@keystrokehq/keystroke 0.1.36 → 0.1.37

package/dist/agent.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_dist = require("./dist-BkxEtBJy.cjs");
 const require_dist$1 = require("./dist-Cy042cqb.cjs");
-const require_dist$2 = require("./dist-Di6PqKAu.cjs");
+const require_dist$2 = require("./dist-DlIUXcOB.cjs");
 const require_dist$3 = require("./dist-BBGCAuTi.cjs");
 let zod = require("zod");
 let node_async_hooks = require("node:async_hooks");
@@ -1171,6 +1171,85 @@ function llmUsageFromLanguageModelUsage(usage, resolved, options) {
 		}
 	};
 }
+/** Synthetic tool name for structured output when responseFormat is unreliable. */
+const STRUCTURED_OUTPUT_SUBMIT_TOOL_NAME = "submit_structured_output";
+const SUBMIT_TOOL_VENDORS = new Set([
+	"zai",
+	"minimax",
+	"alibaba",
+	"deepseek"
+]);
+function structuredOutputSubmitToolVendor(modelId) {
+	const { vendor } = splitAgentModelId(modelId);
+	return SUBMIT_TOOL_VENDORS.has(vendor);
+}
+/**
+* Use a submit tool instead of responseFormat.
+*
+* - Agent + tools: z-ai GLM only (native json mode works for schema-only agent calls).
+* - promptLlm: z-ai, minimax, alibaba, and deepseek — no gateway endpoint exposes reliable
+*   response_format, so schema-only `generateObject` fails validation.
+*/
+function usesStructuredOutputSubmitTool(args) {
+	if (!args.structuredOutput || !structuredOutputSubmitToolVendor(args.modelId)) return false;
+	if (args.promptLlm) return true;
+	const { vendor } = splitAgentModelId(args.modelId);
+	return (vendor === "zai" || vendor === "alibaba") && (args.hasTools ?? false);
+}
+function appendStructuredOutputSubmitTool(tools, schema) {
+	return {
+		...tools,
+		[STRUCTURED_OUTPUT_SUBMIT_TOOL_NAME]: require_dist$2.tool({
+			description: "Submit the final structured result after completing any required tool calls. Include every required schema field.",
+			inputSchema: schema,
+			execute: async (input) => input
+		})
+	};
+}
+function resolveStructuredOutputStopWhen(args) {
+	if (!usesStructuredOutputSubmitTool(args)) return;
+	return require_dist$2.hasToolCall(STRUCTURED_OUTPUT_SUBMIT_TOOL_NAME);
+}
+function extractStructuredOutputFromSubmitTool(args) {
+	for (let index = args.steps.length - 1; index >= 0; index -= 1) {
+		const step = args.steps[index];
+		if (!step) continue;
+		for (const toolCall of step.toolCalls) if (toolCall.toolName === "submit_structured_output") return args.schema.parse(toolCall.input);
+	}
+}
+/**
+* Alibaba rejects `response_format: json_object` unless messages contain the word "json".
+* Applies when structured output is enabled (including tool-loop steps that carry responseFormat).
+*/
+function augmentInstructionsForStructuredOutput(args) {
+	if (!args.structuredOutput) return args.instructions;
+	const { vendor } = splitAgentModelId(args.modelId);
+	let instructions = args.instructions;
+	const submitTool = usesStructuredOutputSubmitTool({
+		modelId: args.modelId,
+		structuredOutput: args.structuredOutput,
+		hasTools: args.hasTools ?? false,
+		promptLlm: args.promptLlm
+	});
+	if (vendor === "alibaba" && !/\bjson\b/i.test(instructions)) instructions = `${instructions}\n\nWhen returning structured data, output valid json.`;
+	if (submitTool) if (args.hasTools) instructions = `${instructions}\n\nCall the available tools first, then call ${STRUCTURED_OUTPUT_SUBMIT_TOOL_NAME} with the final result matching the schema. Do not return prose or raw json as the final answer.${vendor === "alibaba" ? " Do not return tool arguments or guesses as the final schema." : ""}`;
+	else instructions = `${instructions}\n\nCall ${STRUCTURED_OUTPUT_SUBMIT_TOOL_NAME} with the final result matching the schema. Do not return prose or raw json as the final answer.`;
+	else if (vendor === "zai") instructions = `${instructions}\n\nReturn the final answer as raw json matching the schema with every required field. Do not use markdown, bold, or prose in the structured response.`;
+	return instructions;
+}
+function parseRepairedStructuredOutput(args) {
+	const trimmed = args.text.trim();
+	const candidates = [
+		trimmed,
+		trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)?.[1]?.trim(),
+		trimmed.match(/\{[\s\S]*\}/)?.[0]
+	].filter((value) => Boolean(value));
+	for (const candidate of candidates) try {
+		return args.schema.parse(JSON.parse(candidate));
+	} catch {
+		continue;
+	}
+}
 /**
 * Baked-in AI SDK `providerOptions` a model needs for structured output.
 *
@@ -1190,6 +1269,70 @@ function resolveProviderOptions(args) {
 	const { vendor } = splitAgentModelId(args.modelId);
 	if (vendor === "anthropic") return { anthropic: { structuredOutputMode: "outputFormat" } };
 }
+/**
+* Wrap gateway models that need middleware for reliable structured output parsing.
+*
+* z-ai GLM models often wrap JSON in markdown fences; AI SDK's `extractJsonMiddleware` strips them.
+* See vercel/ai middleware docs and vercel/ai#12491.
+*/
+function wrapLanguageModelForStructuredOutput(args) {
+	if (!args.structuredOutput) return args.languageModel;
+	if (usesStructuredOutputSubmitTool({
+		modelId: args.modelId,
+		structuredOutput: args.structuredOutput,
+		hasTools: args.hasTools ?? false
+	})) return args.languageModel;
+	const { vendor } = splitAgentModelId(args.modelId);
+	if (vendor !== "zai") return args.languageModel;
+	return require_dist$2.wrapLanguageModel({
+		model: args.languageModel,
+		middleware: require_dist$2.extractJsonMiddleware()
+	});
+}
+function needsStructuredOutputToolGuard(modelId) {
+	const { vendor, directId } = splitAgentModelId(modelId);
+	if (vendor === "anthropic") return !directId.includes("haiku");
+	return false;
+}
+/**
+* Vendor-scoped guard for structured output + tools (BUS-2823).
+*
+* Anthropic Sonnet-class models may satisfy structured output on step 1 without calling tools;
+* AI SDK's tool loop then stops. Force `toolChoice: "required"` until the first tool result,
+* then release for the final structured step.
+*
+* Do not generalize: Gemini rejects forced tool choice + schema; Anthropic Haiku rejects forced
+* tool choice + thinking. z-ai GLM uses {@link usesStructuredOutputSubmitTool} instead.
+*/
+function resolveStructuredOutputPrepareStep(args) {
+	if (!args.structuredOutput || !args.hasTools) return;
+	if (!needsStructuredOutputToolGuard(args.modelId)) return;
+	return ({ steps }) => {
+		if (steps.some((step) => step.toolResults.length > 0)) return {};
+		return { toolChoice: "required" };
+	};
+}
+/**
+* Alibaba and minimax thinking mode conflicts with forced tool_choice on structured promptLlm calls.
+*/
+function resolveReasoningForStructuredOutputPromptLlm(args) {
+	if (!usesStructuredOutputSubmitTool({
+		modelId: args.modelId,
+		structuredOutput: args.structuredOutput,
+		promptLlm: true
+	})) return args.thinkingLevel;
+	const { vendor } = splitAgentModelId(args.modelId);
+	if (vendor === "alibaba" || vendor === "minimax") return "none";
+	return args.thinkingLevel;
+}
+/** Alibaba may require the word "json" in user messages when response_format is enabled. */
+function augmentInputForStructuredOutput(args) {
+	if (!args.structuredOutput) return args.input;
+	const { vendor } = splitAgentModelId(args.modelId);
+	if (vendor !== "alibaba") return args.input;
+	if (/\bjson\b/i.test(args.input)) return args.input;
+	return `${args.input}\n\nReturn the final answer as json matching the schema.`;
+}
 /** Plain-text tool error for UI streams, model replay, and JSON persistence. */
 function getToolExecutionErrorMessage(error) {
 	if (error instanceof Error) return error.message;
@@ -1218,7 +1361,11 @@ async function streamAgentPrompt(config, input, options) {
 	const userMessage = {
 		id: require_dist$2.generateId(),
 		role: "user",
-		parts: buildUserMessageParts(input, config.files)
+		parts: buildUserMessageParts(augmentInputForStructuredOutput({
+			input,
+			modelId: config.resolvedModel.modelId,
+			structuredOutput: Boolean(options.outputSchema)
+		}), config.files)
 	};
 	const priorMessages = [...config.messages, userMessage];
 	const newMessages = [userMessage];
@@ -1233,25 +1380,55 @@ async function streamAgentPrompt(config, input, options) {
 	});
 	try {
 		if (config.files?.length && !config.experimentalDownload) throw new Error("Chat attachments require worker storage (STORAGE_* / KEYSTROKE_WORKSPACES_BUCKET)");
-		const aiTools = gateToolSetMedia({
+		let aiTools = gateToolSetMedia({
 			...agentToolsToAiToolSet(config.tools),
 			...config.mcpToolSet
 		}, config.resolvedModel.capabilities);
+		const structuredOutput = Boolean(options.outputSchema);
+		const hasTools = Object.keys(aiTools).length > 0;
+		const submitToolOutput = usesStructuredOutputSubmitTool({
+			modelId: config.resolvedModel.modelId,
+			structuredOutput,
+			hasTools
+		});
+		if (submitToolOutput && options.outputSchema) aiTools = appendStructuredOutputSubmitTool(aiTools, options.outputSchema);
 		let messagesForModel = await applyCapabilityPlaceholderToMessages(priorMessages, config.resolvedModel.capabilities);
 		if (config.experimentalDownload) messagesForModel = await hydrateChatAttachmentMessages(messagesForModel, config.experimentalDownload);
 		const modelMessages = await require_dist$2.convertToModelMessages(messagesForModel);
 		const providerOptions = resolveProviderOptions({
 			modelId: config.resolvedModel.modelId,
-			structuredOutput: Boolean(options.outputSchema)
+			structuredOutput
+		});
+		const prepareStep = resolveStructuredOutputPrepareStep({
+			modelId: config.resolvedModel.modelId,
+			structuredOutput,
+			hasTools
+		});
+		const stopWhen = resolveStructuredOutputStopWhen({
+			modelId: config.resolvedModel.modelId,
+			structuredOutput,
+			hasTools
 		});
 		const streamResult = await new require_dist$2.ToolLoopAgent({
-			model: config.resolvedModel.languageModel,
-			instructions: config.systemPrompt,
+			model: wrapLanguageModelForStructuredOutput({
+				languageModel: config.resolvedModel.languageModel,
+				modelId: config.resolvedModel.modelId,
+				structuredOutput,
+				hasTools
+			}),
+			instructions: augmentInstructionsForStructuredOutput({
+				instructions: config.systemPrompt,
+				modelId: config.resolvedModel.modelId,
+				structuredOutput,
+				hasTools
+			}),
 			tools: aiTools,
 			reasoning: config.thinkingLevel,
 			...config.experimentalDownload ? { experimental_download: config.experimentalDownload } : {},
-			...options.outputSchema ? { output: require_dist$2.output_exports.object({ schema: options.outputSchema }) } : {},
-			...providerOptions ? { providerOptions } : {}
+			...!submitToolOutput && options.outputSchema ? { output: require_dist$2.output_exports.object({ schema: options.outputSchema }) } : {},
+			...providerOptions ? { providerOptions } : {},
+			...prepareStep ? { prepareStep } : {},
+			...stopWhen ? { stopWhen } : {}
 		}).stream({
 			messages: modelMessages,
 			abortSignal: options.signal,
@@ -1318,7 +1495,22 @@ async function streamAgentPrompt(config, input, options) {
 			});
 		}
 		text = await streamResult.text;
-		if (options.outputSchema) output = await streamResult.output;
+		if (options.outputSchema) if (submitToolOutput) {
+			output = extractStructuredOutputFromSubmitTool({
+				steps: await streamResult.steps,
+				schema: options.outputSchema
+			});
+			if (output === void 0) throw new Error(`Structured output was not submitted via ${STRUCTURED_OUTPUT_SUBMIT_TOOL_NAME}`);
+		} else try {
+			output = await streamResult.output;
+		} catch (caught) {
+			const repaired = parseRepairedStructuredOutput({
+				text,
+				schema: options.outputSchema
+			});
+			if (repaired !== void 0) output = repaired;
+			else throw caught;
+		}
 		await emit({
 			type: "agent_end",
 			messages: newMessages
@@ -2400,17 +2592,77 @@ async function runPromptText(opts, hooks) {
 	await recordUsage(resolved, result.usage, hooks, result.response?.headers);
 	return result.text;
 }
+async function runPromptObjectViaSubmitTool(opts, hooks) {
+	const schema = opts.outputSchema;
+	if (!schema) throw new Error("outputSchema is required for structured LLM output");
+	const resolved = await resolvePromptModel(opts.model);
+	const providerOptions = resolveProviderOptions({
+		modelId: resolved.modelId,
+		structuredOutput: true
+	});
+	const tools = appendStructuredOutputSubmitTool({}, schema);
+	const system = augmentInstructionsForStructuredOutput({
+		instructions: opts.system ?? "",
+		modelId: resolved.modelId,
+		structuredOutput: true,
+		promptLlm: true
+	});
+	const prompt = augmentInputForStructuredOutput({
+		input: opts.prompt,
+		modelId: resolved.modelId,
+		structuredOutput: true
+	});
+	const thinkingLevel = resolveReasoningForStructuredOutputPromptLlm({
+		modelId: resolved.modelId,
+		thinkingLevel: opts.thinkingLevel,
+		structuredOutput: true
+	});
+	const result = await require_dist$2.generateText({
+		model: resolved.languageModel,
+		...system.trim() ? { system } : {},
+		prompt,
+		tools,
+		toolChoice: "required",
+		stopWhen: require_dist$2.hasToolCall(STRUCTURED_OUTPUT_SUBMIT_TOOL_NAME),
+		...opts.temperature !== void 0 ? { temperature: opts.temperature } : {},
+		...opts.maxTokens !== void 0 ? { maxOutputTokens: opts.maxTokens } : {},
+		...reasoningCallOption(thinkingLevel),
+		...providerOptions ? { providerOptions } : {}
+	});
+	await recordUsage(resolved, result.usage, hooks, result.response?.headers);
+	const fromSteps = extractStructuredOutputFromSubmitTool({
+		steps: await result.steps,
+		schema
+	});
+	if (fromSteps !== void 0) return fromSteps;
+	throw new Error(`Structured output was not submitted via ${STRUCTURED_OUTPUT_SUBMIT_TOOL_NAME}`);
+}
 async function runPromptObject(opts, hooks) {
 	const schema = opts.outputSchema;
 	if (!schema) throw new Error("outputSchema is required for structured LLM output");
 	const resolved = await resolvePromptModel(opts.model);
+	if (usesStructuredOutputSubmitTool({
+		modelId: resolved.modelId,
+		structuredOutput: true,
+		promptLlm: true
+	})) return runPromptObjectViaSubmitTool(opts, hooks);
 	const providerOptions = resolveProviderOptions({
 		modelId: resolved.modelId,
 		structuredOutput: true
 	});
+	const languageModel = wrapLanguageModelForStructuredOutput({
+		languageModel: resolved.languageModel,
+		modelId: resolved.modelId,
+		structuredOutput: true
+	});
+	const system = augmentInstructionsForStructuredOutput({
+		instructions: opts.system ?? "",
+		modelId: resolved.modelId,
+		structuredOutput: true
+	});
 	const result = await require_dist$2.generateObject({
-		model: resolved.languageModel,
-		system: opts.system,
+		model: languageModel,
+		...system.trim() ? { system } : {},
 		prompt: opts.prompt,
 		schema,
 		...opts.temperature !== void 0 ? { temperature: opts.temperature } : {},