Add phase 6 features: tool timeout/isEnabled, RunHooks, tool guardrails, handoff inputType/inputFilter/isEnabled, hosted tool streaming, fileSearchTool, computerUseTool, new model settings, toolUseBehavior function variant, toolErrorFormatter, callModelInputFilter, resetToolChoice, errorHandlers

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: tylergibbs1

src/azure/chat-completions-model.ts

@@ -205,6 +205,11 @@ export class AzureChatCompletionsModel implements Model {
 			if (s.seed !== undefined) body.seed = s.seed;
 			if (s.reasoningEffort !== undefined) body.reasoning_effort = s.reasoningEffort;
 			if (s.promptCacheKey !== undefined) body.prompt_cache_key = s.promptCacheKey;
+			if (s.store !== undefined) body.store = s.store;
+			if (s.metadata !== undefined) body.metadata = s.metadata;
+			if (s.user !== undefined) body.user = s.user;
+			if (s.logprobs !== undefined) body.logprobs = s.logprobs;
+			if (s.topLogprobs !== undefined) body.top_logprobs = s.topLogprobs;
 		}
 
 		return body;
@@ -351,15 +356,15 @@ function serializeMessage(msg: ChatMessage): Record<string, unknown> {
 interface AzureChatResponse {
 	choices: {
 		message: {
-			role: string;
+			role: "assistant";
 			content: string | null;
 			tool_calls?: {
 				id: string;
-				type: string;
+				type: "function";
 				function: { name: string; arguments: string };
 			}[];
 		};
-		finish_reason: string;
+		finish_reason: FinishReason | string;
 	}[];
 	usage?: {
 		prompt_tokens: number;
@@ -384,19 +389,19 @@ interface AzureErrorResponse {
 interface AzureStreamChunk {
 	choices?: {
 		delta?: {
-			role?: string;
+			role?: "assistant";
 			content?: string;
 			tool_calls?: {
 				index: number;
 				id?: string;
-				type?: string;
+				type?: "function";
 				function?: {
 					name?: string;
 					arguments?: string;
 				};
 			}[];
 		};
-		finish_reason?: string;
+		finish_reason?: FinishReason | string;
 	}[];
 	usage?: {
 		prompt_tokens: number;

src/azure/responses-model.ts

@@ -31,6 +31,22 @@ export interface AzureResponsesModelConfig {
 
 const DEFAULT_API_VERSION = "2025-04-01-preview";
 
+type HostedToolStatus = "in_progress" | "completed" | "searching" | "generating" | "interpreting";
+const HOSTED_TOOL_EVENT_MAP = new Map<string, { toolType: string; status: HostedToolStatus }>([
+	["response.web_search_call.in_progress", { toolType: "web_search", status: "in_progress" }],
+	["response.web_search_call.searching", { toolType: "web_search", status: "searching" }],
+	["response.web_search_call.completed", { toolType: "web_search", status: "completed" }],
+	["response.file_search_call.in_progress", { toolType: "file_search", status: "in_progress" }],
+	["response.file_search_call.searching", { toolType: "file_search", status: "searching" }],
+	["response.file_search_call.completed", { toolType: "file_search", status: "completed" }],
+	["response.code_interpreter_call.in_progress", { toolType: "code_interpreter", status: "in_progress" }],
+	["response.code_interpreter_call.interpreting", { toolType: "code_interpreter", status: "interpreting" }],
+	["response.code_interpreter_call.completed", { toolType: "code_interpreter", status: "completed" }],
+	["response.image_generation_call.in_progress", { toolType: "image_generation", status: "in_progress" }],
+	["response.image_generation_call.generating", { toolType: "image_generation", status: "generating" }],
+	["response.image_generation_call.completed", { toolType: "image_generation", status: "completed" }],
+]);
+
 export class AzureResponsesModel implements Model {
 	private readonly url: string;
 	private readonly apiKey?: string;
@@ -149,6 +165,25 @@ export class AzureResponsesModel implements Model {
 					}
 					break;
 				}
+				// Hosted tool streaming events
+				case "response.web_search_call.in_progress":
+				case "response.web_search_call.searching":
+				case "response.web_search_call.completed":
+				case "response.file_search_call.in_progress":
+				case "response.file_search_call.searching":
+				case "response.file_search_call.completed":
+				case "response.code_interpreter_call.in_progress":
+				case "response.code_interpreter_call.interpreting":
+				case "response.code_interpreter_call.completed":
+				case "response.image_generation_call.in_progress":
+				case "response.image_generation_call.generating":
+				case "response.image_generation_call.completed": {
+					const mapped = HOSTED_TOOL_EVENT_MAP.get(event.type);
+					if (mapped) {
+						yield { type: "hosted_tool_call", toolType: mapped.toolType, status: mapped.status };
+					}
+					break;
+				}
 				case "response.completed": {
 					const resp = event.response;
 					if (resp?.id) {
@@ -170,6 +205,29 @@ export class AzureResponsesModel implements Model {
 					finishReason = mapStatus(resp?.status);
 					break;
 				}
+				case "response.failed": {
+					const errorMsg = event.response?.error?.message
+						?? "Response failed";
+					throw new ModelError(
+						`Azure API response failed: ${errorMsg}`,
+						{ status: 200 },
+					);
+				}
+				case "error": {
+					const err = event.error;
+					const errorType = err?.type ?? "unknown";
+					const errorMsg = err?.message ?? "Unknown error";
+					if (errorType === "too_many_requests") {
+						throw new ModelError(
+							`Azure API rate limited (SSE): ${errorMsg}`,
+							{ status: 429 },
+						);
+					}
+					throw new ModelError(
+						`Azure API stream error (${errorType}): ${errorMsg}`,
+						{ status: 200 },
+					);
+				}
 			}
 		}
 
@@ -195,9 +253,11 @@ export class AzureResponsesModel implements Model {
 		request: ModelRequest,
 		stream: boolean,
 	): Record<string, unknown> {
+		// ModelSettings.store overrides config-level store
+		const effectiveStore = request.modelSettings?.store ?? this.store;
 		const body: Record<string, unknown> = {
 			model: this.deployment,
-			store: this.store,
+			store: effectiveStore,
 		};
 
 		const { instructions, input } = convertMessages(request.messages);
@@ -227,23 +287,33 @@ export class AzureResponsesModel implements Model {
 		}
 
 		// Only send previous_response_id when store is enabled (API needs to persist responses)
-		if (this.store && request.previousResponseId) {
+		if (effectiveStore && request.previousResponseId) {
 			body.previous_response_id = request.previousResponseId;
 		}
 
 		const s = request.modelSettings;
 		if (s) {
 			if (s.temperature !== undefined) body.temperature = s.temperature;
 			if (s.topP !== undefined) body.top_p = s.topP;
-			if (s.maxTokens !== undefined) body.max_output_tokens = s.maxTokens;
-			if (s.maxCompletionTokens !== undefined)
+			if (s.maxCompletionTokens !== undefined) {
 				body.max_output_tokens = s.maxCompletionTokens;
+			} else if (s.maxTokens !== undefined) {
+				body.max_output_tokens = s.maxTokens;
+			}
 			if (s.toolChoice !== undefined) body.tool_choice = convertToolChoice(s.toolChoice);
 			if (s.parallelToolCalls !== undefined) body.parallel_tool_calls = s.parallelToolCalls;
-			if (s.reasoningEffort !== undefined)
-				body.reasoning = { effort: s.reasoningEffort };
+			if (s.reasoningEffort !== undefined || s.reasoningSummary !== undefined) {
+				const reasoning: Record<string, unknown> = {};
+				if (s.reasoningEffort !== undefined) reasoning.effort = s.reasoningEffort;
+				if (s.reasoningSummary !== undefined) reasoning.summary = s.reasoningSummary;
+				body.reasoning = reasoning;
+			}
 			if (s.promptCacheKey !== undefined)
 				body.prompt_cache_key = s.promptCacheKey;
+			if (s.truncation !== undefined) body.truncation = s.truncation;
+			if (s.store !== undefined) body.store = s.store;
+			if (s.metadata !== undefined) body.metadata = s.metadata;
+			if (s.user !== undefined) body.user = s.user;
 		}
 
 		return body;
@@ -569,4 +639,20 @@ type ResponsesStreamEvent =
 	| { type: "response.output_item.added"; item?: ResponsesStreamItem }
 	| { type: "response.function_call_arguments.delta"; item_id?: string; delta?: string }
 	| { type: "response.output_item.done"; item?: ResponsesStreamItem }
-	| { type: "response.completed"; response?: { id?: string; status?: string; usage?: ResponsesUsage } };
+	| { type: "response.completed"; response?: { id?: string; status?: string; usage?: ResponsesUsage } }
+	// Hosted tool streaming events
+	| { type: "response.web_search_call.in_progress" }
+	| { type: "response.web_search_call.searching" }
+	| { type: "response.web_search_call.completed" }
+	| { type: "response.file_search_call.in_progress" }
+	| { type: "response.file_search_call.searching" }
+	| { type: "response.file_search_call.completed" }
+	| { type: "response.code_interpreter_call.in_progress" }
+	| { type: "response.code_interpreter_call.interpreting" }
+	| { type: "response.code_interpreter_call.completed" }
+	| { type: "response.image_generation_call.in_progress" }
+	| { type: "response.image_generation_call.generating" }
+	| { type: "response.image_generation_call.completed" }
+	// Error / failure events (e.g. SSE-level 429)
+	| { type: "response.failed"; response?: { id?: string; status?: string; error?: { message?: string; type?: string; code?: string } } }
+	| { type: "error"; error?: { type?: string; code?: string; message?: string } };

src/core/builtin-tools.ts

@@ -81,3 +81,42 @@ export function imageGenerationTool(): HostedTool {
 		},
 	};
 }
+
+export interface FileSearchToolConfig {
+	vectorStoreIds: string[];
+	maxNumResults?: number;
+}
+
+export function fileSearchTool(config: FileSearchToolConfig): HostedTool {
+	const definition: HostedToolDefinition = {
+		type: "file_search",
+		vector_store_ids: config.vectorStoreIds,
+	};
+	if (config.maxNumResults !== undefined) {
+		definition.max_num_results = config.maxNumResults;
+	}
+	return {
+		type: "hosted",
+		name: "file_search",
+		definition,
+	};
+}
+
+export interface ComputerUseToolConfig {
+	displayWidth: number;
+	displayHeight: number;
+	environment?: "windows" | "mac" | "linux";
+}
+
+export function computerUseTool(config: ComputerUseToolConfig): HostedTool {
+	return {
+		type: "hosted",
+		name: "computer_use_preview",
+		definition: {
+			type: "computer_use_preview",
+			display_width: config.displayWidth,
+			display_height: config.displayHeight,
+			environment: config.environment ?? "linux",
+		},
+	};
+}

src/core/errors.ts

@@ -73,6 +73,18 @@ export class MaxBudgetExceededError extends StratusError {
 	}
 }
 
+export class ToolTimeoutError extends StratusError {
+	readonly toolName: string;
+	readonly timeoutMs: number;
+
+	constructor(toolName: string, timeoutMs: number) {
+		super(`Tool "${toolName}" timed out after ${timeoutMs}ms`);
+		this.name = "ToolTimeoutError";
+		this.toolName = toolName;
+		this.timeoutMs = timeoutMs;
+	}
+}
+
 export class OutputGuardrailTripwireTriggered extends StratusError {
 	readonly guardrailName: string;
 	readonly outputInfo?: unknown;

src/core/guardrails.ts

@@ -8,6 +8,11 @@ export interface GuardrailResult {
 	outputInfo?: unknown;
 }
 
+export interface GuardrailRunResult {
+	guardrailName: string;
+	result: GuardrailResult;
+}
+
 export interface InputGuardrail<TContext = unknown> {
 	name: string;
 	execute: (input: string, context: TContext) => GuardrailResult | Promise<GuardrailResult>;
@@ -18,40 +23,96 @@ export interface OutputGuardrail<TContext = unknown> {
 	execute: (output: string, context: TContext) => GuardrailResult | Promise<GuardrailResult>;
 }
 
+/** Guardrail that runs before a tool call */
+export interface ToolInputGuardrail<TContext = unknown> {
+	name: string;
+	execute: (params: {
+		toolName: string;
+		toolArgs: Record<string, unknown>;
+		context: TContext;
+	}) => GuardrailResult | Promise<GuardrailResult>;
+}
+
+/** Guardrail that runs after a tool call */
+export interface ToolOutputGuardrail<TContext = unknown> {
+	name: string;
+	execute: (params: {
+		toolName: string;
+		toolResult: string;
+		context: TContext;
+	}) => GuardrailResult | Promise<GuardrailResult>;
+}
+
 export async function runInputGuardrails<TContext>(
 	guardrails: InputGuardrail<TContext>[],
 	input: string,
 	context: TContext,
-): Promise<void> {
+): Promise<GuardrailRunResult[]> {
 	const results = await Promise.all(
 		guardrails.map(async (g) => {
 			const result = await g.execute(input, context);
-			return { guardrail: g, result };
+			return { guardrailName: g.name, result };
 		}),
 	);
 
-	for (const { guardrail, result } of results) {
+	for (const { guardrailName, result } of results) {
 		if (result.tripwireTriggered) {
-			throw new InputGuardrailTripwireTriggered(guardrail.name, result.outputInfo);
+			throw new InputGuardrailTripwireTriggered(guardrailName, result.outputInfo);
 		}
 	}
+
+	return results;
 }
 
 export async function runOutputGuardrails<TContext>(
 	guardrails: OutputGuardrail<TContext>[],
 	output: string,
 	context: TContext,
-): Promise<void> {
+): Promise<GuardrailRunResult[]> {
 	const results = await Promise.all(
 		guardrails.map(async (g) => {
 			const result = await g.execute(output, context);
-			return { guardrail: g, result };
+			return { guardrailName: g.name, result };
 		}),
 	);
 
-	for (const { guardrail, result } of results) {
+	for (const { guardrailName, result } of results) {
 		if (result.tripwireTriggered) {
-			throw new OutputGuardrailTripwireTriggered(guardrail.name, result.outputInfo);
+			throw new OutputGuardrailTripwireTriggered(guardrailName, result.outputInfo);
 		}
 	}
+
+	return results;
+}
+
+export async function runToolInputGuardrails<TContext>(
+	guardrails: ToolInputGuardrail<TContext>[],
+	toolName: string,
+	toolArgs: Record<string, unknown>,
+	context: TContext,
+): Promise<GuardrailRunResult[]> {
+	const results = await Promise.all(
+		guardrails.map(async (g) => {
+			const result = await g.execute({ toolName, toolArgs, context });
+			return { guardrailName: g.name, result };
+		}),
+	);
+
+	return results;
+}
+
+export async function runToolOutputGuardrails<TContext>(
+	guardrails: ToolOutputGuardrail<TContext>[],
+	toolName: string,
+	toolResult: string,
+	context: TContext,
+): Promise<GuardrailRunResult[]> {
+	const results = await Promise.all(
+		guardrails.map(async (g) => {
+			const result = await g.execute({ toolName, toolResult, context });
+			return { guardrailName: g.name, result };
+		}),
+	);
+
+	return results;
 }