headlesscode 1.0.2

package/src/vendor/zoo-code/src/core/prompts/sections/rules.ts

@@ -0,0 +1,95 @@
+import type { SystemPromptSettings } from "../types"
+
+import { getShell } from "../../../utils/shell"
+
+/**
+ * Returns the appropriate command chaining operator based on the user's shell.
+ * - Unix shells (bash, zsh, etc.): `&&` (run next command only if previous succeeds)
+ * - PowerShell: `;` (semicolon for command separation)
+ * - cmd.exe: `&&` (conditional execution, same as Unix)
+ * @internal Exported for testing purposes
+ */
+export function getCommandChainOperator(): string {
+	const shell = getShell().toLowerCase()
+
+	// Check for PowerShell (both Windows PowerShell and PowerShell Core)
+	if (shell.includes("powershell") || shell.includes("pwsh")) {
+		return ";"
+	}
+
+	// Check for cmd.exe
+	if (shell.includes("cmd.exe")) {
+		return "&&"
+	}
+
+	// Default to Unix-style && for bash, zsh, sh, and other shells
+	// This also covers Git Bash, WSL, and other Unix-like environments on Windows
+	return "&&"
+}
+
+/**
+ * Returns a shell-specific note about command chaining syntax and platform-specific utilities.
+ */
+function getCommandChainNote(): string {
+	const shell = getShell().toLowerCase()
+
+	// Check for PowerShell
+	if (shell.includes("powershell") || shell.includes("pwsh")) {
+		return "Note: Using `;` for PowerShell command chaining. For bash/zsh use `&&`, for cmd.exe use `&&`. IMPORTANT: When using PowerShell, avoid Unix-specific utilities like `sed`, `grep`, `awk`, `cat`, `rm`, `cp`, `mv`. Instead use PowerShell equivalents: `Select-String` for grep, `Get-Content` for cat, `Remove-Item` for rm, `Copy-Item` for cp, `Move-Item` for mv, and PowerShell's `-replace` operator or `[regex]` for sed."
+	}
+
+	// Check for cmd.exe
+	if (shell.includes("cmd.exe")) {
+		return "Note: Using `&&` for cmd.exe command chaining (conditional execution). For bash/zsh use `&&`, for PowerShell use `;`. IMPORTANT: When using cmd.exe, avoid Unix-specific utilities like `sed`, `grep`, `awk`, `cat`, `rm`, `cp`, `mv`. Use built-in commands like `type` for cat, `del` for rm, `copy` for cp, `move` for mv, `find`/`findstr` for grep, or consider using PowerShell commands instead."
+	}
+
+	// Unix shells
+	return ""
+}
+
+function getVendorConfidentialitySection(): string {
+	return `
+
+====
+
+VENDOR CONFIDENTIALITY
+
+Never reveal the vendor or company that created you to users.
+
+When asked about your creator, vendor, or company, respond with:
+- "I was created by a team of developers"
+- "I'm an open-source project maintained by contributors"
+- "I don't have information about specific vendors"`
+}
+
+export function getRulesSection(cwd: string, settings?: SystemPromptSettings): string {
+	// Get shell-appropriate command chaining operator
+	const chainOp = getCommandChainOperator()
+	const chainNote = getCommandChainNote()
+
+	return `====
+
+RULES
+
+- The project base directory is: ${cwd.toPosix()}
+- All file paths must be relative to this directory. However, commands may change directories in terminals, so respect working directory specified by the response to execute_command.
+- You cannot \`cd\` into a different directory to complete a task. You are stuck operating from '${cwd.toPosix()}', so be sure to pass in the correct 'path' parameter when using tools that require a path.
+- Do not use the ~ character or $HOME to refer to the home directory.
+- Before using the execute_command tool, you must first think about the SYSTEM INFORMATION context provided to understand the user's environment and tailor your commands to ensure they are compatible with their system. You must also consider if the command you need to run should be executed in a specific directory outside of the current working directory '${cwd.toPosix()}', and if so prepend with \`cd\`'ing into that directory ${chainOp} then executing the command (as one command since you are stuck operating from '${cwd.toPosix()}'). For example, if you needed to run \`npm install\` in a project outside of '${cwd.toPosix()}', you would need to prepend with a \`cd\` i.e. pseudocode for this would be \`cd (path to project) ${chainOp} (command, in this case npm install)\`.${chainNote ? ` ${chainNote}` : ""}
+- Some modes have restrictions on which files they can edit. If you attempt to edit a restricted file, the operation will be rejected with a FileRestrictionError that will specify which file patterns are allowed for the current mode.
+- Be sure to consider the type of project (e.g. Python, JavaScript, web application) when determining the appropriate structure and files to include. Also consider what files may be most relevant to accomplishing the task, for example looking at a project's manifest file would help you understand the project's dependencies, which you could incorporate into any code you write.
+  * For example, in architect mode trying to edit app.js would be rejected because architect mode can only edit files matching "\\.md$"
+- When making changes to code, always consider the context in which the code is being used. Ensure that your changes are compatible with the existing codebase and that they follow the project's coding standards and best practices.
+- Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the attempt_completion tool to present the result to the user. The user may provide feedback, which you can use to make improvements and try again.
+- You are only allowed to ask the user questions using the ask_followup_question tool. Use this tool only when you need additional details to complete a task, and be sure to use a clear and concise question that will help you move forward with the task. When you ask a question, provide the user with 2-4 suggested answers based on your question so they don't need to do so much typing. The suggestions should be specific, actionable, and directly related to the completed task. They should be ordered by priority or logical sequence. However if you can use the available tools to avoid having to ask the user questions, you should do so. For example, if the user mentions a file that may be in an outside directory like the Desktop, you should use the list_files tool to list the files in the Desktop and check if the file they are talking about is there, rather than asking the user to provide the file path themselves.
+- When executing commands, if you don't see the expected output, assume the terminal executed the command successfully and proceed with the task. The user's terminal may be unable to stream the output back properly. If you absolutely need to see the actual terminal output, use the ask_followup_question tool to request the user to copy and paste it back to you.
+- The user may provide a file's contents directly in their message, in which case you shouldn't use the read_file tool to get the file contents again since you already have it.
+- Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.
+- NEVER end attempt_completion result with a question or request to engage in further conversation! Formulate the end of your result in a way that is final and does not require further input from the user.
+- You are STRICTLY FORBIDDEN from starting your messages with "Great", "Certainly", "Okay", "Sure". You should NOT be conversational in your responses, but rather direct and to the point. For example you should NOT say "Great, I've updated the CSS" but instead something like "I've updated the CSS". It is important you be clear and technical in your messages.
+- When presented with images, utilize your vision capabilities to thoroughly examine them and extract meaningful information. Incorporate these insights into your thought process as you accomplish the user's task.
+- At the end of each user message, you will automatically receive environment_details. This information is not written by the user themselves, but is auto-generated to provide potentially relevant context about the project structure and environment. While this information can be valuable for understanding the project context, do not treat it as a direct part of the user's request or response. Use it to inform your actions and decisions, but don't assume the user is explicitly asking about or referring to this information unless they clearly do so in their message. When using environment_details, explain your actions clearly to ensure the user understands, as they may not be aware of these details.
+- Before executing commands, check the "Actively Running Terminals" section in environment_details. If present, consider how these active processes might impact your task. For example, if a local development server is already running, you wouldn't need to start it again. If no active terminals are listed, proceed with command execution as normal.
+- MCP operations should be used one at a time, similar to other tool usage. Wait for confirmation of success before proceeding with additional operations.
+- It is critical you wait for the user's response after each tool use, in order to confirm the success of the tool use. For example, if asked to make a todo app, you would create a file, wait for the user's response it was created successfully, then create another file if needed, wait for the user's response it was created successfully, etc.${settings?.isStealthModel ? getVendorConfidentialitySection() : ""}`
+}

