@xortex/xcode 3.0.0

package/tools/SkillTool/UI.tsx

@@ -0,0 +1,128 @@
+import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs';
+import * as React from 'react';
+import { SubAgentProvider } from 'src/components/CtrlOToExpand.js';
+import { FallbackToolUseErrorMessage } from 'src/components/FallbackToolUseErrorMessage.js';
+import { FallbackToolUseRejectedMessage } from 'src/components/FallbackToolUseRejectedMessage.js';
+import type { z } from 'zod/v4';
+import type { Command } from '../../commands.js';
+import { Byline } from '../../components/design-system/Byline.js';
+import { Message as MessageComponent } from '../../components/Message.js';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { Box, Text } from '../../ink.js';
+import type { Tools } from '../../Tool.js';
+import type { ProgressMessage } from '../../types/message.js';
+import { buildSubagentLookups, EMPTY_LOOKUPS } from '../../utils/messages.js';
+import { plural } from '../../utils/stringUtils.js';
+import type { inputSchema, Output, Progress } from './SkillTool.js';
+type Input = z.infer<ReturnType<typeof inputSchema>>;
+const MAX_PROGRESS_MESSAGES_TO_SHOW = 3;
+const INITIALIZING_TEXT = 'Initializing…';
+export function renderToolResultMessage(output: Output): React.ReactNode {
+  // Handle forked skill result
+  if ('status' in output && output.status === 'forked') {
+    return <MessageResponse height={1}>
+        <Text>
+          <Byline>{['Done']}</Byline>
+        </Text>
+      </MessageResponse>;
+  }
+  const parts: string[] = ['Successfully loaded skill'];
+
+  // Show tools count (only for inline skills)
+  if ('allowedTools' in output && output.allowedTools && output.allowedTools.length > 0) {
+    const count = output.allowedTools.length;
+    parts.push(`${count} ${plural(count, 'tool')} allowed`);
+  }
+
+  // Show model if non-default (only for inline skills)
+  if ('model' in output && output.model) {
+    parts.push(output.model);
+  }
+  return <MessageResponse height={1}>
+      <Text>
+        <Byline>{parts}</Byline>
+      </Text>
+    </MessageResponse>;
+}
+export function renderToolUseMessage({
+  skill
+}: Partial<Input>, {
+  commands
+}: {
+  commands?: Command[];
+}): React.ReactNode {
+  if (!skill) {
+    return null;
+  }
+  // Look up the command to check if it came from the legacy /commands folder
+  const command = commands?.find(c => c.name === skill);
+  const displayName = command?.loadedFrom === 'commands_DEPRECATED' ? `/${skill}` : skill;
+  return displayName;
+}
+export function renderToolUseProgressMessage(progressMessages: ProgressMessage<Progress>[], {
+  tools,
+  verbose
+}: {
+  tools: Tools;
+  verbose: boolean;
+}): React.ReactNode {
+  if (!progressMessages.length) {
+    return <MessageResponse height={1}>
+        <Text dimColor>{INITIALIZING_TEXT}</Text>
+      </MessageResponse>;
+  }
+
+  // Take only the last few messages for display in non-verbose mode
+  const displayedMessages = verbose ? progressMessages : progressMessages.slice(-MAX_PROGRESS_MESSAGES_TO_SHOW);
+  const hiddenCount = progressMessages.length - displayedMessages.length;
+  const {
+    inProgressToolUseIDs
+  } = buildSubagentLookups(progressMessages.map(pm => pm.data));
+  return <MessageResponse>
+      <Box flexDirection="column">
+        <SubAgentProvider>
+          {displayedMessages.map(progressMessage => <Box key={progressMessage.uuid} height={1} overflow="hidden">
+              <MessageComponent message={progressMessage.data.message} lookups={EMPTY_LOOKUPS} addMargin={false} tools={tools} commands={[]} verbose={verbose} inProgressToolUseIDs={inProgressToolUseIDs} progressMessagesForMessage={[]} shouldAnimate={false} shouldShowDot={false} style="condensed" isTranscriptMode={false} isStatic={true} />
+            </Box>)}
+        </SubAgentProvider>
+        {hiddenCount > 0 && <Text dimColor>
+            +{hiddenCount} more tool {plural(hiddenCount, 'use')}
+          </Text>}
+      </Box>
+    </MessageResponse>;
+}
+export function renderToolUseRejectedMessage(_input: Input, {
+  progressMessagesForMessage,
+  tools,
+  verbose
+}: {
+  progressMessagesForMessage: ProgressMessage<Progress>[];
+  tools: Tools;
+  verbose: boolean;
+}): React.ReactNode {
+  return <>
+      {renderToolUseProgressMessage(progressMessagesForMessage, {
+      tools,
+      verbose
+    })}
+      <FallbackToolUseRejectedMessage />
+    </>;
+}
+export function renderToolUseErrorMessage(result: ToolResultBlockParam['content'], {
+  progressMessagesForMessage,
+  tools,
+  verbose
+}: {
+  progressMessagesForMessage: ProgressMessage<Progress>[];
+  tools: Tools;
+  verbose: boolean;
+}): React.ReactNode {
+  return <>
+      {renderToolUseProgressMessage(progressMessagesForMessage, {
+      tools,
+      verbose
+    })}
+      <FallbackToolUseErrorMessage result={result} verbose={verbose} />
+    </>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ToolResultBlockParam","React","SubAgentProvider","FallbackToolUseErrorMessage","FallbackToolUseRejectedMessage","z","Command","Byline","Message","MessageComponent","MessageResponse","Box","Text","Tools","ProgressMessage","buildSubagentLookups","EMPTY_LOOKUPS","plural","inputSchema","Output","Progress","Input","infer","ReturnType","MAX_PROGRESS_MESSAGES_TO_SHOW","INITIALIZING_TEXT","renderToolResultMessage","output","ReactNode","status","parts","allowedTools","length","count","push","model","renderToolUseMessage","skill","Partial","commands","command","find","c","name","displayName","loadedFrom","renderToolUseProgressMessage","progressMessages","tools","verbose","displayedMessages","slice","hiddenCount","inProgressToolUseIDs","map","pm","data","progressMessage","uuid","message","renderToolUseRejectedMessage","_input","progressMessagesForMessage","renderToolUseErrorMessage","result"],"sources":["UI.tsx"],"sourcesContent":["import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'\nimport * as React from 'react'\nimport { SubAgentProvider } from 'src/components/CtrlOToExpand.js'\nimport { FallbackToolUseErrorMessage } from 'src/components/FallbackToolUseErrorMessage.js'\nimport { FallbackToolUseRejectedMessage } from 'src/components/FallbackToolUseRejectedMessage.js'\nimport type { z } from 'zod/v4'\nimport type { Command } from '../../commands.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { Message as MessageComponent } from '../../components/Message.js'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { Box, Text } from '../../ink.js'\nimport type { Tools } from '../../Tool.js'\nimport type { ProgressMessage } from '../../types/message.js'\nimport { buildSubagentLookups, EMPTY_LOOKUPS } from '../../utils/messages.js'\nimport { plural } from '../../utils/stringUtils.js'\nimport type { inputSchema, Output, Progress } from './SkillTool.js'\n\ntype Input = z.infer<ReturnType<typeof inputSchema>>\n\nconst MAX_PROGRESS_MESSAGES_TO_SHOW = 3\nconst INITIALIZING_TEXT = 'Initializing…'\n\nexport function renderToolResultMessage(output: Output): React.ReactNode {\n  // Handle forked skill result\n  if ('status' in output && output.status === 'forked') {\n    return (\n      <MessageResponse height={1}>\n        <Text>\n          <Byline>{['Done']}</Byline>\n        </Text>\n      </MessageResponse>\n    )\n  }\n\n  const parts: string[] = ['Successfully loaded skill']\n\n  // Show tools count (only for inline skills)\n  if (\n    'allowedTools' in output &&\n    output.allowedTools &&\n    output.allowedTools.length > 0\n  ) {\n    const count = output.allowedTools.length\n    parts.push(`${count} ${plural(count, 'tool')} allowed`)\n  }\n\n  // Show model if non-default (only for inline skills)\n  if ('model' in output && output.model) {\n    parts.push(output.model)\n  }\n\n  return (\n    <MessageResponse height={1}>\n      <Text>\n        <Byline>{parts}</Byline>\n      </Text>\n    </MessageResponse>\n  )\n}\n\nexport function renderToolUseMessage(\n  { skill }: Partial<Input>,\n  { commands }: { commands?: Command[] },\n): React.ReactNode {\n  if (!skill) {\n    return null\n  }\n  // Look up the command to check if it came from the legacy /commands folder\n  const command = commands?.find(c => c.name === skill)\n  const displayName =\n    command?.loadedFrom === 'commands_DEPRECATED' ? `/${skill}` : skill\n  return displayName\n}\n\nexport function renderToolUseProgressMessage(\n  progressMessages: ProgressMessage<Progress>[],\n  {\n    tools,\n    verbose,\n  }: {\n    tools: Tools\n    verbose: boolean\n  },\n): React.ReactNode {\n  if (!progressMessages.length) {\n    return (\n      <MessageResponse height={1}>\n        <Text dimColor>{INITIALIZING_TEXT}</Text>\n      </MessageResponse>\n    )\n  }\n\n  // Take only the last few messages for display in non-verbose mode\n  const displayedMessages = verbose\n    ? progressMessages\n    : progressMessages.slice(-MAX_PROGRESS_MESSAGES_TO_SHOW)\n\n  const hiddenCount = progressMessages.length - displayedMessages.length\n  const { inProgressToolUseIDs } = buildSubagentLookups(\n    progressMessages.map(pm => pm.data),\n  )\n\n  return (\n    <MessageResponse>\n      <Box flexDirection=\"column\">\n        <SubAgentProvider>\n          {displayedMessages.map(progressMessage => (\n            <Box key={progressMessage.uuid} height={1} overflow=\"hidden\">\n              <MessageComponent\n                message={progressMessage.data.message}\n                lookups={EMPTY_LOOKUPS}\n                addMargin={false}\n                tools={tools}\n                commands={[]}\n                verbose={verbose}\n                inProgressToolUseIDs={inProgressToolUseIDs}\n                progressMessagesForMessage={[]}\n                shouldAnimate={false}\n                shouldShowDot={false}\n                style=\"condensed\"\n                isTranscriptMode={false}\n                isStatic={true}\n              />\n            </Box>\n          ))}\n        </SubAgentProvider>\n        {hiddenCount > 0 && (\n          <Text dimColor>\n            +{hiddenCount} more tool {plural(hiddenCount, 'use')}\n          </Text>\n        )}\n      </Box>\n    </MessageResponse>\n  )\n}\n\nexport function renderToolUseRejectedMessage(\n  _input: Input,\n  {\n    progressMessagesForMessage,\n    tools,\n    verbose,\n  }: {\n    progressMessagesForMessage: ProgressMessage<Progress>[]\n    tools: Tools\n    verbose: boolean\n  },\n): React.ReactNode {\n  return (\n    <>\n      {renderToolUseProgressMessage(progressMessagesForMessage, {\n        tools,\n        verbose,\n      })}\n      <FallbackToolUseRejectedMessage />\n    </>\n  )\n}\n\nexport function renderToolUseErrorMessage(\n  result: ToolResultBlockParam['content'],\n  {\n    progressMessagesForMessage,\n    tools,\n    verbose,\n  }: {\n    progressMessagesForMessage: ProgressMessage<Progress>[]\n    tools: Tools\n    verbose: boolean\n  },\n): React.ReactNode {\n  return (\n    <>\n      {renderToolUseProgressMessage(progressMessagesForMessage, {\n        tools,\n        verbose,\n      })}\n      <FallbackToolUseErrorMessage result={result} verbose={verbose} />\n    </>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/tools/SkillTool/constants.ts

@@ -0,0 +1 @@
+export const SKILL_TOOL_NAME = 'Skill'

package/tools/SkillTool/prompt.ts

@@ -0,0 +1,241 @@
+import { memoize } from 'lodash-es'
+import type { Command } from 'src/commands.js'
+import {
+  getCommandName,
+  getSkillToolCommands,
+  getSlashCommandToolSkills,
+} from 'src/commands.js'
+import { COMMAND_NAME_TAG } from '../../constants/xml.js'
+import { stringWidth } from '../../ink/stringWidth.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../services/analytics/index.js'
+import { count } from '../../utils/array.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { toError } from '../../utils/errors.js'
+import { truncate } from '../../utils/format.js'
+import { logError } from '../../utils/log.js'
+
+// Skill listing gets 1% of the context window (in characters)
+export const SKILL_BUDGET_CONTEXT_PERCENT = 0.01
+export const CHARS_PER_TOKEN = 4
+export const DEFAULT_CHAR_BUDGET = 8_000 // Fallback: 1% of 200k × 4
+
+// Per-entry hard cap. The listing is for discovery only — the Skill tool loads
+// full content on invoke, so verbose whenToUse strings waste turn-1 cache_creation
+// tokens without improving match rate. Applies to all entries, including bundled,
+// since the cap is generous enough to preserve the core use case.
+export const MAX_LISTING_DESC_CHARS = 250
+
+export function getCharBudget(contextWindowTokens?: number): number {
+  if (Number(process.env.SLASH_COMMAND_TOOL_CHAR_BUDGET)) {
+    return Number(process.env.SLASH_COMMAND_TOOL_CHAR_BUDGET)
+  }
+  if (contextWindowTokens) {
+    return Math.floor(
+      contextWindowTokens * CHARS_PER_TOKEN * SKILL_BUDGET_CONTEXT_PERCENT,
+    )
+  }
+  return DEFAULT_CHAR_BUDGET
+}
+
+function getCommandDescription(cmd: Command): string {
+  const desc = cmd.whenToUse
+    ? `${cmd.description} - ${cmd.whenToUse}`
+    : cmd.description
+  return desc.length > MAX_LISTING_DESC_CHARS
+    ? desc.slice(0, MAX_LISTING_DESC_CHARS - 1) + '\u2026'
+    : desc
+}
+
+function formatCommandDescription(cmd: Command): string {
+  // Debug: log if userFacingName differs from cmd.name for plugin skills
+  const displayName = getCommandName(cmd)
+  if (
+    cmd.name !== displayName &&
+    cmd.type === 'prompt' &&
+    cmd.source === 'plugin'
+  ) {
+    logForDebugging(
+      `Skill prompt: showing "${cmd.name}" (userFacingName="${displayName}")`,
+    )
+  }
+
+  return `- ${cmd.name}: ${getCommandDescription(cmd)}`
+}
+
+const MIN_DESC_LENGTH = 20
+
+export function formatCommandsWithinBudget(
+  commands: Command[],
+  contextWindowTokens?: number,
+): string {
+  if (commands.length === 0) return ''
+
+  const budget = getCharBudget(contextWindowTokens)
+
+  // Try full descriptions first
+  const fullEntries = commands.map(cmd => ({
+    cmd,
+    full: formatCommandDescription(cmd),
+  }))
+  // join('\n') produces N-1 newlines for N entries
+  const fullTotal =
+    fullEntries.reduce((sum, e) => sum + stringWidth(e.full), 0) +
+    (fullEntries.length - 1)
+
+  if (fullTotal <= budget) {
+    return fullEntries.map(e => e.full).join('\n')
+  }
+
+  // Partition into bundled (never truncated) and rest
+  const bundledIndices = new Set<number>()
+  const restCommands: Command[] = []
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i]!
+    if (cmd.type === 'prompt' && cmd.source === 'bundled') {
+      bundledIndices.add(i)
+    } else {
+      restCommands.push(cmd)
+    }
+  }
+
+  // Compute space used by bundled skills (full descriptions, always preserved)
+  const bundledChars = fullEntries.reduce(
+    (sum, e, i) =>
+      bundledIndices.has(i) ? sum + stringWidth(e.full) + 1 : sum,
+    0,
+  )
+  const remainingBudget = budget - bundledChars
+
+  // Calculate max description length for non-bundled commands
+  if (restCommands.length === 0) {
+    return fullEntries.map(e => e.full).join('\n')
+  }
+
+  const restNameOverhead =
+    restCommands.reduce((sum, cmd) => sum + stringWidth(cmd.name) + 4, 0) +
+    (restCommands.length - 1)
+  const availableForDescs = remainingBudget - restNameOverhead
+  const maxDescLen = Math.floor(availableForDescs / restCommands.length)
+
+  if (maxDescLen < MIN_DESC_LENGTH) {
+    // Extreme case: non-bundled go names-only, bundled keep descriptions
+    if (process.env.USER_TYPE === 'ant') {
+      logEvent('tengu_skill_descriptions_truncated', {
+        skill_count: commands.length,
+        budget,
+        full_total: fullTotal,
+        truncation_mode:
+          'names_only' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        max_desc_length: maxDescLen,
+        bundled_count: bundledIndices.size,
+        bundled_chars: bundledChars,
+      })
+    }
+    return commands
+      .map((cmd, i) =>
+        bundledIndices.has(i) ? fullEntries[i]!.full : `- ${cmd.name}`,
+      )
+      .join('\n')
+  }
+
+  // Truncate non-bundled descriptions to fit within budget
+  const truncatedCount = count(
+    restCommands,
+    cmd => stringWidth(getCommandDescription(cmd)) > maxDescLen,
+  )
+  if (process.env.USER_TYPE === 'ant') {
+    logEvent('tengu_skill_descriptions_truncated', {
+      skill_count: commands.length,
+      budget,
+      full_total: fullTotal,
+      truncation_mode:
+        'description_trimmed' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      max_desc_length: maxDescLen,
+      truncated_count: truncatedCount,
+      // Count of bundled skills included in this prompt (excludes skills with disableModelInvocation)
+      bundled_count: bundledIndices.size,
+      bundled_chars: bundledChars,
+    })
+  }
+  return commands
+    .map((cmd, i) => {
+      // Bundled skills always get full descriptions
+      if (bundledIndices.has(i)) return fullEntries[i]!.full
+      const description = getCommandDescription(cmd)
+      return `- ${cmd.name}: ${truncate(description, maxDescLen)}`
+    })
+    .join('\n')
+}
+
+export const getPrompt = memoize(async (_cwd: string): Promise<string> => {
+  return `Execute a skill within the main conversation
+
+When users ask you to perform tasks, check if any of the available skills match. Skills provide specialized capabilities and domain knowledge.
+
+When users reference a "slash command" or "/<something>" (e.g., "/commit", "/review-pr"), they are referring to a skill. Use this tool to invoke it.
+
+How to invoke:
+- Use this tool with the skill name and optional arguments
+- Examples:
+  - \`skill: "pdf"\` - invoke the pdf skill
+  - \`skill: "commit", args: "-m 'Fix bug'"\` - invoke with arguments
+  - \`skill: "review-pr", args: "123"\` - invoke with arguments
+  - \`skill: "ms-office-suite:pdf"\` - invoke using fully qualified name
+
+Important:
+- Available skills are listed in system-reminder messages in the conversation
+- When a skill matches the user's request, this is a BLOCKING REQUIREMENT: invoke the relevant Skill tool BEFORE generating any other response about the task
+- NEVER mention a skill without actually calling this tool
+- Do not invoke a skill that is already running
+- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)
+- If you see a <${COMMAND_NAME_TAG}> tag in the current conversation turn, the skill has ALREADY been loaded - follow the instructions directly instead of calling this tool again
+`
+})
+
+export async function getSkillToolInfo(cwd: string): Promise<{
+  totalCommands: number
+  includedCommands: number
+}> {
+  const agentCommands = await getSkillToolCommands(cwd)
+
+  return {
+    totalCommands: agentCommands.length,
+    includedCommands: agentCommands.length,
+  }
+}
+
+// Returns the commands included in the SkillTool prompt.
+// All commands are always included (descriptions may be truncated to fit budget).
+// Used by analyzeContext to count skill tokens.
+export function getLimitedSkillToolCommands(cwd: string): Promise<Command[]> {
+  return getSkillToolCommands(cwd)
+}
+
+export function clearPromptCache(): void {
+  getPrompt.cache?.clear?.()
+}
+
+export async function getSkillInfo(cwd: string): Promise<{
+  totalSkills: number
+  includedSkills: number
+}> {
+  try {
+    const skills = await getSlashCommandToolSkills(cwd)
+
+    return {
+      totalSkills: skills.length,
+      includedSkills: skills.length,
+    }
+  } catch (error) {
+    logError(toError(error))
+
+    // Return zeros rather than throwing - let caller decide how to handle
+    return {
+      totalSkills: 0,
+      includedSkills: 0,
+    }
+  }
+}

package/tools/SleepTool/prompt.ts

@@ -0,0 +1,17 @@
+import { TICK_TAG } from '../../constants/xml.js'
+
+export const SLEEP_TOOL_NAME = 'Sleep'
+
+export const DESCRIPTION = 'Wait for a specified duration'
+
+export const SLEEP_TOOL_PROMPT = `Wait for a specified duration. The user can interrupt the sleep at any time.
+
+Use this when the user tells you to sleep or rest, when you have nothing to do, or when you're waiting for something.
+
+You may receive <${TICK_TAG}> prompts — these are periodic check-ins. Look for useful work to do before sleeping.
+
+You can call this concurrently with other tools — it won't interfere with them.
+
+Prefer this over \`Bash(sleep ...)\` — it doesn't hold a shell process.
+
+Each wake-up costs an API call, but the prompt cache expires after 5 minutes of inactivity — balance accordingly.`

package/tools/SyntheticOutputTool/SyntheticOutputTool.ts

@@ -0,0 +1,163 @@
+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) }
+  }
+}