headlesscode 1.0.2

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/attempt_completion.ts

@@ -0,0 +1,33 @@
+import type OpenAI from "openai"
+
+const ATTEMPT_COMPLETION_DESCRIPTION = `After each tool use, the user will respond with the result of that tool use, i.e. if it succeeded or failed, along with any reasons for failure. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again.
+
+IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user that any previous tool uses were successful. Failure to do so will result in code corruption and system failure. Before using this tool, you must confirm that you've received successful results from the user for any previous tool uses. If not, then DO NOT use this tool.
+
+Parameters:
+- result: (required) The result of the task. Formulate this result in a way that is final and does not require further input from the user. Don't end your result with questions or offers for further assistance.
+
+Example: Completing after updating CSS
+{ "result": "I've updated the CSS to use flexbox layout for better responsiveness" }`
+
+const RESULT_PARAMETER_DESCRIPTION = `Final result message to deliver to the user once the task is complete`
+
+export default {
+	type: "function",
+	function: {
+		name: "attempt_completion",
+		description: ATTEMPT_COMPLETION_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				result: {
+					type: "string",
+					description: RESULT_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["result"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/codebase_search.ts

@@ -0,0 +1,43 @@
+import type OpenAI from "openai"
+
+const CODEBASE_SEARCH_DESCRIPTION = `Find files most relevant to the search query using semantic search. Searches based on meaning rather than exact text matches. By default searches entire workspace. Reuse the user's exact wording unless there's a clear reason not to - their phrasing often helps semantic search. Queries MUST be in English (translate if needed).
+
+**CRITICAL: For ANY exploration of code you haven't examined yet in this conversation, you MUST use this tool FIRST before any other search or file exploration tools.** This applies throughout the entire conversation, not just at the beginning. This tool uses semantic search to find relevant code based on meaning rather than just keywords, making it far more effective than regex-based search_files for understanding implementations. Even if you've already explored some code, any new area of exploration requires codebase_search first.
+
+Parameters:
+- query: (required) The search query. Reuse the user's exact wording/question format unless there's a clear reason not to.
+- path: (optional) Limit search to specific subdirectory (relative to the current workspace directory). Leave empty for entire workspace.
+
+Example: Searching for user authentication code
+{ "query": "User login and password hashing", "path": "src/auth" }
+
+Example: Searching entire workspace
+{ "query": "database connection pooling", "path": null }`
+
+const QUERY_PARAMETER_DESCRIPTION = `Meaning-based search query describing the information you need`
+
+const PATH_PARAMETER_DESCRIPTION = `Optional subdirectory (relative to the workspace) to limit the search scope`
+
+export default {
+	type: "function",
+	function: {
+		name: "codebase_search",
+		description: CODEBASE_SEARCH_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				query: {
+					type: "string",
+					description: QUERY_PARAMETER_DESCRIPTION,
+				},
+				path: {
+					type: ["string", "null"],
+					description: PATH_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["query", "path"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/converters.ts

@@ -0,0 +1,109 @@
+import type OpenAI from "openai"
+import type Anthropic from "../../../../../shim/anthropic"
+
+/**
+ * Converts an OpenAI ChatCompletionTool to Anthropic's Tool format.
+ *
+ * OpenAI format wraps the tool definition in a `function` object with `parameters`,
+ * while Anthropic uses a flatter structure with `input_schema`.
+ *
+ * @param tool - OpenAI ChatCompletionTool to convert
+ * @returns Anthropic Tool definition
+ *
+ * @example
+ * ```typescript
+ * const openAITool = {
+ *   type: "function",
+ *   function: {
+ *     name: "get_weather",
+ *     description: "Get weather",
+ *     parameters: { type: "object", properties: {...} }
+ *   }
+ * }
+ *
+ * const anthropicTool = convertOpenAIToolToAnthropic(openAITool)
+ * // Returns: { name: "get_weather", description: "Get weather", input_schema: {...} }
+ * ```
+ */
+export function convertOpenAIToolToAnthropic(tool: OpenAI.Chat.ChatCompletionTool): Anthropic.Tool {
+	// Handle both ChatCompletionFunctionTool and ChatCompletionCustomTool
+	if (tool.type !== "function") {
+		throw new Error(`Unsupported tool type: ${tool.type}`)
+	}
+
+	return {
+		name: tool.function.name,
+		description: tool.function.description || "",
+		input_schema: tool.function.parameters as Anthropic.Tool.InputSchema,
+	}
+}
+
+/**
+ * Converts an array of OpenAI ChatCompletionTools to Anthropic's Tool format.
+ *
+ * @param tools - Array of OpenAI ChatCompletionTools to convert
+ * @returns Array of Anthropic Tool definitions
+ */
+export function convertOpenAIToolsToAnthropic(tools: OpenAI.Chat.ChatCompletionTool[]): Anthropic.Tool[] {
+	return tools.map(convertOpenAIToolToAnthropic)
+}
+
+/**
+ * Converts OpenAI tool_choice to Anthropic ToolChoice format.
+ *
+ * Maps OpenAI's tool_choice parameter to Anthropic's equivalent format:
+ * - "none" → undefined (Anthropic doesn't have "none", just omit tools)
+ * - "auto" → { type: "auto" }
+ * - "required" → { type: "any" }
+ * - { type: "function", function: { name } } → { type: "tool", name }
+ *
+ * @param toolChoice - OpenAI tool_choice parameter
+ * @param parallelToolCalls - When true (default), allows parallel tool calls. When false, disables parallel tool calls.
+ * @returns Anthropic ToolChoice or undefined if tools should be omitted
+ *
+ * @example
+ * ```typescript
+ * convertOpenAIToolChoiceToAnthropic("auto", false)
+ * // Returns: { type: "auto", disable_parallel_tool_use: true }
+ *
+ * convertOpenAIToolChoiceToAnthropic({ type: "function", function: { name: "get_weather" } })
+ * // Returns: { type: "tool", name: "get_weather", disable_parallel_tool_use: false }
+ * ```
+ */
+export function convertOpenAIToolChoiceToAnthropic(
+	toolChoice: OpenAI.Chat.ChatCompletionCreateParams["tool_choice"],
+	parallelToolCalls?: boolean,
+): Anthropic.Messages.MessageCreateParams["tool_choice"] | undefined {
+	// Parallel tool calls are enabled by default. When parallelToolCalls is explicitly false,
+	// we disable parallel tool use to ensure one tool call at a time.
+	const disableParallelToolUse = parallelToolCalls === false
+
+	if (!toolChoice) {
+		// Default to auto with parallel tool use control
+		return { type: "auto", disable_parallel_tool_use: disableParallelToolUse }
+	}
+
+	if (typeof toolChoice === "string") {
+		switch (toolChoice) {
+			case "none":
+				return undefined // Anthropic doesn't have "none", just omit tools
+			case "auto":
+				return { type: "auto", disable_parallel_tool_use: disableParallelToolUse }
+			case "required":
+				return { type: "any", disable_parallel_tool_use: disableParallelToolUse }
+			default:
+				return { type: "auto", disable_parallel_tool_use: disableParallelToolUse }
+		}
+	}
+
+	// Handle object form { type: "function", function: { name: string } }
+	if (typeof toolChoice === "object" && "function" in toolChoice) {
+		return {
+			type: "tool",
+			name: toolChoice.function.name,
+			disable_parallel_tool_use: disableParallelToolUse,
+		}
+	}
+
+	return { type: "auto", disable_parallel_tool_use: disableParallelToolUse }
+}

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/edit.ts

@@ -0,0 +1,48 @@
+import type OpenAI from "openai"
+
+const EDIT_DESCRIPTION = `Performs exact string replacements in files.
+
+Usage:
+- You must use your \`Read\` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file.
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`.
+- Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`
+
+const edit = {
+	type: "function",
+	function: {
+		name: "edit",
+		description: EDIT_DESCRIPTION,
+		parameters: {
+			type: "object",
+			properties: {
+				file_path: {
+					type: "string",
+					description: "The path of the file to edit (relative to the working directory)",
+				},
+				old_string: {
+					type: "string",
+					description:
+						"The exact text to find in the file. Must match exactly, including all whitespace, indentation, and line endings.",
+				},
+				new_string: {
+					type: "string",
+					description:
+						"The replacement text that will replace old_string. Must include all necessary whitespace and indentation.",
+				},
+				replace_all: {
+					type: "boolean",
+					description:
+						"When true, replaces ALL occurrences of old_string in the file. When false (default), only replaces the first occurrence and errors if multiple matches exist.",
+					default: false,
+				},
+			},
+			required: ["file_path", "old_string", "new_string"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool
+
+export default edit

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/edit_file.ts

@@ -0,0 +1,72 @@
+import type OpenAI from "openai"
+
+const EDIT_FILE_DESCRIPTION = `Use this tool to replace text in an existing file, or create a new file.
+
+This tool performs literal string replacement with support for multiple occurrences.
+
+To be resilient to minor formatting drift, the tool normalizes line endings (CRLF/LF) for matching and may fall back to deterministic matching strategies when an exact literal match fails (exact → whitespace-tolerant match → token-based match). The original file's line endings are preserved when writing.
+
+USAGE PATTERNS:
+
+1. MODIFY EXISTING FILE (default):
+   - Provide file_path, old_string (text to find), and new_string (replacement)
+   - By default, expects exactly 1 occurrence of old_string
+   - Use expected_replacements to replace multiple occurrences
+
+2. CREATE NEW FILE:
+   - Set old_string to empty string ""
+   - new_string becomes the entire file content
+   - File must not already exist
+
+CRITICAL REQUIREMENTS:
+
+1. EXACT MATCHING (BEST): The old_string should match the file contents EXACTLY, including:
+    - All whitespace (spaces, tabs, newlines)
+    - All indentation
+    - All punctuation and special characters
+
+2. CONTEXT FOR UNIQUENESS: For single replacements (default), include at least 3 lines of context BEFORE and AFTER the target text to ensure uniqueness.
+
+3. MULTIPLE REPLACEMENTS: If you need to replace multiple identical occurrences:
+   - Set expected_replacements to the exact count you expect to replace
+   - ALL occurrences will be replaced
+
+4. NO ESCAPING: Provide the literal text - do not escape special characters.`
+
+const edit_file = {
+	type: "function",
+	function: {
+		name: "edit_file",
+		description: EDIT_FILE_DESCRIPTION,
+		parameters: {
+			type: "object",
+			properties: {
+				file_path: {
+					type: "string",
+					description:
+						"The path to the file to modify or create. You can use either a relative path in the workspace or an absolute path. If an absolute path is provided, it will be preserved as is.",
+				},
+				old_string: {
+					type: "string",
+					description:
+						"The exact literal text to replace (must match the file contents exactly, including all whitespace and indentation). For single replacements (default), include at least 3 lines of context BEFORE and AFTER the target text. Use empty string to create a new file.",
+				},
+				new_string: {
+					type: "string",
+					description:
+						"The exact literal text to replace old_string with. When creating a new file (old_string is empty), this becomes the file content.",
+				},
+				expected_replacements: {
+					type: "number",
+					description:
+						"Number of replacements expected. Defaults to 1 if not specified. Use when you want to replace multiple occurrences of the same text.",
+					minimum: 1,
+				},
+			},
+			required: ["file_path", "old_string", "new_string"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool
+
+export default edit_file

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/execute_command.ts

@@ -0,0 +1,54 @@
+import type OpenAI from "openai"
+
+const EXECUTE_COMMAND_DESCRIPTION = `Request to execute a CLI command on the system. Use this when you need to perform system operations or run specific commands to accomplish any step in the user's task. You must tailor your command to the user's system and provide a clear explanation of what the command does. For command chaining, use the appropriate chaining syntax for the user's shell. Prefer to execute complex CLI commands over creating executable scripts, as they are more flexible and easier to run. Prefer relative commands and paths that avoid location sensitivity for terminal consistency.
+
+Parameters:
+- command: (required) The CLI command to execute. This should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
+- cwd: (optional) The working directory to execute the command in
+- timeout: (optional) Timeout in seconds. When exceeded, the command keeps running in the background and you receive the output so far. Set this for commands that may run indefinitely, such as dev servers or file watchers, so you can proceed without waiting for them to exit.
+
+Example: Executing npm run dev
+{ "command": "npm run dev", "cwd": null, "timeout": null }
+
+Example: Executing ls in a specific directory if directed
+{ "command": "ls -la", "cwd": "/home/user/projects", "timeout": null }
+
+Example: Using relative paths
+{ "command": "touch ./testdata/example.file", "cwd": null, "timeout": null }
+
+Example: Running a build with a timeout
+{ "command": "npm run build", "cwd": null, "timeout": 30 }`
+
+const COMMAND_PARAMETER_DESCRIPTION = `Shell command to execute`
+
+const CWD_PARAMETER_DESCRIPTION = `Optional working directory for the command, relative or absolute`
+
+const TIMEOUT_PARAMETER_DESCRIPTION = `Timeout in seconds. When exceeded, the command continues running in the background and output collected so far is returned. Use this for long-running processes like dev servers, file watchers, or any command that may not exit on its own`
+
+export default {
+	type: "function",
+	function: {
+		name: "execute_command",
+		description: EXECUTE_COMMAND_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				command: {
+					type: "string",
+					description: COMMAND_PARAMETER_DESCRIPTION,
+				},
+				cwd: {
+					type: ["string", "null"],
+					description: CWD_PARAMETER_DESCRIPTION,
+				},
+				timeout: {
+					type: ["number", "null"],
+					description: TIMEOUT_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["command", "cwd", "timeout"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/generate_image.ts

@@ -0,0 +1,51 @@
+import type OpenAI from "openai"
+
+const GENERATE_IMAGE_DESCRIPTION = `Request to generate or edit an image using AI models through OpenRouter API. This tool can create new images from text prompts or modify existing images based on your instructions. When an input image is provided, the AI will apply the requested edits, transformations, or enhancements to that image.
+
+Parameters:
+- prompt: (required) The text prompt describing what to generate or how to edit the image
+- path: (required) The file path where the generated/edited image should be saved (relative to the current workspace directory). The tool will automatically add the appropriate image extension if not provided.
+- image: (optional) The file path to an input image to edit or transform (relative to the current workspace directory). Supported formats: PNG, JPG, JPEG, GIF, WEBP.
+
+Example: Generating a sunset image
+{ "prompt": "A beautiful sunset over mountains with vibrant orange and purple colors", "path": "images/sunset.png", "image": null }
+
+Example: Editing an existing image
+{ "prompt": "Transform this image into a watercolor painting style", "path": "images/watercolor-output.png", "image": "images/original-photo.jpg" }
+
+Example: Upscaling and enhancing an image
+{ "prompt": "Upscale this image to higher resolution, enhance details, improve clarity and sharpness while maintaining the original content and composition", "path": "images/enhanced-photo.png", "image": "images/low-res-photo.jpg" }`
+
+const PROMPT_PARAMETER_DESCRIPTION = `Text description of the image to generate or the edits to apply`
+
+const PATH_PARAMETER_DESCRIPTION = `Filesystem path (relative to the workspace) where the resulting image should be saved`
+
+const IMAGE_PARAMETER_DESCRIPTION = `Optional path (relative to the workspace) to an existing image to edit; supports PNG, JPG, JPEG, GIF, and WEBP`
+
+export default {
+	type: "function",
+	function: {
+		name: "generate_image",
+		description: GENERATE_IMAGE_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				prompt: {
+					type: "string",
+					description: PROMPT_PARAMETER_DESCRIPTION,
+				},
+				path: {
+					type: "string",
+					description: PATH_PARAMETER_DESCRIPTION,
+				},
+				image: {
+					type: ["string", "null"],
+					description: IMAGE_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["prompt", "path", "image"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/index.ts

@@ -0,0 +1,75 @@
+import type OpenAI from "openai"
+import accessMcpResource from "./access_mcp_resource"
+import { apply_diff } from "./apply_diff"
+import applyPatch from "./apply_patch"
+import askFollowupQuestion from "./ask_followup_question"
+import attemptCompletion from "./attempt_completion"
+import codebaseSearch from "./codebase_search"
+import editTool from "./edit"
+import executeCommand from "./execute_command"
+import generateImage from "./generate_image"
+import listFiles from "./list_files"
+import newTask from "./new_task"
+import readCommandOutput from "./read_command_output"
+import { createReadFileTool, type ReadFileToolOptions } from "./read_file"
+import runSlashCommand from "./run_slash_command"
+import skill from "./skill"
+import searchReplace from "./search_replace"
+import edit_file from "./edit_file"
+import searchFiles from "./search_files"
+import switchMode from "./switch_mode"
+import updateTodoList from "./update_todo_list"
+import writeToFile from "./write_to_file"
+
+export { getMcpServerTools } from "./mcp_server"
+export { convertOpenAIToolToAnthropic, convertOpenAIToolsToAnthropic } from "./converters"
+export type { ReadFileToolOptions } from "./read_file"
+
+/**
+ * Options for customizing the native tools array.
+ */
+export interface NativeToolsOptions {
+	/** Whether the model supports image processing (default: false) */
+	supportsImages?: boolean
+}
+
+/**
+ * Get native tools array, optionally customizing based on settings.
+ *
+ * @param options - Configuration options for the tools
+ * @returns Array of native tool definitions
+ */
+export function getNativeTools(options: NativeToolsOptions = {}): OpenAI.Chat.ChatCompletionTool[] {
+	const { supportsImages = false } = options
+
+	const readFileOptions: ReadFileToolOptions = {
+		supportsImages,
+	}
+
+	return [
+		accessMcpResource,
+		apply_diff,
+		applyPatch,
+		askFollowupQuestion,
+		attemptCompletion,
+		codebaseSearch,
+		executeCommand,
+		generateImage,
+		listFiles,
+		newTask,
+		readCommandOutput,
+		createReadFileTool(readFileOptions),
+		runSlashCommand,
+		skill,
+		searchReplace,
+		edit_file,
+		editTool,
+		searchFiles,
+		switchMode,
+		updateTodoList,
+		writeToFile,
+	] satisfies OpenAI.Chat.ChatCompletionTool[]
+}
+
+// Backward compatibility: export default tools with line ranges enabled
+export const nativeTools = getNativeTools()

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/list_files.ts

@@ -0,0 +1,41 @@
+import type OpenAI from "openai"
+
+const LIST_FILES_DESCRIPTION = `Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.
+
+Parameters:
+- path: (required) The path of the directory to list contents for (relative to the current workspace directory)
+- recursive: (required) Whether to list files recursively. Use true for recursive listing, false for top-level only.
+
+Example: Listing all files in the current directory (top-level only)
+{ "path": ".", "recursive": false }
+
+Example: Listing all files recursively in src directory
+{ "path": "src", "recursive": true }`
+
+const PATH_PARAMETER_DESCRIPTION = `Directory path to inspect, relative to the workspace`
+
+const RECURSIVE_PARAMETER_DESCRIPTION = `Set true to list contents recursively; false to show only the top level`
+
+export default {
+	type: "function",
+	function: {
+		name: "list_files",
+		description: LIST_FILES_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: PATH_PARAMETER_DESCRIPTION,
+				},
+				recursive: {
+					type: "boolean",
+					description: RECURSIVE_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["path", "recursive"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/mcp_server.ts

@@ -0,0 +1,75 @@
+import type OpenAI from "openai"
+import { McpHub } from "../../../../services/mcp/McpHub"
+import { buildMcpToolName } from "../../../../utils/mcp-name"
+import { normalizeToolSchema, type JsonSchema } from "../../../../utils/json-schema"
+
+/**
+ * Dynamically generates native tool definitions for all enabled tools across connected MCP servers.
+ * Tools are deduplicated by name to prevent API errors. When the same server exists in both
+ * global and project configs, project servers take priority (handled by McpHub.getServers()).
+ *
+ * @param mcpHub The McpHub instance containing connected servers.
+ * @returns An array of OpenAI.Chat.ChatCompletionTool definitions.
+ */
+export function getMcpServerTools(mcpHub?: McpHub, allowedServers?: string[]): OpenAI.Chat.ChatCompletionTool[] {
+	if (!mcpHub) {
+		return []
+	}
+
+	let servers = mcpHub.getServers()
+
+	// Filter servers by allowlist if provided
+	if (allowedServers) {
+		const allowSet = new Set(allowedServers)
+		servers = servers.filter((s) => allowSet.has(s.name))
+	}
+	const tools: OpenAI.Chat.ChatCompletionTool[] = []
+	// Track seen tool names to prevent duplicates (e.g., when same server exists in both global and project configs)
+	const seenToolNames = new Set<string>()
+
+	for (const server of servers) {
+		if (!server.tools) {
+			continue
+		}
+		for (const tool of server.tools) {
+			// Filter tools where tool.enabledForPrompt is not explicitly false
+			if (tool.enabledForPrompt === false) {
+				continue
+			}
+
+			// Build sanitized tool name for API compliance
+			// The name is sanitized to conform to API requirements (e.g., Gemini's function name restrictions)
+			const toolName = buildMcpToolName(server.name, tool.name)
+
+			// Skip duplicate tool names - first occurrence wins (project servers come before global servers)
+			if (seenToolNames.has(toolName)) {
+				continue
+			}
+			seenToolNames.add(toolName)
+
+			const originalSchema = tool.inputSchema as Record<string, unknown> | undefined
+
+			// Normalize schema for JSON Schema 2020-12 compliance (type arrays → anyOf)
+			let parameters: JsonSchema
+			if (originalSchema) {
+				parameters = normalizeToolSchema(originalSchema) as JsonSchema
+			} else {
+				// No schema provided - create a minimal valid schema
+				parameters = { type: "object", additionalProperties: false } as JsonSchema
+			}
+
+			const toolDefinition: OpenAI.Chat.ChatCompletionTool = {
+				type: "function",
+				function: {
+					name: toolName,
+					description: tool.description,
+					parameters: parameters as OpenAI.FunctionParameters,
+				},
+			}
+
+			tools.push(toolDefinition)
+		}
+	}
+
+	return tools
+}

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/new_task.ts

@@ -0,0 +1,39 @@
+import type OpenAI from "openai"
+
+const NEW_TASK_DESCRIPTION = `Create a new task instance in the chosen mode using your provided message and initial todo list (if required).
+
+CRITICAL: This tool MUST be called alone. Do NOT call this tool alongside other tools in the same message turn. If you need to gather information before delegating, use other tools in a separate turn first, then call new_task by itself in the next turn.`
+
+const MODE_PARAMETER_DESCRIPTION = `Slug of the mode to begin the new task in (e.g., code, debug, architect)`
+
+const MESSAGE_PARAMETER_DESCRIPTION = `Initial user instructions or context for the new task`
+
+const TODOS_PARAMETER_DESCRIPTION = `Optional initial todo list written as a markdown checklist; required when the workspace mandates todos`
+
+export default {
+	type: "function",
+	function: {
+		name: "new_task",
+		description: NEW_TASK_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				mode: {
+					type: "string",
+					description: MODE_PARAMETER_DESCRIPTION,
+				},
+				message: {
+					type: "string",
+					description: MESSAGE_PARAMETER_DESCRIPTION,
+				},
+				todos: {
+					type: ["string", "null"],
+					description: TODOS_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["mode", "message", "todos"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool