{"version":3,"sources":["../src/tools/code-mode/stub-generator.ts","../src/workspace/errors.ts","../src/tools/code-mode/runner.ts","../src/tools/code-mode/transport.ts","../src/tools/code-mode/code-mode.ts","../src/tools/builtin/ask-user.ts","../src/tools/builtin/submit-plan.ts"],"names":["isStandardSchemaWithJSON","standardSchemaToJSONSchema","SAFE_IDENT","mkdtemp","join","tmpdir","randomBytes","writeFile","pathToFileURL","handleFrame","notifyCall","notifyResult","rm","z","createTool","isValidationError"],"mappings":"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","file":"chunk-QK2WXKVV.cjs","sourcesContent":["/**\n * Code Mode — Type stub generation\n *\n * Converts Mastra tools into TypeScript `declare function external_(...)`\n * stubs and assembles the instructions the model sees. The pipeline is:\n *\n * tool.inputSchema (StandardSchemaWithJSON)\n * -> standardSchemaToJSONSchema() (already in core, zod v3 + v4 + arktype)\n * -> jsonSchemaToTsString() (this file, synchronous, dependency-free)\n * -> stub string\n *\n * Only the subset of JSON Schema that tool schemas actually produce is handled;\n * anything else degrades to `unknown`.\n */\n\nimport type { JSONSchema7, JSONSchema7Definition, JSONSchema7TypeName } from 'json-schema';\nimport type { ToolsInput } from '../../agent/types';\nimport { isStandardSchemaWithJSON, standardSchemaToJSONSchema } from '../../schema';\nimport type { StandardSchemaWithJSON } from '../../schema';\nimport type { CodeModeConfig } from './types';\n\n/** A valid TypeScript identifier? (used to decide quoting of object keys). */\nconst SAFE_IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;\n\n/**\n * Convert a JSON Schema (draft-07) node into a TypeScript type string.\n * Unsupported constructs return `unknown`.\n */\nexport function jsonSchemaToTsString(schema: JSONSchema7Definition | undefined): string {\n if (schema === undefined) return 'unknown';\n if (typeof schema === 'boolean') return schema ? 'unknown' : 'never';\n\n // enum / const\n if (schema.const !== undefined) return literal(schema.const);\n if (Array.isArray(schema.enum)) {\n return schema.enum.length ? schema.enum.map(literal).join(' | ') : 'never';\n }\n\n // unions\n const union = schema.anyOf ?? schema.oneOf;\n if (Array.isArray(union) && union.length) {\n return union.map(jsonSchemaToTsString).join(' | ');\n }\n\n const type = normalizeType(schema.type);\n\n if (type === 'object' || schema.properties) {\n return objectType(schema);\n }\n if (type === 'array' || schema.items) {\n return arrayType(schema);\n }\n\n switch (type) {\n case 'string':\n return 'string';\n case 'number':\n case 'integer':\n return 'number';\n case 'boolean':\n return 'boolean';\n case 'null':\n return 'null';\n default:\n return 'unknown';\n }\n}\n\nfunction normalizeType(type: JSONSchema7['type']): JSONSchema7TypeName | undefined {\n if (Array.isArray(type)) {\n // e.g. ['string', 'null'] — caller folds null in via nullability; pick the\n // first non-null for the base type.\n return type.find(t => t !== 'null');\n }\n return type;\n}\n\nfunction objectType(schema: JSONSchema7): string {\n const props = schema.properties ?? {};\n const required = new Set(schema.required ?? []);\n const keys = Object.keys(props);\n\n if (!keys.length) {\n // Free-form object.\n const additional = schema.additionalProperties;\n if (additional !== undefined && additional !== false) {\n const valueType = typeof additional === 'object' ? jsonSchemaToTsString(additional) : 'unknown';\n return `Record`;\n }\n return 'Record';\n }\n\n const fields = keys.map(key => {\n const optional = !required.has(key) ? '?' : '';\n const k = SAFE_IDENT.test(key) ? key : JSON.stringify(key);\n return `${k}${optional}: ${jsonSchemaToTsString(props[key])}`;\n });\n return `{ ${fields.join('; ')} }`;\n}\n\nfunction arrayType(schema: JSONSchema7): string {\n const items = schema.items;\n if (Array.isArray(items)) {\n // Tuple.\n return `[${items.map(jsonSchemaToTsString).join(', ')}]`;\n }\n const inner = jsonSchemaToTsString(items);\n // Use `Array<...>` form for top-level unions so `A | B[]` isn't misread as\n // `A | (B[])`. Object literals and other forms use the `T[]` shorthand.\n return isTopLevelUnion(inner) ? `Array<${inner}>` : `${inner}[]`;\n}\n\n/** True if `ts` is a union at the top level (a ` | ` not nested in braces/brackets). */\nfunction isTopLevelUnion(ts: string): boolean {\n let depth = 0;\n for (let i = 0; i < ts.length; i++) {\n const c = ts[i];\n if (c === '{' || c === '[' || c === '(' || c === '<') depth++;\n else if (c === '}' || c === ']' || c === ')' || c === '>') depth--;\n else if (c === '|' && depth === 0) return true;\n }\n return false;\n}\n\nfunction literal(value: unknown): string {\n if (typeof value === 'string') return JSON.stringify(value);\n if (typeof value === 'number' || typeof value === 'boolean') return String(value);\n if (value === null) return 'null';\n return 'unknown';\n}\n\nfunction schemaToTs(schema: unknown, io: 'input' | 'output'): string {\n if (!isStandardSchemaWithJSON(schema)) return 'unknown';\n try {\n const json = standardSchemaToJSONSchema(schema as StandardSchemaWithJSON, { io });\n return jsonSchemaToTsString(json as JSONSchema7);\n } catch {\n return 'unknown';\n }\n}\n\n/** Strip non-identifier characters so a tool id is a legal function-name suffix. */\nfunction sanitizeId(id: string): string {\n const cleaned = id.replace(/[^A-Za-z0-9_$]/g, '_');\n return SAFE_IDENT.test(cleaned) ? cleaned : `_${cleaned}`;\n}\n\n/** A single tool's TS declaration plus the original/sanitized id mapping. */\nexport interface CodeModeStub {\n /** Original tool id (key used by the RPC dispatcher). */\n toolId: string;\n /** Sanitized identifier used in `external_`. */\n externalName: string;\n /** The full `declare function ...` line(s). */\n declaration: string;\n}\n\n/** Generate stubs for every tool in the config. */\nexport function generateStubs(tools: ToolsInput): CodeModeStub[] {\n // Two distinct tool ids can sanitize to the same `external_*` name (e.g.\n // `a-b` and `a_b`). Without this check the later binding would silently\n // overwrite the earlier one in the runner, so fail fast instead.\n const seen = new Map();\n return Object.entries(tools).map(([key, tool]) => {\n const toolId = (tool as { id?: string }).id ?? key;\n const description = (tool as { description?: string }).description;\n const inputType = schemaToTs((tool as { inputSchema?: unknown }).inputSchema, 'input');\n const outputType = schemaToTs((tool as { outputSchema?: unknown }).outputSchema, 'output');\n const externalName = sanitizeId(toolId);\n\n const prior = seen.get(externalName);\n if (prior !== undefined && prior !== toolId) {\n throw new Error(`Code Mode tool id collision: \"${prior}\" and \"${toolId}\" both map to external_${externalName}`);\n }\n seen.set(externalName, toolId);\n\n const doc = description ? `/** ${description.replace(/\\*\\//g, '* /')} */\\n` : '';\n const declaration = `${doc}declare function external_${externalName}(input: ${inputType}): Promise<${outputType}>;`;\n\n return { toolId, externalName, declaration };\n });\n}\n\nconst USAGE_CONTRACT = `# Code Mode\n\nYou have an \\`execute_typescript\\` tool. Instead of calling tools one at a time,\nwrite a single TypeScript program that orchestrates them and returns one result.\n\nRules:\n- Call the available tools via the \\`external_*\\` functions declared below. Each\n returns a Promise — \\`await\\` it.\n- Batch independent calls with \\`Promise.all\\`. Do arithmetic and data shaping in\n JavaScript, not in your head.\n- End the program by \\`return\\`-ing the final value (objects/arrays are fine).\n- The program runs in a sandbox: no access to the host filesystem, network, or\n process. The only capabilities are the \\`external_*\\` functions.\n- Use \\`console.log\\` for debugging; logs are captured and returned.\n\nAvailable functions:`;\n\n/** Build the full instructions string (usage contract + stubs). */\nexport function createCodeModeInstructions(config: CodeModeConfig): string {\n const stubs = generateStubs(config.tools);\n const declarations = stubs.map(s => s.declaration).join('\\n\\n');\n return `${USAGE_CONTRACT}\\n\\n${declarations}`;\n}\n","/**\n * Workspace Errors\n *\n * Error classes for workspace operations.\n */\n\nimport type { WorkspaceStatus } from './types';\n\n// =============================================================================\n// Base Error\n// =============================================================================\n\nexport class WorkspaceError extends Error {\n constructor(\n message: string,\n public readonly code: string,\n public readonly workspaceId?: string,\n ) {\n super(message);\n this.name = 'WorkspaceError';\n }\n}\n\n// =============================================================================\n// Availability Errors\n// =============================================================================\n\nexport class WorkspaceNotAvailableError extends WorkspaceError {\n constructor() {\n super('Workspace not available. Ensure the agent has a workspace configured.', 'NO_WORKSPACE');\n this.name = 'WorkspaceNotAvailableError';\n }\n}\n\nexport class FilesystemNotAvailableError extends WorkspaceError {\n constructor() {\n super('Workspace does not have a filesystem configured', 'NO_FILESYSTEM');\n this.name = 'FilesystemNotAvailableError';\n }\n}\n\nexport class SandboxNotAvailableError extends WorkspaceError {\n constructor(message?: string) {\n super(message ?? 'Workspace does not have a sandbox configured', 'NO_SANDBOX');\n this.name = 'SandboxNotAvailableError';\n }\n}\n\nexport class SandboxFeatureNotSupportedError extends WorkspaceError {\n constructor(feature: 'executeCommand' | 'installPackage' | 'processes') {\n super(`Sandbox does not support ${feature}`, 'FEATURE_NOT_SUPPORTED');\n this.name = 'SandboxFeatureNotSupportedError';\n }\n}\n\nexport class SearchNotAvailableError extends WorkspaceError {\n constructor() {\n super('Workspace does not have search configured (enable bm25 or provide vectorStore + embedder)', 'NO_SEARCH');\n this.name = 'SearchNotAvailableError';\n }\n}\n\n// =============================================================================\n// State Errors\n// =============================================================================\n\nexport class WorkspaceNotReadyError extends WorkspaceError {\n constructor(workspaceId: string, status: WorkspaceStatus) {\n super(`Workspace is not ready (status: ${status})`, 'NOT_READY', workspaceId);\n this.name = 'WorkspaceNotReadyError';\n }\n}\n\nexport class WorkspaceReadOnlyError extends WorkspaceError {\n constructor(operation: string) {\n super(`Workspace is in read-only mode. Cannot perform: ${operation}`, 'READ_ONLY');\n this.name = 'WorkspaceReadOnlyError';\n }\n}\n\n// =============================================================================\n// Filesystem Errors\n// =============================================================================\n\nexport class FilesystemError extends Error {\n constructor(\n message: string,\n public readonly code: string,\n public readonly path: string,\n ) {\n super(message);\n this.name = 'FilesystemError';\n }\n}\n\nexport class FileNotFoundError extends FilesystemError {\n constructor(path: string) {\n super(`File not found: ${path}`, 'ENOENT', path);\n this.name = 'FileNotFoundError';\n }\n}\n\nexport class DirectoryNotFoundError extends FilesystemError {\n constructor(path: string) {\n super(`Directory not found: ${path}`, 'ENOENT', path);\n this.name = 'DirectoryNotFoundError';\n }\n}\n\nexport class FileExistsError extends FilesystemError {\n constructor(path: string) {\n super(`File already exists: ${path}`, 'EEXIST', path);\n this.name = 'FileExistsError';\n }\n}\n\nexport class IsDirectoryError extends FilesystemError {\n constructor(path: string) {\n super(`Path is a directory: ${path}`, 'EISDIR', path);\n this.name = 'IsDirectoryError';\n }\n}\n\nexport class NotDirectoryError extends FilesystemError {\n constructor(path: string) {\n super(`Path is not a directory: ${path}`, 'ENOTDIR', path);\n this.name = 'NotDirectoryError';\n }\n}\n\nexport class DirectoryNotEmptyError extends FilesystemError {\n constructor(path: string) {\n super(`Directory not empty: ${path}`, 'ENOTEMPTY', path);\n this.name = 'DirectoryNotEmptyError';\n }\n}\n\nexport class PermissionError extends FilesystemError {\n constructor(\n path: string,\n public readonly operation: string,\n ) {\n super(`Permission denied: ${operation} on ${path}`, 'EACCES', path);\n this.name = 'PermissionError';\n }\n}\n\nexport class FileReadRequiredError extends FilesystemError {\n constructor(path: string, reason: string) {\n super(reason, 'EREAD_REQUIRED', path);\n this.name = 'FileReadRequiredError';\n }\n}\n\nexport class StaleFileError extends FilesystemError {\n constructor(\n path: string,\n public readonly expectedMtime: Date,\n public readonly actualMtime: Date,\n ) {\n super(\n `File was modified externally: ${path} (expected mtime ${expectedMtime.toISOString()}, actual ${actualMtime.toISOString()})`,\n 'ESTALE',\n path,\n );\n this.name = 'StaleFileError';\n }\n}\n\n/**\n * Error thrown when a filesystem operation is attempted before initialization.\n */\nexport class FilesystemNotReadyError extends FilesystemError {\n constructor(id: string) {\n super(`Filesystem \"${id}\" is not ready. Call init() first or use ensureReady().`, 'ENOTREADY', id);\n this.name = 'FilesystemNotReadyError';\n }\n}\n","/**\n * Code Mode — Sandbox runner\n *\n * Builds the JavaScript program that runs *inside* the sandbox. The runner:\n * - defines an `external_` function per allow-listed tool, each of which\n * emits a JSON-RPC request on the protocol channel and awaits its response\n * (matched by `id`, so `Promise.all` calls resolve independently);\n * - wraps the model's program in an async function, captures `console.*`, and\n * emits a terminal `done` frame.\n *\n * Protocol (host <-> runner), newline-delimited JSON on stdout/stdin:\n * - Frames the runner emits are prefixed with FRAME_PREFIX so the host can\n * tell them apart from any stray output. Forms: `rpc`, `log`, `done`.\n * - The host writes `rpc-result` frames to the runner stdin (no prefix).\n */\n\n/** Marks a line on stdout as a Code Mode protocol frame. */\nexport const FRAME_PREFIX = '\\u0000CODEMODE\\u0000';\n\nexport interface BuildRunnerOptions {\n /**\n * Module specifier the runner imports to obtain the user program. The\n * referenced module must `export default` an async function (the wrapped\n * model code). Written as a sibling `.ts` file so the sandbox's `node`\n * strips the TypeScript types natively at import time.\n */\n programModule: string;\n /** Map of `external_` -> original tool id used in the RPC request. */\n externals: Array<{ externalName: string; toolId: string }>;\n}\n\n/**\n * Wrap the model's TypeScript program as a default-exported async function\n * module. Written to a `.ts` file; Node strips the type annotations at import.\n * Top-level `return`, `await`, and `const` work because the body lives inside\n * an async function.\n */\nexport function buildProgramModule(program: string): string {\n return `export default async function () {\\n${program}\\n}\\n`;\n}\n\n/**\n * Produce the full runner source to write into the sandbox and run with node.\n */\nexport function buildRunner({ programModule, externals }: BuildRunnerOptions): string {\n // `buildRunner` is exported, so a caller could pass a non-sanitized name.\n // External names become global property suffixes, so reject anything that\n // isn't a legal identifier instead of producing an unusable global.\n const SAFE_IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;\n const seen = new Map();\n for (const { externalName, toolId } of externals) {\n if (!SAFE_IDENT.test(externalName)) {\n throw new Error(`Invalid Code Mode external identifier: ${externalName}`);\n }\n // Two tool ids can sanitize to the same external name (e.g. `a-b` and\n // `a_b` both become `a_b`). The install loop below would silently overwrite\n // the earlier global, leaving one tool unreachable. Fail fast instead.\n const existing = seen.get(externalName);\n if (existing) {\n throw new Error(\n `Code Mode external identifier collision: tools \"${existing}\" and \"${toolId}\" both map to external_${externalName}`,\n );\n }\n seen.set(externalName, toolId);\n }\n\n // Externals are emitted as JSON data, not interpolated identifiers. The\n // runner installs each `external_` global in a loop using bracket\n // assignment, so no caller-derived string is ever spliced into the generated\n // source as code. This keeps tool ids strictly data, even if `sanitize`\n // changes.\n const externalsJson = JSON.stringify(externals.map(({ externalName, toolId }) => ({ externalName, toolId })));\n\n return `'use strict';\nconst FRAME_PREFIX = ${JSON.stringify(FRAME_PREFIX)};\n\nfunction __emit(frame) {\n process.stdout.write(FRAME_PREFIX + JSON.stringify(frame) + '\\\\n');\n}\n\n// ---- console capture -------------------------------------------------------\nfor (const level of ['log', 'info', 'warn', 'error']) {\n console[level] = (...args) => {\n const message = args\n .map((a) => (typeof a === 'string' ? a : safeStringify(a)))\n .join(' ');\n __emit({ type: 'log', level, message });\n };\n}\nfunction safeStringify(value) {\n try { return JSON.stringify(value); } catch { return String(value); }\n}\n\n// ---- RPC bridge ------------------------------------------------------------\nlet __nextId = 0;\nconst __pending = new Map();\n\nfunction __rpc(tool, args) {\n const id = __nextId++;\n return new Promise((resolve, reject) => {\n __pending.set(id, { resolve, reject });\n __emit({ type: 'rpc', id, tool, args });\n });\n}\n\nlet __stdinBuffer = '';\nprocess.stdin.setEncoding('utf8');\nprocess.stdin.on('data', (chunk) => {\n __stdinBuffer += chunk;\n let idx;\n while ((idx = __stdinBuffer.indexOf('\\\\n')) >= 0) {\n const line = __stdinBuffer.slice(0, idx);\n __stdinBuffer = __stdinBuffer.slice(idx + 1);\n if (!line) continue;\n let frame;\n try { frame = JSON.parse(line); } catch { continue; }\n if (frame && frame.type === 'rpc-result') {\n const entry = __pending.get(frame.id);\n if (!entry) continue;\n __pending.delete(frame.id);\n if (frame.ok) entry.resolve(frame.result);\n else {\n const err = new Error(frame.error?.message || 'external tool failed');\n if (frame.error?.name) err.name = frame.error.name;\n entry.reject(err);\n }\n }\n }\n});\n\n// ---- externals -------------------------------------------------------------\nfor (const { externalName, toolId } of ${externalsJson}) {\n globalThis['external_' + externalName] = (input) => __rpc(toolId, input);\n}\n\n// ---- user program ----------------------------------------------------------\n// The program lives in a sibling .ts module exporting a default async function;\n// node strips its TypeScript types natively on import.\nasync function __main() {\n const mod = await import(${JSON.stringify(programModule)});\n return await mod.default();\n}\n\n__main()\n .then((result) => {\n __emit({ type: 'done', ok: true, result });\n process.exit(0);\n })\n .catch((error) => {\n __emit({\n type: 'done',\n ok: false,\n error: { message: error?.message ?? String(error), name: error?.name },\n });\n process.exit(0);\n });\n`;\n}\n","/**\n * Code Mode — stdio JSON-RPC transport (v1)\n *\n * Runs the runner inside the sandbox via `sandbox.processes.spawn`, parses\n * protocol frames off stdout, dispatches `external_*` calls back to the host,\n * and writes results to the runner stdin. Abstracted behind\n * {@link CodeModeTransport} so socket/file-queue transports can be added for\n * remote sandboxes later.\n */\n\nimport { randomBytes } from 'node:crypto';\nimport { mkdtemp, rm, writeFile } from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { pathToFileURL } from 'node:url';\n\nimport { SandboxFeatureNotSupportedError } from '../../workspace/errors';\nimport { buildRunner, buildProgramModule, FRAME_PREFIX } from './runner';\nimport type { CodeModeRunnerFrame, CodeModeToolResult, CodeModeTransport } from './types';\n\n/**\n * Default transport: writes the runner to a temp dir, spawns\n * `node `, and bridges RPC over stdio.\n */\nexport class StdioCodeModeTransport implements CodeModeTransport {\n async run(opts: Parameters[0]): Promise {\n const { sandbox, program, toolIds, dispatch, timeout, abortSignal, onExternalCall, onExternalResult } = opts;\n\n if (!sandbox.processes) {\n throw new SandboxFeatureNotSupportedError('processes');\n }\n\n const externals = toolIds.map(toolId => ({ toolId, externalName: sanitize(toolId) }));\n const allowList = new Set(toolIds);\n\n const dir = await mkdtemp(join(tmpdir(), 'mastra-code-mode-'));\n const suffix = randomBytes(4).toString('hex');\n // The model's TypeScript program is written to its own .ts module; node\n // strips the type annotations when the runner imports it (see the\n // --experimental-strip-types flag on the spawn below).\n const programPath = join(dir, `program-${suffix}.ts`);\n await writeFile(programPath, buildProgramModule(program), 'utf8');\n const runnerSource = buildRunner({ programModule: pathToFileURL(programPath).href, externals });\n const runnerPath = join(dir, `runner-${suffix}.mjs`);\n await writeFile(runnerPath, runnerSource, 'utf8');\n\n const logs: string[] = [];\n let done: CodeModeToolResult | undefined;\n let stdoutBuffer = '';\n\n // Resolved once a terminal `done` frame arrives.\n let resolveDone!: () => void;\n const donePromise = new Promise(resolve => {\n resolveDone = resolve;\n });\n\n try {\n // `--experimental-strip-types` lets node import the program's `.ts`\n // module on Node 22.6–22.17 (where type-stripping is still flagged). On\n // Node 22.18+/24, where stripping is the default, the flag is accepted as\n // a harmless no-op, so this works across the versions CI and users run.\n const handle = await sandbox.processes.spawn(`node --experimental-strip-types ${runnerPath}`, {\n cwd: dir,\n abortSignal,\n onStdout: (chunk: string) => {\n stdoutBuffer += chunk;\n let idx: number;\n while ((idx = stdoutBuffer.indexOf('\\n')) >= 0) {\n const line = stdoutBuffer.slice(0, idx);\n stdoutBuffer = stdoutBuffer.slice(idx + 1);\n if (!line.startsWith(FRAME_PREFIX)) continue;\n let frame: CodeModeRunnerFrame;\n try {\n frame = JSON.parse(line.slice(FRAME_PREFIX.length));\n } catch {\n continue;\n }\n handleFrame(frame);\n }\n },\n });\n\n function handleFrame(frame: CodeModeRunnerFrame): void {\n switch (frame.type) {\n case 'log':\n logs.push(frame.message);\n return;\n case 'done':\n done = frame.ok\n ? { success: true, result: frame.result, logs }\n : { success: false, error: frame.error, logs };\n resolveDone();\n return;\n case 'rpc':\n // `serveRpc` awaits `respond`, which writes to the child's stdin and\n // can reject if the process already exited/was killed. Swallow that\n // so it never surfaces as an unhandled rejection.\n void serveRpc(frame.id, frame.tool, frame.args).catch(() => {});\n return;\n }\n }\n\n // Observer hooks are caller-supplied and best-effort: a throwing hook must\n // never prevent `respond()` from running, or the matching in-sandbox promise\n // would hang until the timeout.\n function notifyCall(tool: string, args: unknown): void {\n try {\n onExternalCall?.(tool, args);\n } catch {\n /* observer errors are non-fatal */\n }\n }\n function notifyResult(tool: string, durationMs: number, error?: Error): void {\n try {\n onExternalResult?.(tool, durationMs, error);\n } catch {\n /* observer errors are non-fatal */\n }\n }\n\n async function serveRpc(id: number, tool: string, args: unknown): Promise {\n const started = Date.now();\n notifyCall(tool, args);\n // Allow-list enforcement: never invoke a tool that wasn't exposed.\n if (!allowList.has(tool)) {\n notifyResult(tool, Date.now() - started, new Error('not allowed'));\n await respond(id, false, undefined, {\n message: `Tool \"${tool}\" is not available in Code Mode`,\n name: 'NotAllowedError',\n });\n return;\n }\n try {\n const result = await dispatch(tool, args);\n notifyResult(tool, Date.now() - started);\n await respond(id, true, result);\n } catch (error: any) {\n notifyResult(tool, Date.now() - started, error);\n await respond(id, false, undefined, {\n message: error?.message ?? String(error),\n name: error?.name,\n });\n }\n }\n\n async function respond(\n id: number,\n ok: boolean,\n result?: unknown,\n error?: { message: string; name?: string },\n ): Promise {\n await handle.sendStdin(JSON.stringify({ type: 'rpc-result', id, ok, result, error }) + '\\n');\n }\n\n // Race completion against process exit and the timeout. Including process\n // exit means a runner that dies without emitting `done` resolves\n // immediately instead of waiting out the full timeout.\n let timer: NodeJS.Timeout | undefined;\n const timeoutPromise = new Promise<'timeout'>(resolve => {\n timer = setTimeout(() => resolve('timeout'), timeout);\n });\n const exitPromise = handle.wait().then(() => 'exited' as const);\n\n const outcome = await Promise.race([\n donePromise.then(() => 'done' as const),\n exitPromise.catch(() => 'exited' as const),\n timeoutPromise,\n ]);\n if (timer) clearTimeout(timer);\n\n if (outcome === 'timeout') {\n await handle.kill().catch(() => {});\n return {\n success: false,\n logs,\n error: { message: `Code Mode execution timed out after ${timeout}ms`, name: 'TimeoutError' },\n };\n }\n\n // Either `done` arrived or the process exited. If we raced ahead of a\n // `done` frame still in flight, give it a brief beat to land.\n if (!done) {\n await exitPromise.catch(() => {});\n }\n\n return (\n done ?? {\n success: false,\n logs,\n error: { message: 'Program exited without returning a result', name: 'NoResultError' },\n }\n );\n } finally {\n await rm(dir, { recursive: true, force: true }).catch(() => {});\n }\n }\n}\n\nfunction sanitize(id: string): string {\n const cleaned = id.replace(/[^A-Za-z0-9_$]/g, '_');\n return /^[A-Za-z_$]/.test(cleaned) ? cleaned : `_${cleaned}`;\n}\n","/**\n * Code Mode — tool factory\n *\n * `createCodeMode(config)` returns the `execute_typescript` tool plus the\n * generated `instructions`. The tool transpiles the model's TypeScript to JS,\n * runs it in a WorkspaceSandbox via the transport, and bridges each\n * `external_*` call back to the real Mastra tool on the host.\n */\n\nimport { z } from 'zod/v4';\nimport type { WorkspaceSandbox } from '../../workspace/sandbox/sandbox';\nimport { createTool } from '../tool';\nimport type { Tool } from '../tool';\nimport { isValidationError } from '../validation';\nimport { createCodeModeInstructions } from './stub-generator';\nimport { StdioCodeModeTransport } from './transport';\nimport type { CodeModeConfig, CodeModeToolDispatcher, CodeModeToolResult, CodeModeTransport } from './types';\n\nconst DEFAULT_TIMEOUT = 30_000;\nconst DEFAULT_TOOL_NAME = 'execute_typescript';\n\nconst codeModeInputSchema = z.object({\n code: z\n .string()\n .describe(\n 'A TypeScript program that orchestrates the available external_* tools and returns a final value. ' +\n 'Use Promise.all to batch calls; do arithmetic in JS. End with `return `.',\n ),\n});\n\nconst codeModeOutputSchema = z.object({\n success: z.boolean(),\n result: z.unknown().optional(),\n logs: z.array(z.string()).optional(),\n error: z\n .object({\n message: z.string(),\n name: z.string().optional(),\n line: z.number().optional(),\n })\n .optional(),\n});\n\n/** Result of {@link createCodeMode}: the tool plus its generated instructions. */\nexport interface CodeModeResult {\n tool: Tool;\n instructions: string;\n}\n\n/** Resolve the tool key -> tool map keyed by the tool's effective id. */\nfunction indexToolsById(config: CodeModeConfig): Map Promise }> {\n const map = new Map();\n for (const [key, tool] of Object.entries(config.tools)) {\n const id = (tool as { id?: string }).id ?? key;\n map.set(id, tool);\n }\n return map;\n}\n\n/**\n * Create only the `execute_typescript` tool. Most callers want\n * {@link createCodeMode}, which also returns the matching instructions.\n */\nexport function createCodeModeTool(\n config: CodeModeConfig,\n transport: CodeModeTransport = new StdioCodeModeTransport(),\n) {\n const timeout = config.timeout ?? DEFAULT_TIMEOUT;\n const id = config.id ?? DEFAULT_TOOL_NAME;\n const toolsById = indexToolsById(config);\n const toolIds = [...toolsById.keys()];\n\n return createTool({\n id,\n description:\n 'Execute a TypeScript program that orchestrates the available tools in a sandbox. ' +\n 'Prefer this over calling tools one at a time when a task needs multiple tool calls, ' +\n 'batching, aggregation, or arithmetic.',\n inputSchema: codeModeInputSchema,\n outputSchema: codeModeOutputSchema,\n execute: async ({ code }, ctx): Promise => {\n // Resolve sandbox: explicit config -> workspace from context. There is no\n // implicit fallback: Code Mode runs model-authored code, so the execution\n // boundary must be chosen deliberately. To run locally (host privileges),\n // pass `sandbox: new LocalSandbox()` explicitly.\n const sandbox: WorkspaceSandbox | undefined = config.sandbox ?? ctx?.workspace?.sandbox;\n if (!sandbox) {\n throw new Error(\n 'Code Mode requires a sandbox to run model-authored code, but none was configured. ' +\n 'Pass one to createCodeMode({ tools, sandbox }), or run the agent in a workspace that provides a sandbox. ' +\n 'To execute on the host (host privileges — only for trusted/local use), pass `sandbox: new LocalSandbox()`.',\n );\n }\n\n // Each external_* call re-enters the real Mastra tool pipeline (validation,\n // request-context checks, tracing) on the host, with the outer tool's context.\n const dispatch: CodeModeToolDispatcher = async (toolId, args) => {\n const tool = toolsById.get(toolId);\n if (!tool?.execute) {\n throw new Error(`Tool \"${toolId}\" is not available in Code Mode`);\n }\n const result = await tool.execute(args, {\n mastra: ctx?.mastra,\n requestContext: ctx?.requestContext,\n abortSignal: ctx?.abortSignal,\n workspace: ctx?.workspace,\n });\n if (isValidationError(result)) {\n throw new Error(result.message ?? `Invalid input for tool \"${toolId}\"`);\n }\n return result;\n };\n\n // The TypeScript program is written to a .ts module by the transport;\n // the sandbox's node strips the type annotations natively at import.\n return ctx.observe.span(`code-mode:${id}`, () =>\n transport.run({\n sandbox,\n program: code,\n toolIds,\n dispatch,\n timeout,\n abortSignal: ctx?.abortSignal,\n onExternalCall: (tool, args) => ctx.observe.log('info', 'code-mode external call', { tool, args }),\n onExternalResult: (tool, durationMs, error) =>\n ctx.observe.log(error ? 'error' : 'info', 'code-mode external result', { tool, durationMs }),\n }),\n );\n },\n }) as unknown as Tool;\n}\n\n/**\n * Create Code Mode: the `execute_typescript` tool plus generated instructions.\n *\n * @example\n * ```ts\n * const { tool, instructions } = createCodeMode({ tools: { getTopProducts, getProductRatings } });\n * const agent = new Agent({ instructions: ['You are helpful.', instructions], tools: { [tool.id]: tool } });\n * ```\n */\nexport function createCodeMode(config: CodeModeConfig, transport?: CodeModeTransport): CodeModeResult {\n return {\n tool: createCodeModeTool(config, transport),\n instructions: createCodeModeInstructions(config),\n };\n}\n","import { z } from 'zod/v4';\n\nimport { createTool } from '../tool';\n\n/**\n * A structured choice rendered by the host for an `ask_user` prompt.\n *\n * The label is the value returned to the model when the option is selected. The\n * optional description gives the host more context without changing the answer value.\n */\nexport interface AskUserOption {\n label: string;\n description?: string;\n}\n\n/**\n * Controls whether an `ask_user` prompt accepts one choice or multiple choices.\n *\n * `single_select` is the default for prompts that provide options, preserving the\n * original one-answer behavior. `multi_select` tells the host that the user may choose\n * more than one option and resume with those selections as an array.\n */\nexport type AskUserSelectionMode = 'single_select' | 'multi_select';\n\n/**\n * Answer shape used to resume a suspended `ask_user` call.\n *\n * Free-text and single-select prompts resume with a string. Multi-select prompts\n * resume with a string array containing each selected option label.\n */\nexport type AskUserAnswer = string | string[];\n\n/**\n * Payload carried by the native `tool-call-suspended` event when `ask_user` pauses.\n * Hosts read this to render the question, choices, and selection mode.\n */\nexport interface AskUserSuspendPayload {\n question: string;\n options?: AskUserOption[];\n selectionMode?: AskUserSelectionMode;\n}\n\nconst optionSchema = z.object({\n label: z.string().describe('Short display text for this option (1-5 words)'),\n description: z.string().optional().describe('Explanation of what this option means'),\n});\n\n/**\n * Converts the resume answer into the text returned to the model after `ask_user`\n * resumes. Free-text and single-select prompts already produce a single string,\n * while multi-select prompts resume with an array of selected labels that must be\n * flattened before the tool result is added back into the generation context.\n *\n * The formatter keeps the model-facing output compact by joining multi-select\n * answers with commas, mirroring the single-answer behavior while still preserving\n * every selected option in a readable form.\n */\nexport function formatQuestionAnswer(answer: AskUserAnswer): string {\n return Array.isArray(answer) ? answer.join(', ') : answer;\n}\n\n/**\n * Built-in, agent-agnostic tool: ask the user a question and wait for their response.\n *\n * The tool supports three prompt shapes. Omitting `options` asks an open-ended\n * free-text question. Providing `options` without `selectionMode` asks the host to\n * render a single-select prompt for backwards compatibility. Providing\n * `selectionMode: 'multi_select'` lets the host resume with multiple selected option\n * labels as a string array.\n *\n * Pausing uses the agent-native tool suspension primitive: the tool calls\n * `suspend({ question, options, selectionMode })`, which makes the agent emit a\n * `tool-call-suspended` event and persist run state. The host renders the question,\n * collects the user's answer, and continues the run via `agent.resumeStream(answer)`;\n * the tool re-runs with `resumeData` set to the answer and returns it to the model.\n *\n * When executed without an agent `suspend` (e.g. direct invocation outside an agent\n * run), the tool returns a readable fallback prompt so the question and choices are\n * still surfaced.\n */\nexport const askUserTool = createTool({\n id: 'ask_user',\n description:\n 'Ask the user a question and wait for their response. Use this when you need clarification, want to validate assumptions, or need the user to make a decision between options. Provide options for structured choices (2-4 options), or omit them for open-ended questions. Use selectionMode to choose whether the user can pick one option or multiple options.',\n inputSchema: z.object({\n question: z.string().min(1).describe('The question to ask the user. Should be clear and specific.'),\n options: z\n .array(optionSchema)\n .optional()\n .describe('Optional choices. If provided, shows a selection list. If omitted, shows a free-text input.'),\n selectionMode: z\n .enum(['single_select', 'multi_select'])\n .optional()\n .describe(\n 'Controls how many provided options the user can select. Defaults to single_select when options are provided. Requires options.',\n ),\n }),\n suspendSchema: z.object({\n question: z.string(),\n options: z.array(optionSchema).optional(),\n selectionMode: z.enum(['single_select', 'multi_select']).optional(),\n }),\n resumeSchema: z.union([z.string(), z.array(z.string())]),\n execute: async ({ question, options, selectionMode }, context) => {\n try {\n if (selectionMode && !options?.length) {\n return {\n content: 'Failed to ask user: selectionMode requires options.',\n isError: true,\n };\n }\n\n const resolvedSelectionMode = options?.length ? (selectionMode ?? 'single_select') : undefined;\n\n const resumeData = context?.agent?.resumeData as AskUserAnswer | undefined;\n if (resumeData !== undefined) {\n return { content: `User answered: ${formatQuestionAnswer(resumeData)}`, isError: false };\n }\n\n const suspend = context?.agent?.suspend;\n if (suspend) {\n await suspend({ question, options, selectionMode: resolvedSelectionMode });\n return;\n }\n\n // No agent context available: surface the question as readable text so non-agent\n // execution paths still expose the question and available choices to the model.\n return {\n content: `[Question for user]: ${question}${\n options?.length ? '\\nOptions: ' + options.map(o => o.label).join(', ') : ''\n }${resolvedSelectionMode ? '\\nSelection mode: ' + resolvedSelectionMode : ''}`,\n isError: false,\n };\n } catch (error) {\n const msg = error instanceof Error ? error.message : 'Unknown error';\n return { content: `Failed to ask user: ${msg}`, isError: true };\n }\n },\n});\n","import { z } from 'zod/v4';\n\nimport { createTool } from '../tool';\n\n/**\n * Payload carried by the native `tool-call-suspended` event when `submit_plan` pauses.\n * Hosts read this to render the plan for review with approve/reject controls.\n */\nexport interface SubmitPlanSuspendPayload {\n title: string;\n plan: string;\n}\n\n/**\n * The action a host resumes a suspended `submit_plan` call with.\n *\n * `approved` means the user accepted the plan and the agent should proceed. `rejected`\n * means the user wants revisions; the optional `feedback` is surfaced to the model so it\n * can revise and submit again.\n *\n * Hosts that layer additional behavior on approval (e.g. a Harness switching from a\n * planning mode to an execution mode) drive that from their own response handling; the\n * tool itself only reports the outcome back to the model.\n */\nexport interface SubmitPlanResumeData {\n action: 'approved' | 'rejected';\n feedback?: string;\n}\n\nconst resumeSchema = z.object({\n action: z.enum(['approved', 'rejected']),\n feedback: z.string().optional(),\n});\n\n/**\n * Built-in, agent-agnostic tool: submit an implementation plan for user review.\n *\n * Pausing uses the agent-native tool suspension primitive: the tool calls\n * `suspend({ title, plan })`, which makes the agent emit a `tool-call-suspended` event\n * and persist run state. The host renders the plan, collects an approve/reject decision,\n * and continues the run via `agent.resumeStream({ action, feedback })`; the tool re-runs\n * with `resumeData` set to that decision and reports it back to the model.\n *\n * This tool is deliberately host-agnostic: it does not know about Harness modes or any\n * UI. A plain Agent (e.g. embedded in Studio or a customer app) can use it directly, and\n * a Harness can layer mode-switch behavior on top of the approval in its own response\n * handling without the tool needing to change.\n *\n * When executed without an agent `suspend` (e.g. direct invocation outside an agent run),\n * the tool returns the plan as readable text so it is still surfaced.\n */\nexport const submitPlanTool = createTool({\n id: 'submit_plan',\n description:\n 'Submit a completed implementation plan for user review. The plan will be rendered as markdown and the user can approve, reject, or request changes. Use this when your exploration is complete and you have a concrete plan ready for review. On approval, the system automatically switches to the default mode so you can implement.',\n inputSchema: z.object({\n title: z.string().optional().describe(\"Short title for the plan (e.g., 'Add dark mode toggle')\"),\n plan: z\n .string()\n .min(1)\n .describe('The full plan content in markdown format. Should include Overview, Steps, and Verification sections.'),\n }),\n suspendSchema: z.object({\n title: z.string(),\n plan: z.string(),\n }),\n resumeSchema,\n execute: async ({ title, plan }, context) => {\n try {\n const resolvedTitle = title || 'Implementation Plan';\n\n const resumeData = context?.agent?.resumeData as SubmitPlanResumeData | undefined;\n if (resumeData !== undefined) {\n if (resumeData.action === 'approved') {\n return {\n content: 'Plan approved. Proceed with implementation following the approved plan.',\n isError: false,\n };\n }\n\n const feedback = resumeData.feedback ? `\\n\\nUser feedback: ${resumeData.feedback}` : '';\n return {\n content: `Plan was not approved. The user wants revisions.${feedback}\\n\\nPlease revise the plan based on the feedback and submit again with submit_plan.`,\n isError: false,\n };\n }\n\n const suspend = context?.agent?.suspend;\n if (suspend) {\n await suspend({ title: resolvedTitle, plan });\n return;\n }\n\n // No agent context available: surface the plan as readable text so non-agent\n // execution paths still expose it to the model.\n return {\n content: `[Plan submitted for review]\\n\\nTitle: ${resolvedTitle}\\n\\n${plan}`,\n isError: false,\n };\n } catch (error) {\n const msg = error instanceof Error ? error.message : 'Unknown error';\n return { content: `Failed to submit plan: ${msg}`, isError: true };\n }\n },\n});\n"]}