fix: retry logic for stream processing errors in agent Stream function (#75)

casidiablo · web-flow · commit ddf3ee096969 · 2025-11-21T10:49:00.000-03:00
diff --git a/agent.go b/agent.go
@@ -16,6 +16,12 @@ type StepResult struct {
 	Messages []Message
 }
 
+// stepExecutionResult encapsulates the result of executing a step with stream processing.
+type stepExecutionResult struct {
+	StepResult     StepResult
+	ShouldContinue bool
+}
+
 // StopCondition defines a function that determines when an agent should stop executing.
 type StopCondition = func(steps []StepResult) bool
 
@@ -736,6 +742,7 @@ func (a *agent) Stream(ctx context.Context, opts AgentStreamCall) (*AgentResult,
 		ActiveTools:      opts.ActiveTools,
 		ProviderOptions:  opts.ProviderOptions,
 		MaxRetries:       opts.MaxRetries,
+		OnRetry:          opts.OnRetry,
 		StopWhen:         opts.StopWhen,
 		PrepareStep:      opts.PrepareStep,
 		RepairToolCall:   opts.RepairToolCall,
@@ -829,48 +836,51 @@ func (a *agent) Stream(ctx context.Context, opts AgentStreamCall) (*AgentResult,
 			ProviderOptions:  call.ProviderOptions,
 		}
 
-		// Get streaming response with retry logic
+		// Execute step with retry logic wrapping both stream creation and processing
 		retryOptions := DefaultRetryOptions()
 		if call.MaxRetries != nil {
 			retryOptions.MaxRetries = *call.MaxRetries
 		}
 		retryOptions.OnRetry = call.OnRetry
-		retry := RetryWithExponentialBackoffRespectingRetryHeaders[StreamResponse](retryOptions)
+		retry := RetryWithExponentialBackoffRespectingRetryHeaders[stepExecutionResult](retryOptions)
 
-		stream, err := retry(ctx, func() (StreamResponse, error) {
-			return stepModel.Stream(ctx, streamCall)
-		})
-		if err != nil {
-			if opts.OnError != nil {
-				opts.OnError(err)
+		result, err := retry(ctx, func() (stepExecutionResult, error) {
+			// Create the stream
+			stream, err := stepModel.Stream(ctx, streamCall)
+			if err != nil {
+				return stepExecutionResult{}, err
+			}
+
+			// Process the stream
+			result, err := a.processStepStream(ctx, stream, opts, steps)
+			if err != nil {
+				return stepExecutionResult{}, err
 			}
-			return nil, err
-		}
 
-		// Process stream with tool execution
-		stepResult, shouldContinue, err := a.processStepStream(ctx, stream, opts, steps)
+			return result, nil
+		})
 		if err != nil {
 			if opts.OnError != nil {
 				opts.OnError(err)
 			}
 			return nil, err
 		}
 
-		steps = append(steps, stepResult)
-		totalUsage = addUsage(totalUsage, stepResult.Usage)
+		steps = append(steps, result.StepResult)
+		totalUsage = addUsage(totalUsage, result.StepResult.Usage)
 
 		// Call step finished callback
 		if opts.OnStepFinish != nil {
-			_ = opts.OnStepFinish(stepResult)
+			_ = opts.OnStepFinish(result.StepResult)
 		}
 
 		// Add step messages to response messages
-		stepMessages := toResponseMessages(stepResult.Content)
+		stepMessages := toResponseMessages(result.StepResult.Content)
 		responseMessages = append(responseMessages, stepMessages...)
 
 		// Check stop conditions
 		shouldStop := isStopConditionMet(call.StopWhen, steps)
-		if shouldStop || !shouldContinue {
+		if shouldStop || !result.ShouldContinue {
 			break
 		}
 	}
@@ -1088,7 +1098,7 @@ func WithOnRetry(callback OnRetryCallback) AgentOption {
 }
 
 // processStepStream processes a single step's stream and returns the step result.
-func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, opts AgentStreamCall, _ []StepResult) (StepResult, bool, error) {
+func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, opts AgentStreamCall, _ []StepResult) (stepExecutionResult, error) {
 	var stepContent []Content
 	var stepToolCalls []ToolCallContent
 	var stepUsage Usage
@@ -1110,7 +1120,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 		if opts.OnChunk != nil {
 			err := opts.OnChunk(part)
 			if err != nil {
-				return StepResult{}, false, err
+				return stepExecutionResult{}, err
 			}
 		}
 
@@ -1120,7 +1130,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 			if opts.OnWarnings != nil {
 				err := opts.OnWarnings(part.Warnings)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
@@ -1129,7 +1139,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 			if opts.OnTextStart != nil {
 				err := opts.OnTextStart(part.ID)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
@@ -1140,7 +1150,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 			if opts.OnTextDelta != nil {
 				err := opts.OnTextDelta(part.ID, part.Delta)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
@@ -1155,7 +1165,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 			if opts.OnTextEnd != nil {
 				err := opts.OnTextEnd(part.ID)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
@@ -1168,7 +1178,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 				}
 				err := opts.OnReasoningStart(part.ID, content)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
@@ -1181,7 +1191,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 			if opts.OnReasoningDelta != nil {
 				err := opts.OnReasoningDelta(part.ID, part.Delta)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
@@ -1198,7 +1208,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 				if opts.OnReasoningEnd != nil {
 					err := opts.OnReasoningEnd(part.ID, content)
 					if err != nil {
-						return StepResult{}, false, err
+						return stepExecutionResult{}, err
 					}
 				}
 				delete(activeReasoningContent, part.ID)
@@ -1214,7 +1224,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 			if opts.OnToolInputStart != nil {
 				err := opts.OnToolInputStart(part.ID, part.ToolCallName)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
@@ -1225,15 +1235,15 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 			if opts.OnToolInputDelta != nil {
 				err := opts.OnToolInputDelta(part.ID, part.Delta)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
 		case StreamPartTypeToolInputEnd:
 			if opts.OnToolInputEnd != nil {
 				err := opts.OnToolInputEnd(part.ID)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
@@ -1254,7 +1264,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 			if opts.OnToolCall != nil {
 				err := opts.OnToolCall(validatedToolCall)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
@@ -1273,7 +1283,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 			if opts.OnSource != nil {
 				err := opts.OnSource(sourceContent)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
@@ -1284,15 +1294,12 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 			if opts.OnStreamFinish != nil {
 				err := opts.OnStreamFinish(part.Usage, part.FinishReason, part.ProviderMetadata)
 				if err != nil {
-					return StepResult{}, false, err
+					return stepExecutionResult{}, err
 				}
 			}
 
 		case StreamPartTypeError:
-			if opts.OnError != nil {
-				opts.OnError(part.Error)
-			}
-			return StepResult{}, false, part.Error
+			return stepExecutionResult{}, part.Error
 		}
 	}
 
@@ -1302,7 +1309,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 		var err error
 		toolResults, err = a.executeTools(ctx, a.settings.tools, stepToolCalls, opts.OnToolResult)
 		if err != nil {
-			return StepResult{}, false, err
+			return stepExecutionResult{}, err
 		}
 		// Add tool results to content
 		for _, result := range toolResults {
@@ -1324,7 +1331,10 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op
 	// Determine if we should continue (has tool calls and not stopped)
 	shouldContinue := len(stepToolCalls) > 0 && stepFinishReason == FinishReasonToolCalls
 
-	return stepResult, shouldContinue, nil
+	return stepExecutionResult{
+		StepResult:     stepResult,
+		ShouldContinue: shouldContinue,
+	}, nil
 }
 
 func addUsage(a, b Usage) Usage {

Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,12 @@ type StepResult struct {`
`16`	`16`	`Messages []Message`
`17`	`17`	`}`
`18`	`18`
	`19`	`+// stepExecutionResult encapsulates the result of executing a step with stream processing.`
	`20`	`+type stepExecutionResult struct {`
	`21`	`+ StepResult StepResult`
	`22`	`+ ShouldContinue bool`
	`23`	`+}`
	`24`	`+`
`19`	`25`	`// StopCondition defines a function that determines when an agent should stop executing.`
`20`	`26`	`type StopCondition = func(steps []StepResult) bool`
`21`	`27`
`@@ -736,6 +742,7 @@ func (a agent) Stream(ctx context.Context, opts AgentStreamCall) (AgentResult,`
`736`	`742`	`ActiveTools: opts.ActiveTools,`
`737`	`743`	`ProviderOptions: opts.ProviderOptions,`
`738`	`744`	`MaxRetries: opts.MaxRetries,`
	`745`	`+ OnRetry: opts.OnRetry,`
`739`	`746`	`StopWhen: opts.StopWhen,`
`740`	`747`	`PrepareStep: opts.PrepareStep,`
`741`	`748`	`RepairToolCall: opts.RepairToolCall,`
`@@ -829,48 +836,51 @@ func (a agent) Stream(ctx context.Context, opts AgentStreamCall) (AgentResult,`
`829`	`836`	`ProviderOptions: call.ProviderOptions,`
`830`	`837`	`}`
`831`	`838`
`832`		`- // Get streaming response with retry logic`
	`839`	`+ // Execute step with retry logic wrapping both stream creation and processing`
`833`	`840`	`retryOptions := DefaultRetryOptions()`
`834`	`841`	`if call.MaxRetries != nil {`
`835`	`842`	`retryOptions.MaxRetries = *call.MaxRetries`
`836`	`843`	`}`
`837`	`844`	`retryOptions.OnRetry = call.OnRetry`
`838`		`- retry := RetryWithExponentialBackoffRespectingRetryHeaders[StreamResponse](retryOptions)`
	`845`	`+ retry := RetryWithExponentialBackoffRespectingRetryHeaders[stepExecutionResult](retryOptions)`
`839`	`846`
`840`		`- stream, err := retry(ctx, func() (StreamResponse, error) {`
`841`		`- return stepModel.Stream(ctx, streamCall)`
`842`		`- })`
`843`		`- if err != nil {`
`844`		`- if opts.OnError != nil {`
`845`		`- opts.OnError(err)`
	`847`	`+ result, err := retry(ctx, func() (stepExecutionResult, error) {`
	`848`	`+ // Create the stream`
	`849`	`+ stream, err := stepModel.Stream(ctx, streamCall)`
	`850`	`+ if err != nil {`
	`851`	`+ return stepExecutionResult{}, err`
	`852`	`+ }`
	`853`	`+`
	`854`	`+ // Process the stream`
	`855`	`+ result, err := a.processStepStream(ctx, stream, opts, steps)`
	`856`	`+ if err != nil {`
	`857`	`+ return stepExecutionResult{}, err`
`846`	`858`	`}`
`847`		`- return nil, err`
`848`		`- }`
`849`	`859`
`850`		`- // Process stream with tool execution`
`851`		`- stepResult, shouldContinue, err := a.processStepStream(ctx, stream, opts, steps)`
	`860`	`+ return result, nil`
	`861`	`+ })`
`852`	`862`	`if err != nil {`
`853`	`863`	`if opts.OnError != nil {`
`854`	`864`	`opts.OnError(err)`
`855`	`865`	`}`
`856`	`866`	`return nil, err`
`857`	`867`	`}`
`858`	`868`
`859`		`- steps = append(steps, stepResult)`
`860`		`- totalUsage = addUsage(totalUsage, stepResult.Usage)`
	`869`	`+ steps = append(steps, result.StepResult)`
	`870`	`+ totalUsage = addUsage(totalUsage, result.StepResult.Usage)`
`861`	`871`
`862`	`872`	`// Call step finished callback`
`863`	`873`	`if opts.OnStepFinish != nil {`
`864`		`- _ = opts.OnStepFinish(stepResult)`
	`874`	`+ _ = opts.OnStepFinish(result.StepResult)`
`865`	`875`	`}`
`866`	`876`
`867`	`877`	`// Add step messages to response messages`
`868`		`- stepMessages := toResponseMessages(stepResult.Content)`
	`878`	`+ stepMessages := toResponseMessages(result.StepResult.Content)`
`869`	`879`	`responseMessages = append(responseMessages, stepMessages...)`
`870`	`880`
`871`	`881`	`// Check stop conditions`
`872`	`882`	`shouldStop := isStopConditionMet(call.StopWhen, steps)`
`873`		`- if shouldStop \|\| !shouldContinue {`
	`883`	`+ if shouldStop \|\| !result.ShouldContinue {`
`874`	`884`	`break`
`875`	`885`	`}`
`876`	`886`	`}`
`@@ -1088,7 +1098,7 @@ func WithOnRetry(callback OnRetryCallback) AgentOption {`
`1088`	`1098`	`}`
`1089`	`1099`
`1090`	`1100`	`// processStepStream processes a single step's stream and returns the step result.`
`1091`		`-func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, opts AgentStreamCall, _ []StepResult) (StepResult, bool, error) {`
	`1101`	`+func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, opts AgentStreamCall, _ []StepResult) (stepExecutionResult, error) {`
`1092`	`1102`	`var stepContent []Content`
`1093`	`1103`	`var stepToolCalls []ToolCallContent`
`1094`	`1104`	`var stepUsage Usage`
`@@ -1110,7 +1120,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1110`	`1120`	`if opts.OnChunk != nil {`
`1111`	`1121`	`err := opts.OnChunk(part)`
`1112`	`1122`	`if err != nil {`
`1113`		`- return StepResult{}, false, err`
	`1123`	`+ return stepExecutionResult{}, err`
`1114`	`1124`	`}`
`1115`	`1125`	`}`
`1116`	`1126`
`@@ -1120,7 +1130,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1120`	`1130`	`if opts.OnWarnings != nil {`
`1121`	`1131`	`err := opts.OnWarnings(part.Warnings)`
`1122`	`1132`	`if err != nil {`
`1123`		`- return StepResult{}, false, err`
	`1133`	`+ return stepExecutionResult{}, err`
`1124`	`1134`	`}`
`1125`	`1135`	`}`
`1126`	`1136`
`@@ -1129,7 +1139,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1129`	`1139`	`if opts.OnTextStart != nil {`
`1130`	`1140`	`err := opts.OnTextStart(part.ID)`
`1131`	`1141`	`if err != nil {`
`1132`		`- return StepResult{}, false, err`
	`1142`	`+ return stepExecutionResult{}, err`
`1133`	`1143`	`}`
`1134`	`1144`	`}`
`1135`	`1145`
`@@ -1140,7 +1150,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1140`	`1150`	`if opts.OnTextDelta != nil {`
`1141`	`1151`	`err := opts.OnTextDelta(part.ID, part.Delta)`
`1142`	`1152`	`if err != nil {`
`1143`		`- return StepResult{}, false, err`
	`1153`	`+ return stepExecutionResult{}, err`
`1144`	`1154`	`}`
`1145`	`1155`	`}`
`1146`	`1156`
`@@ -1155,7 +1165,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1155`	`1165`	`if opts.OnTextEnd != nil {`
`1156`	`1166`	`err := opts.OnTextEnd(part.ID)`
`1157`	`1167`	`if err != nil {`
`1158`		`- return StepResult{}, false, err`
	`1168`	`+ return stepExecutionResult{}, err`
`1159`	`1169`	`}`
`1160`	`1170`	`}`
`1161`	`1171`
`@@ -1168,7 +1178,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1168`	`1178`	`}`
`1169`	`1179`	`err := opts.OnReasoningStart(part.ID, content)`
`1170`	`1180`	`if err != nil {`
`1171`		`- return StepResult{}, false, err`
	`1181`	`+ return stepExecutionResult{}, err`
`1172`	`1182`	`}`
`1173`	`1183`	`}`
`1174`	`1184`
`@@ -1181,7 +1191,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1181`	`1191`	`if opts.OnReasoningDelta != nil {`
`1182`	`1192`	`err := opts.OnReasoningDelta(part.ID, part.Delta)`
`1183`	`1193`	`if err != nil {`
`1184`		`- return StepResult{}, false, err`
	`1194`	`+ return stepExecutionResult{}, err`
`1185`	`1195`	`}`
`1186`	`1196`	`}`
`1187`	`1197`
`@@ -1198,7 +1208,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1198`	`1208`	`if opts.OnReasoningEnd != nil {`
`1199`	`1209`	`err := opts.OnReasoningEnd(part.ID, content)`
`1200`	`1210`	`if err != nil {`
`1201`		`- return StepResult{}, false, err`
	`1211`	`+ return stepExecutionResult{}, err`
`1202`	`1212`	`}`
`1203`	`1213`	`}`
`1204`	`1214`	`delete(activeReasoningContent, part.ID)`
`@@ -1214,7 +1224,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1214`	`1224`	`if opts.OnToolInputStart != nil {`
`1215`	`1225`	`err := opts.OnToolInputStart(part.ID, part.ToolCallName)`
`1216`	`1226`	`if err != nil {`
`1217`		`- return StepResult{}, false, err`
	`1227`	`+ return stepExecutionResult{}, err`
`1218`	`1228`	`}`
`1219`	`1229`	`}`
`1220`	`1230`
`@@ -1225,15 +1235,15 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1225`	`1235`	`if opts.OnToolInputDelta != nil {`
`1226`	`1236`	`err := opts.OnToolInputDelta(part.ID, part.Delta)`
`1227`	`1237`	`if err != nil {`
`1228`		`- return StepResult{}, false, err`
	`1238`	`+ return stepExecutionResult{}, err`
`1229`	`1239`	`}`
`1230`	`1240`	`}`
`1231`	`1241`
`1232`	`1242`	`case StreamPartTypeToolInputEnd:`
`1233`	`1243`	`if opts.OnToolInputEnd != nil {`
`1234`	`1244`	`err := opts.OnToolInputEnd(part.ID)`
`1235`	`1245`	`if err != nil {`
`1236`		`- return StepResult{}, false, err`
	`1246`	`+ return stepExecutionResult{}, err`
`1237`	`1247`	`}`
`1238`	`1248`	`}`
`1239`	`1249`
`@@ -1254,7 +1264,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1254`	`1264`	`if opts.OnToolCall != nil {`
`1255`	`1265`	`err := opts.OnToolCall(validatedToolCall)`
`1256`	`1266`	`if err != nil {`
`1257`		`- return StepResult{}, false, err`
	`1267`	`+ return stepExecutionResult{}, err`
`1258`	`1268`	`}`
`1259`	`1269`	`}`
`1260`	`1270`
`@@ -1273,7 +1283,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1273`	`1283`	`if opts.OnSource != nil {`
`1274`	`1284`	`err := opts.OnSource(sourceContent)`
`1275`	`1285`	`if err != nil {`
`1276`		`- return StepResult{}, false, err`
	`1286`	`+ return stepExecutionResult{}, err`
`1277`	`1287`	`}`
`1278`	`1288`	`}`
`1279`	`1289`
`@@ -1284,15 +1294,12 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1284`	`1294`	`if opts.OnStreamFinish != nil {`
`1285`	`1295`	`err := opts.OnStreamFinish(part.Usage, part.FinishReason, part.ProviderMetadata)`
`1286`	`1296`	`if err != nil {`
`1287`		`- return StepResult{}, false, err`
	`1297`	`+ return stepExecutionResult{}, err`
`1288`	`1298`	`}`
`1289`	`1299`	`}`
`1290`	`1300`
`1291`	`1301`	`case StreamPartTypeError:`
`1292`		`- if opts.OnError != nil {`
`1293`		`- opts.OnError(part.Error)`
`1294`		`- }`
`1295`		`- return StepResult{}, false, part.Error`
	`1302`	`+ return stepExecutionResult{}, part.Error`
`1296`	`1303`	`}`
`1297`	`1304`	`}`
`1298`	`1305`
`@@ -1302,7 +1309,7 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1302`	`1309`	`var err error`
`1303`	`1310`	`toolResults, err = a.executeTools(ctx, a.settings.tools, stepToolCalls, opts.OnToolResult)`
`1304`	`1311`	`if err != nil {`
`1305`		`- return StepResult{}, false, err`
	`1312`	`+ return stepExecutionResult{}, err`
`1306`	`1313`	`}`
`1307`	`1314`	`// Add tool results to content`
`1308`	`1315`	`for _, result := range toolResults {`
`@@ -1324,7 +1331,10 @@ func (a *agent) processStepStream(ctx context.Context, stream StreamResponse, op`
`1324`	`1331`	`// Determine if we should continue (has tool calls and not stopped)`
`1325`	`1332`	`shouldContinue := len(stepToolCalls) > 0 && stepFinishReason == FinishReasonToolCalls`
`1326`	`1333`
`1327`		`- return stepResult, shouldContinue, nil`
	`1334`	`+ return stepExecutionResult{`
	`1335`	`+ StepResult: stepResult,`
	`1336`	`+ ShouldContinue: shouldContinue,`
	`1337`	`+ }, nil`
`1328`	`1338`	`}`
`1329`	`1339`
`1330`	`1340`	`func addUsage(a, b Usage) Usage {`