@keystrokehq/keystroke 0.1.91 → 0.1.92

package/dist/agent-types.d.cts

@@ -1,4 +1,4 @@
 import { i as AgentToolUpdateCallback, n as AgentToolParameters, r as AgentToolResult, t as AgentTool } from "./index-dDHyyZ6y.cjs";
-import { a as UIMessage } from "./index-BKn5COTH.cjs";
-import { c as AgentStreamEvent, i as AgentMessage, p as ThinkingLevel, s as AgentStepStartEvent, t as AgentContextCompactedEvent } from "./schemas-lSbMfQRy-DdpE4_dC.cjs";
+import { a as UIMessage } from "./index-C614Tmd_.cjs";
+import { c as AgentStreamEvent, i as AgentMessage, p as ThinkingLevel, s as AgentStepStartEvent, t as AgentContextCompactedEvent } from "./schemas-lSbMfQRy-YsonGA_B.cjs";
 export { AgentContextCompactedEvent, AgentMessage, AgentStepStartEvent, AgentStreamEvent, type AgentTool, type AgentToolParameters, type AgentToolResult, type AgentToolUpdateCallback, ThinkingLevel, type UIMessage };

package/dist/agent-types.d.mts

@@ -1,4 +1,4 @@
 import { i as AgentToolUpdateCallback, n as AgentToolParameters, r as AgentToolResult, t as AgentTool } from "./index-dDHyyZ6y.mjs";
-import { a as UIMessage } from "./index-DHfxB8DH.mjs";
-import { c as AgentStreamEvent, i as AgentMessage, p as ThinkingLevel, s as AgentStepStartEvent, t as AgentContextCompactedEvent } from "./schemas-lSbMfQRy-D7NW7SCj.mjs";
+import { a as UIMessage } from "./index-BAERW4m3.mjs";
+import { c as AgentStreamEvent, i as AgentMessage, p as ThinkingLevel, s as AgentStepStartEvent, t as AgentContextCompactedEvent } from "./schemas-lSbMfQRy-CIfs2xv6.mjs";
 export { AgentContextCompactedEvent, AgentMessage, AgentStepStartEvent, AgentStreamEvent, type AgentTool, type AgentToolParameters, type AgentToolResult, type AgentToolUpdateCallback, ThinkingLevel, type UIMessage };

package/dist/agent.cjs

@@ -841,6 +841,75 @@ function gateToolSetMedia(toolSet, capabilities) {
 	}
 	return gated;
 }
+function withDescription(schema, source) {
+	return source.description ? schema.describe(source.description) : schema;
+}
+/** Wire accepts null; parse output uses undefined so `.optional()` consumers still match. */
+function nullableWire(schema) {
+	return schema.nullable().transform((value) => value === null ? void 0 : value);
+}
+/**
+* OpenAI (and Azure) strict structured outputs require every key in
+* `properties` to also appear in `required`. Zod `.optional()` / `.nullish()`
+* / `.default()` omit keys from `required`, which the API rejects before the
+* model runs.
+*
+* Rewrite those wrappers to a wire-nullable shape, then map values back to what
+* the original schema expects (null → undefined for `.optional()`, apply
+* `.default()`), so workflow `output` / caller parses still succeed.
+*/
+function toStrictStructuredOutputSchema(schema) {
+	return rewrite(schema);
+}
+/** Zod classic wrappers expose nested schemas as core `$ZodType`. */
+function rewrite(schema) {
+	if (schema instanceof zod.z.ZodOptional) {
+		const transformed = rewrite(schema.unwrap());
+		if (transformed instanceof zod.z.ZodNullable) return withDescription(transformed, schema);
+		return withDescription(nullableWire(transformed), schema);
+	}
+	if (schema instanceof zod.z.ZodNullable) return withDescription(rewrite(schema.unwrap()).nullable(), schema);
+	if (schema instanceof zod.z.ZodDefault) {
+		const defaultValue = schema.def.defaultValue;
+		const inner = rewrite(schema.unwrap());
+		return withDescription(zod.z.union([inner, zod.z.null()]).transform((value) => {
+			if (value === null || value === void 0) return defaultValue;
+			return value;
+		}), schema);
+	}
+	if (schema instanceof zod.z.ZodObject) {
+		const shape = {};
+		for (const [key, value] of Object.entries(schema.shape)) shape[key] = rewrite(value);
+		const catchall = schema.def.catchall;
+		let objectSchema = zod.z.object(shape);
+		if (catchall instanceof zod.z.ZodUnknown) objectSchema = objectSchema.loose();
+		else if (catchall instanceof zod.z.ZodNever) objectSchema = objectSchema.strict();
+		else if (catchall) objectSchema = objectSchema.catchall(rewrite(catchall));
+		return withDescription(objectSchema, schema);
+	}
+	if (schema instanceof zod.z.ZodArray) return withDescription(zod.z.array(rewrite(schema.element)), schema);
+	if (schema instanceof zod.z.ZodUnion) {
+		const options = schema.options.map(rewrite);
+		const first = options[0];
+		const second = options[1];
+		if (!first || !second) return schema;
+		return withDescription(zod.z.union([
+			first,
+			second,
+			...options.slice(2)
+		]), schema);
+	}
+	if (schema instanceof zod.z.ZodTuple) {
+		const { items, rest } = schema.def;
+		const transformed = items.map(rewrite);
+		const first = transformed[0];
+		if (!first) return schema;
+		return withDescription(rest ? zod.z.tuple([first, ...transformed.slice(1)]).rest(rewrite(rest)) : zod.z.tuple([first, ...transformed.slice(1)]), schema);
+	}
+	if (schema instanceof zod.z.ZodRecord) return withDescription(zod.z.record(schema.keyType, rewrite(schema.valueType)), schema);
+	if (schema instanceof zod.z.ZodType) return schema;
+	throw new Error("Expected a Zod classic schema");
+}
 function textFromContent(result) {
 	return result.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
 }
@@ -1183,13 +1252,14 @@ async function streamAgentPrompt(config, input, options) {
 			...instrumentAiToolSet(config.mcpToolSet)
 		}, config.resolvedModel.capabilities);
 		const structuredOutput = Boolean(options.outputSchema);
+		const outputSchema = options.outputSchema ? toStrictStructuredOutputSchema(options.outputSchema) : void 0;
 		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);
+		if (submitToolOutput && outputSchema) aiTools = appendStructuredOutputSubmitTool(aiTools, 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, resume ? { ignoreIncompleteToolCalls: true } : void 0);
@@ -1288,7 +1358,7 @@ async function streamAgentPrompt(config, input, options) {
 			tools: aiTools,
 			reasoning: config.thinkingLevel,
 			...config.experimentalDownload ? { experimental_download: config.experimentalDownload } : {},
-			...!submitToolOutput && options.outputSchema ? { output: require_dist$2.output_exports.object({ schema: options.outputSchema }) } : {},
+			...!submitToolOutput && outputSchema ? { output: require_dist$2.output_exports.object({ schema: outputSchema }) } : {},
 			...providerOptions ? { providerOptions } : {},
 			prepareStep: prepareStepOnce,
 			stopWhen
@@ -1390,10 +1460,10 @@ async function streamAgentPrompt(config, input, options) {
 			});
 		}
 		text = await streamResult.text;
-		if (options.outputSchema) if (submitToolOutput) {
+		if (outputSchema) if (submitToolOutput) {
 			output = extractStructuredOutputFromSubmitTool({
 				steps: await streamResult.steps,
-				schema: options.outputSchema
+				schema: outputSchema
 			});
 			if (output === void 0) throw new Error(`Structured output was not submitted via ${STRUCTURED_OUTPUT_SUBMIT_TOOL_NAME}`);
 		} else try {
@@ -1401,7 +1471,7 @@ async function streamAgentPrompt(config, input, options) {
 		} catch (caught) {
 			const repaired = parseRepairedStructuredOutput({
 				text,
-				schema: options.outputSchema
+				schema: outputSchema
 			});
 			if (repaired !== void 0) output = repaired;
 			else throw caught;
@@ -2788,7 +2858,7 @@ async function runPromptText(opts, hooks) {
 	return result.text;
 }
 async function runPromptObjectViaSubmitTool(opts, hooks) {
-	const schema = opts.outputSchema;
+	const schema = opts.outputSchema ? toStrictStructuredOutputSchema(opts.outputSchema) : void 0;
 	if (!schema) throw new Error("outputSchema is required for structured LLM output");
 	const resolved = await resolvePromptModel(opts.model);
 	const providerOptions = resolveProviderOptions({
@@ -2833,14 +2903,14 @@ async function runPromptObjectViaSubmitTool(opts, hooks) {
 	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 schema = opts.outputSchema ? toStrictStructuredOutputSchema(opts.outputSchema) : void 0;
+	if (!schema) throw new Error("outputSchema is required for structured LLM output");
 	const providerOptions = resolveProviderOptions({
 		modelId: resolved.modelId,
 		structuredOutput: true