File size: 5,468 Bytes
064bfd6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 | import { Ajv } from 'ajv'
import { z } from 'zod/v4'
import type { Tool, ToolInputJSONSchema } from '../../Tool.js'
import { buildTool, type ToolDef } from '../../Tool.js'
import { TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS } from '../../utils/errors.js'
import { lazySchema } from '../../utils/lazySchema.js'
import type { PermissionResult } from '../../utils/permissions/PermissionResult.js'
import { jsonStringify } from '../../utils/slowOperations.js'
// Allow any input object since the schema is provided dynamically
const inputSchema = lazySchema(() => z.object({}).passthrough())
type InputSchema = ReturnType<typeof inputSchema>
const outputSchema = lazySchema(() =>
z.string().describe('Structured output tool result'),
)
type OutputSchema = ReturnType<typeof outputSchema>
export type Output = z.infer<OutputSchema>
export const SYNTHETIC_OUTPUT_TOOL_NAME = 'StructuredOutput'
export function isSyntheticOutputToolEnabled(opts: {
isNonInteractiveSession: boolean
}): boolean {
return opts.isNonInteractiveSession
}
export const SyntheticOutputTool = buildTool({
isMcp: false,
isEnabled() {
// This tool is only created when conditions are met (see main.tsx where
// isSyntheticOutputToolEnabled() gates tool creation). Once created, always enabled.
return true
},
isConcurrencySafe() {
return true
},
isReadOnly() {
return true
},
isOpenWorld() {
return false
},
name: SYNTHETIC_OUTPUT_TOOL_NAME,
searchHint: 'return the final response as structured JSON',
maxResultSizeChars: 100_000,
async description(): Promise<string> {
return 'Return structured output in the requested format'
},
async prompt(): Promise<string> {
return `Use this tool to return your final response in the requested structured format. You MUST call this tool exactly once at the end of your response to provide the structured output.`
},
get inputSchema(): InputSchema {
return inputSchema()
},
get outputSchema(): OutputSchema {
return outputSchema()
},
async call(input) {
// The tool just validates and returns the input as the structured output
return {
data: 'Structured output provided successfully',
structured_output: input,
}
},
async checkPermissions(input): Promise<PermissionResult> {
// Always allow this tool - it's just returning data
return {
behavior: 'allow',
updatedInput: input,
}
},
// Minimal UI implementations - this tool is for non-interactive SDK/CLI use
renderToolUseMessage(input: Record<string, unknown>) {
const keys = Object.keys(input)
if (keys.length === 0) return null
if (keys.length <= 3) {
return keys.map(k => `${k}: ${jsonStringify(input[k])}`).join(', ')
}
return `${keys.length} fields: ${keys.slice(0, 3).join(', ')}…`
},
renderToolUseRejectedMessage() {
return 'Structured output rejected'
},
renderToolUseErrorMessage() {
return 'Structured output error'
},
renderToolUseProgressMessage() {
return null
},
renderToolResultMessage(output: string) {
return output
},
mapToolResultToToolResultBlockParam(content: string, toolUseID: string) {
return {
tool_use_id: toolUseID,
type: 'tool_result' as const,
content,
}
},
} satisfies ToolDef<InputSchema, Output>)
type CreateResult = { tool: Tool<InputSchema> } | { error: string }
// Workflow scripts call agent({schema: BUGS_SCHEMA}) 30-80 times per run with
// the same schema object reference. Without caching, each call does
// new Ajv() + validateSchema() + compile() (~1.4ms of JIT codegen). Identity
// cache brings 80-call workflows from ~110ms to ~4ms Ajv overhead.
const toolCache = new WeakMap<object, CreateResult>()
/**
* Create a SyntheticOutputTool configured with the given JSON schema.
* Returns {tool} on success or {error} with Ajv's diagnostic message
* (e.g. "data/properties/bugs should be object") on invalid schema.
*/
export function createSyntheticOutputTool(
jsonSchema: Record<string, unknown>,
): CreateResult {
const cached = toolCache.get(jsonSchema)
if (cached) return cached
const result = buildSyntheticOutputTool(jsonSchema)
toolCache.set(jsonSchema, result)
return result
}
function buildSyntheticOutputTool(
jsonSchema: Record<string, unknown>,
): CreateResult {
try {
const ajv = new Ajv({ allErrors: true })
const isValidSchema = ajv.validateSchema(jsonSchema)
if (!isValidSchema) {
return { error: ajv.errorsText(ajv.errors) }
}
const validateSchema = ajv.compile(jsonSchema)
return {
tool: {
...SyntheticOutputTool,
inputJSONSchema: jsonSchema as ToolInputJSONSchema,
async call(input) {
const isValid = validateSchema(input)
if (!isValid) {
const errors = validateSchema.errors
?.map(e => `${e.instancePath || 'root'}: ${e.message}`)
.join(', ')
throw new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(
`Output does not match required schema: ${errors}`,
`StructuredOutput schema mismatch: ${(errors ?? '').slice(0, 150)}`,
)
}
return {
data: 'Structured output provided successfully',
structured_output: input,
}
},
},
}
} catch (e) {
return { error: e instanceof Error ? e.message : String(e) }
}
}
|