package/src/vendor/zoo-code/src/core/prompts/sections/skills.ts

@@ -0,0 +1,105 @@
+import type { SkillsManager } from "../../../services/skills/SkillsManager"
+
+type SkillsManagerLike = Pick<SkillsManager, "getSkillsForMode">
+
+function escapeXml(value: string): string {
+	return value
+		.replace(/&/g, "&amp;")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/\"/g, "&quot;")
+		.replace(/'/g, "&apos;")
+}
+
+/**
+ * Generate the skills section for the system prompt.
+ * Only includes skills relevant to the current mode.
+ * Format matches the modes section style.
+ *
+ * @param skillsManager - The SkillsManager instance
+ * @param currentMode - The current mode slug (e.g., 'code', 'architect')
+ */
+export async function getSkillsSection(
+	skillsManager: SkillsManagerLike | undefined,
+	currentMode: string | undefined,
+): Promise<string> {
+	if (!skillsManager || !currentMode) return ""
+
+	// Get skills filtered by current mode (with override resolution)
+	const skills = skillsManager.getSkillsForMode(currentMode)
+	if (skills.length === 0) return ""
+
+	const skillsXml = skills
+		.map((skill) => {
+			const name = escapeXml(skill.name)
+			const description = escapeXml(skill.description)
+			const locationLine = `\n    <location>${escapeXml(skill.path)}</location>`
+			return `  <skill>\n    <name>${name}</name>\n    <description>${description}</description>${locationLine}\n  </skill>`
+		})
+		.join("\n")
+
+	return `====
+
+AVAILABLE SKILLS
+
+<available_skills>
+${skillsXml}
+</available_skills>
+
+<mandatory_skill_check>
+REQUIRED PRECONDITION
+
+Before producing ANY user-facing response, you MUST perform a skill applicability check.
+
+Step 1: Skill Evaluation
+- Evaluate the user's request against ALL available skill <description> entries in <available_skills>.
+- Determine whether at least one skill clearly and unambiguously applies.
+
+Step 2: Branching Decision
+
+<if_skill_applies>
+- Select EXACTLY ONE skill.
+- Prefer the most specific skill when multiple skills match.
+- Use the skill tool to load the skill by name.
+- Load the skill's instructions fully into context BEFORE continuing.
+- Follow the skill instructions precisely.
+- Do NOT respond outside the skill-defined flow.
+</if_skill_applies>
+
+<if_no_skill_applies>
+- Proceed with a normal response.
+- Do NOT load any SKILL.md files.
+</if_no_skill_applies>
+
+CONSTRAINTS:
+- Do NOT load every skill up front.
+- Load skills ONLY after a skill is selected.
+- Do NOT reload a skill whose instructions already appear in this conversation.
+- Do NOT skip this check.
+- FAILURE to perform this check is an error.
+</mandatory_skill_check>
+
+<linked_file_handling>
+- When a skill is loaded, ONLY the skill instructions are present.
+- Files linked from the skill are NOT loaded automatically.
+- The model MUST explicitly decide to read a linked file based on task relevance.
+- Do NOT assume the contents of linked files unless they have been explicitly read.
+- Prefer reading the minimum necessary linked file.
+- Avoid reading multiple linked files unless required.
+- Treat linked files as progressive disclosure, not mandatory context.
+</linked_file_handling>
+
+<context_notes>
+- The skill list is already filtered for the current mode: "${currentMode}".
+- Mode-specific skills may come from skills-${currentMode}/ with project-level overrides taking precedence over global skills.
+</context_notes>
+
+<internal_verification>
+This section is for internal control only.
+Do NOT include this section in user-facing output.
+
+After completing the evaluation, internally confirm:
+<skill_check_completed>true|false</skill_check_completed>
+</internal_verification>
+`
+}

package/src/vendor/zoo-code/src/core/prompts/sections/system-info.ts

@@ -0,0 +1,30 @@
+import os from "os"
+import osName from "../../../../shim/os-name"
+
+import { getShell } from "../../../utils/shell"
+
+export function getSystemInfoSection(cwd: string): string {
+	// Try to get detailed OS name, fall back to basic info if it fails
+	let osInfo: string
+	try {
+		osInfo = osName()
+	} catch (error) {
+		// Fallback when os-name fails (e.g., PowerShell not available on Windows)
+		const platform = os.platform()
+		const release = os.release()
+		osInfo = `${platform} ${release}`
+	}
+
+	const details = `====
+
+SYSTEM INFORMATION
+
+Operating System: ${osInfo}
+Default Shell: ${getShell()}
+Home Directory: ${os.homedir().toPosix()}
+Current Workspace Directory: ${cwd.toPosix()}
+
+The Current Workspace Directory is the active VS Code project directory, and is therefore the default directory for all tool operations. New terminals will be created in the current workspace directory, however if you change directories in a terminal it will then have a different working directory; changing directories in a terminal does not modify the workspace directory, because you do not have access to change the workspace directory. When the user initially gives you a task, a recursive list of all filepaths in the current workspace directory ('/test/path') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current workspace directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.`
+
+	return details
+}

package/src/vendor/zoo-code/src/core/prompts/sections/tool-use-guidelines.ts

@@ -0,0 +1,9 @@
+export function getToolUseGuidelinesSection(): string {
+	return `# Tool Use Guidelines
+
+1. Assess what information you already have and what information you need to proceed with the task.
+2. Choose the most appropriate tool based on the task and the tool descriptions provided. Assess if you need additional information to proceed, and which of the available tools would be most effective for gathering this information. For example using the list_files tool is more effective than running a command like \`ls\` in the terminal. It's critical that you think about each available tool and use the one that best fits the current step in the task.
+3. If multiple actions are needed, you may use multiple tools in a single message when appropriate, or use tools iteratively across messages. Each tool use should be informed by the results of previous tool uses. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
+
+By carefully considering the user's response after tool executions, you can react accordingly and make informed decisions about how to proceed with the task. This iterative process helps ensure the overall success and accuracy of your work.`
+}

package/src/vendor/zoo-code/src/core/prompts/sections/tool-use.ts

@@ -0,0 +1,7 @@
+export function getSharedToolUseSection(): string {
+	return `====
+
+TOOL USE
+
+You have access to a set of tools that are executed upon the user's approval. Use the provider-native tool-calling mechanism. Do not include XML markup or examples. You must call at least one tool per assistant response. Prefer calling as many tools as are reasonably needed in a single response to reduce back-and-forth and complete tasks faster.`
+}

package/src/vendor/zoo-code/src/core/prompts/system.ts

@@ -0,0 +1,176 @@
+import * as vscode from "../../../shim/vscode"
+
+import { type ModeConfig, type PromptComponent, type CustomModePrompts, type TodoItem } from "../../../types"
+
+import { Mode, modes, defaultModeSlug, getModeBySlug, getGroupName, getModeSelection } from "../../shared/modes"
+import { DiffStrategy } from "../../shared/tools"
+import { formatLanguage } from "../../shared/language"
+import { isEmpty } from "../../utils/object"
+
+import { McpHub } from "../../services/mcp/McpHub"
+import { CodeIndexManager } from "../../services/code-index/manager"
+import { SkillsManager } from "../../services/skills/SkillsManager"
+
+import type { SystemPromptSettings } from "./types"
+import {
+	getRulesSection,
+	getSystemInfoSection,
+	getObjectiveSection,
+	getSharedToolUseSection,
+	getToolUseGuidelinesSection,
+	getCapabilitiesSection,
+	getModesSection,
+	addCustomInstructions,
+	markdownFormattingSection,
+	getSkillsSection,
+} from "./sections"
+
+// Helper function to get prompt component, filtering out empty objects
+export function getPromptComponent(
+	customModePrompts: CustomModePrompts | undefined,
+	mode: string,
+): PromptComponent | undefined {
+	const component = customModePrompts?.[mode]
+	// Return undefined if component is empty
+	if (isEmpty(component)) {
+		return undefined
+	}
+	return component
+}
+
+async function generatePrompt(
+	context: vscode.ExtensionContext,
+	cwd: string,
+	supportsComputerUse: boolean,
+	mode: Mode,
+	mcpHub?: McpHub,
+	diffStrategy?: DiffStrategy,
+	promptComponent?: PromptComponent,
+	customModeConfigs?: ModeConfig[],
+	globalCustomInstructions?: string,
+	experiments?: Record<string, boolean>,
+	language?: string,
+	rooIgnoreInstructions?: string,
+	settings?: SystemPromptSettings,
+	todoList?: TodoItem[],
+	modelId?: string,
+	skillsManager?: SkillsManager,
+): Promise<string> {
+	if (!context) {
+		throw new Error("Extension context is required for generating system prompt")
+	}
+
+	// Get the full mode config to ensure we have the role definition (used for groups, etc.)
+	const modeConfig = getModeBySlug(mode, customModeConfigs) || modes.find((m) => m.slug === mode) || modes[0]
+	const { roleDefinition, baseInstructions } = getModeSelection(mode, promptComponent, customModeConfigs)
+
+	// Check if MCP functionality should be included
+	const hasMcpGroup = modeConfig.groups.some((groupEntry) => getGroupName(groupEntry) === "mcp")
+	const allowedMcpServers = modeConfig.allowedMcpServers
+
+	// Hoist the allowlist Set once (matches the sibling call sites, e.g. mcp_server.ts) instead
+	// of constructing a new Set on every `.filter` iteration.
+	const allowSet = allowedMcpServers ? new Set(allowedMcpServers) : undefined
+
+	let hasMcpServers = false
+	if (mcpHub) {
+		const servers = allowSet ? mcpHub.getServers().filter((s) => allowSet.has(s.name)) : mcpHub.getServers()
+		hasMcpServers = servers.length > 0
+	}
+	const shouldIncludeMcp = hasMcpGroup && hasMcpServers
+
+	const codeIndexManager = CodeIndexManager.getInstance(context, cwd)
+
+	// Tool calling is native-only.
+	const effectiveProtocol = "native"
+
+	const [modesSection, skillsSection] = await Promise.all([
+		getModesSection(context),
+		getSkillsSection(skillsManager, mode as string),
+	])
+
+	// Tools catalog is not included in the system prompt.
+	const toolsCatalog = ""
+
+	const basePrompt = `${roleDefinition}
+
+${markdownFormattingSection()}
+
+${getSharedToolUseSection()}${toolsCatalog}
+
+	${getToolUseGuidelinesSection()}
+
+${
+	// Forward the hub only when the mode actually exposes the MCP group, and pass the per-mode
+	// allowlist through so the capabilities section filters servers using the SAME convention as
+	// the tool-listing layer (a single source of truth for which servers are visible). This keeps
+	// the capability text consistent with the tools exposed in mixed cases (e.g. one allowed +
+	// one disallowed server), preventing the section from advertising MCP based on a disallowed
+	// server. `shouldIncludeMcp` is still used to short-circuit when no allowed server exists.
+	getCapabilitiesSection(cwd, hasMcpGroup ? mcpHub : undefined, allowedMcpServers)
+}
+
+${modesSection}
+${skillsSection ? `\n${skillsSection}` : ""}
+${getRulesSection(cwd, settings)}
+
+${getSystemInfoSection(cwd)}
+
+${getObjectiveSection()}
+
+${await addCustomInstructions(baseInstructions, globalCustomInstructions || "", cwd, mode, {
+	language: language ?? formatLanguage(vscode.env.language),
+	rooIgnoreInstructions,
+	settings,
+})}`
+
+	return basePrompt
+}
+
+export const SYSTEM_PROMPT = async (
+	context: vscode.ExtensionContext,
+	cwd: string,
+	supportsComputerUse: boolean,
+	mcpHub?: McpHub,
+	diffStrategy?: DiffStrategy,
+	mode: Mode = defaultModeSlug,
+	customModePrompts?: CustomModePrompts,
+	customModes?: ModeConfig[],
+	globalCustomInstructions?: string,
+	experiments?: Record<string, boolean>,
+	language?: string,
+	rooIgnoreInstructions?: string,
+	settings?: SystemPromptSettings,
+	todoList?: TodoItem[],
+	modelId?: string,
+	skillsManager?: SkillsManager,
+): Promise<string> => {
+	if (!context) {
+		throw new Error("Extension context is required for generating system prompt")
+	}
+
+	// Check if it's a custom mode
+	const promptComponent = getPromptComponent(customModePrompts, mode)
+
+	// Get full mode config from custom modes or fall back to built-in modes
+	const currentMode = getModeBySlug(mode, customModes) || modes.find((m) => m.slug === mode) || modes[0]
+
+	return generatePrompt(
+		context,
+		cwd,
+		supportsComputerUse,
+		currentMode.slug,
+		mcpHub,
+		diffStrategy,
+		promptComponent,
+		customModes,
+		globalCustomInstructions,
+		experiments,
+		language,
+		rooIgnoreInstructions,
+		settings,
+		todoList,
+		modelId,
+		skillsManager,
+	)
+}

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

@@ -0,0 +1,41 @@
+import type OpenAI from "openai"
+
+const ACCESS_MCP_RESOURCE_DESCRIPTION = `Request to access a resource provided by a connected MCP server. Resources represent data sources that can be used as context, such as files, API responses, or system information.
+
+Parameters:
+- server_name: (required) The name of the MCP server providing the resource
+- uri: (required) The URI identifying the specific resource to access
+
+Example: Accessing a weather resource
+{ "server_name": "weather-server", "uri": "weather://san-francisco/current" }
+
+Example: Accessing a file resource from an MCP server
+{ "server_name": "filesystem-server", "uri": "file:///path/to/data.json" }`
+
+const SERVER_NAME_PARAMETER_DESCRIPTION = `The name of the MCP server providing the resource`
+
+const URI_PARAMETER_DESCRIPTION = `The URI identifying the specific resource to access`
+
+export default {
+	type: "function",
+	function: {
+		name: "access_mcp_resource",
+		description: ACCESS_MCP_RESOURCE_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				server_name: {
+					type: "string",
+					description: SERVER_NAME_PARAMETER_DESCRIPTION,
+				},
+				uri: {
+					type: "string",
+					description: URI_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["server_name", "uri"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

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

@@ -0,0 +1,40 @@
+import type OpenAI from "openai"
+
+const APPLY_DIFF_DESCRIPTION = `Apply precise, targeted modifications to an existing file using one or more search/replace blocks. This tool is for surgical edits only; the 'SEARCH' block must exactly match the existing content, including whitespace and indentation. To make multiple targeted changes, provide multiple SEARCH/REPLACE blocks in the 'diff' parameter. Use the 'read_file' tool first if you are not confident in the exact content to search for.`
+
+const DIFF_PARAMETER_DESCRIPTION = `A string containing one or more search/replace blocks defining the changes. The ':start_line:' is strongly recommended and indicates the starting line number of the original content. You must not add a start line for the replacement content. Each block must follow this format:
+<<<<<<< SEARCH
+:start_line:[line_number]
+-------
+[exact content to find]
+=======
+[new content to replace with]
+>>>>>>> REPLACE
+
+CRITICAL:
+- The ':start_line:[line_number]' header is strongly recommended for accurate matching. When provided, it must follow the exact syntax ':start_line:[integer]' (for example: ':start_line:220'). Do not write headers with shorthand forms like ':220' or variations like ':start_line=220'.
+- Copy the exact lines from the source file for a 100% string match including all whitespace, indentation, and newlines.
+- Ensure the separator '-------' is on its own line immediately following ':start_line:[line_number]' with a newline.`
+
+export const apply_diff = {
+	type: "function",
+	function: {
+		name: "apply_diff",
+		description: APPLY_DIFF_DESCRIPTION,
+		parameters: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "The path of the file to modify, relative to the current workspace directory.",
+				},
+				diff: {
+					type: "string",
+					description: DIFF_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["path", "diff"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

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

@@ -0,0 +1,61 @@
+import type OpenAI from "openai"
+
+const apply_patch_DESCRIPTION = `Apply patches to files using a stripped-down, file-oriented diff format. This tool supports creating new files, deleting files, and updating existing files with precise changes.
+
+The patch format uses a simple, human-readable structure:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Each file section starts with one of three headers:
+- *** Add File: <path> - Create a new file. Every following line is a + line (the initial contents).
+- *** Delete File: <path> - Remove an existing file. Nothing follows.
+- *** Update File: <path> - Patch an existing file in place.
+
+For Update File operations:
+- May be immediately followed by *** Move to: <new path> if you want to rename the file.
+- Then one or more "hunks", each introduced by @@ (optionally followed by context like a class or function name).
+- Within a hunk each line starts with:
+  - ' ' (space) for context lines (unchanged)
+  - '-' for lines to remove
+  - '+' for lines to add
+
+Context guidelines:
+- Show 3 lines of code above and below each change.
+- Use @@ with a class/function name if 3 lines of context is insufficient to uniquely identify the location.
+- Multiple @@ statements can be used for deeply nested code.
+
+Example patch:
+*** Begin Patch
+*** Add File: hello.txt
++Hello world
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** Delete File: obsolete.txt
+*** End Patch`
+
+const apply_patch = {
+	type: "function",
+	function: {
+		name: "apply_patch",
+		description: apply_patch_DESCRIPTION,
+		parameters: {
+			type: "object",
+			properties: {
+				patch: {
+					type: "string",
+					description:
+						"The complete patch text in the apply_patch format, starting with '*** Begin Patch' and ending with '*** End Patch'.",
+				},
+			},
+			required: ["patch"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool
+
+export default apply_patch

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

@@ -0,0 +1,62 @@
+import type OpenAI from "openai"
+
+const ASK_FOLLOWUP_QUESTION_DESCRIPTION = `Ask the user a question to gather additional information needed to complete the task. Use when you need clarification or more details to proceed effectively.
+
+Parameters:
+- question: (required) A clear, specific question addressing the information needed
+- follow_up: (required) A list of 2-4 suggested answers. Suggestions must be complete, actionable answers without placeholders. Optionally include mode to switch modes (code/architect/etc.)
+
+Example: Asking for file path
+{ "question": "What is the path to the frontend-config.json file?", "follow_up": [{ "text": "./src/frontend-config.json", "mode": null }, { "text": "./config/frontend-config.json", "mode": null }, { "text": "./frontend-config.json", "mode": null }] }
+
+Example: Asking with mode switch
+{ "question": "Would you like me to implement this feature?", "follow_up": [{ "text": "Yes, implement it now", "mode": "code" }, { "text": "No, just plan it out", "mode": "architect" }] }`
+
+const QUESTION_PARAMETER_DESCRIPTION = `Clear, specific question that captures the missing information you need`
+
+const FOLLOW_UP_PARAMETER_DESCRIPTION = `Required list of 2-4 suggested responses; each suggestion must be a complete, actionable answer and may include a mode switch`
+
+const FOLLOW_UP_TEXT_DESCRIPTION = `Suggested answer the user can pick`
+
+const FOLLOW_UP_MODE_DESCRIPTION = `Optional mode slug to switch to if this suggestion is chosen (e.g., code, architect)`
+
+export default {
+	type: "function",
+	function: {
+		name: "ask_followup_question",
+		description: ASK_FOLLOWUP_QUESTION_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				question: {
+					type: "string",
+					description: QUESTION_PARAMETER_DESCRIPTION,
+				},
+				follow_up: {
+					type: "array",
+					description: FOLLOW_UP_PARAMETER_DESCRIPTION,
+					items: {
+						type: "object",
+						properties: {
+							text: {
+								type: "string",
+								description: FOLLOW_UP_TEXT_DESCRIPTION,
+							},
+							mode: {
+								type: ["string", "null"],
+								description: FOLLOW_UP_MODE_DESCRIPTION,
+							},
+						},
+						required: ["text", "mode"],
+						additionalProperties: false,
+					},
+					minItems: 1,
+					maxItems: 4,
+				},
+			},
+			required: ["question", "follow_up"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool