@builder.io/ai-utils 0.59.0 → 0.60.0

package/src/codegen.js

@@ -1,8 +1,1516 @@
 import { z } from "zod";
+import { AttachmentSchema, ContentMessageItemToolResultSchema, } from "./messages";
+import { UserContextSchema } from "./mapping";
+import { SetupDependencySchema } from "./projects";
+export const GitSnapshotSchema = z.string().meta({
+    title: "GitSnapshot",
+    description: "Multi-repo git snapshot. Format: 'folder:hash,folder:hash' " +
+        "with URL-encoded folder names. Legacy single-hash form " +
+        "('abc123') is also accepted. Empty string means no commits.",
+});
+// Define the import type as a union of literal types.
+export const ImportTypeSchema = z
+    .enum(["named", "default"])
+    .meta({ title: "ImportType" });
+export const ProjectFileSchema = z
+    .object({
+    filePath: z.string(),
+    content: z.string().optional(),
+    importance: z.number().optional(),
+    dropReason: z.string().optional(),
+    wasIncluded: z.boolean().optional(),
+    virtual: z.boolean().optional(),
+})
+    .meta({ title: "ProjectFile" });
+export const CustomInstructionSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    content: z.string(),
+    type: z.enum(["always", "agent-mode"]).optional(),
+    filePath: z.string().optional(),
+    glob: z.string().optional(),
+    description: z.string().optional(),
+    allowedTools: z.array(z.string()).optional(),
+    hideUI: z.boolean().optional(),
+    isSkill: z.boolean().optional(),
+    disableModelInvocation: z.boolean().optional(),
+    userInvocable: z.boolean().optional(),
+    /**
+     * Where this instruction was discovered. Drives precedence on name
+     * collision: `project` > `user` > `plugin`. Set by the discovery loader,
+     * not by the parsed file itself.
+     */
+    scope: z.enum(["project", "user", "plugin"]).optional(),
+    /**
+     * Name of the plugin that contributed this instruction, if any. Set by
+     * the plugin loader (Phase 2); always `undefined` for project-level and
+     * user-level standalone files (Phase 1).
+     */
+    pluginName: z.string().optional(),
+})
+    .meta({ title: "CustomInstruction" });
 /** Reasoning effort level for LLM completions. */
 export const ReasoningEffortSchema = z
     .enum(["auto", "none", "minimal", "low", "medium", "high", "xhigh", "max"])
     .meta({ title: "ReasoningEffort" });
+export const CustomAgentInfoSchema = z
+    .object({
+    name: z.string(),
+    description: z.string().optional(),
+})
+    .meta({ title: "CustomAgentInfo" });
+/** Per-agent model overrides. String = fixed model, string[] = round-robin. */
+export const AgentModelOverridesSchema = z
+    .record(z.string(), z.union([z.string(), z.array(z.string())]))
+    .meta({ title: "AgentModelOverrides" });
+export const CodeGenFrameworkSchema = z
+    .enum([
+    "react",
+    "html",
+    "mitosis",
+    "react-native",
+    "angular",
+    "vue",
+    "svelte",
+    "qwik",
+    "solid",
+    "marko",
+    "swiftui",
+    "jetpack-compose",
+    "flutter",
+])
+    .meta({ title: "CodeGenFramework" });
+export const CodeGenStyleLibrarySchema = z
+    .enum([
+    "tailwind",
+    "tailwind-precise",
+    "emotion",
+    "styled-components",
+    "styled-jsx",
+    "react-native",
+])
+    .meta({ title: "CodeGenStyleLibrary" });
+export const CompletionStopReasonSchema = z
+    .enum([
+    "max_tokens",
+    "stop_sequence",
+    "tool_use",
+    "end_turn",
+    "content_filter",
+    "error",
+    "aborted",
+    "pause_turn",
+    "refusal",
+    "compaction",
+    "model_context_window_exceeded",
+])
+    .nullable()
+    .meta({ title: "CompletionStopReason" });
+export const FILE_PATH_DESCRIPTION = "The path of the file. Accepts a path relative to the project working directory, an absolute path (`/Users/.../skill.md`), or a tilde path (`~/.builder/skills/.../SKILL.md`). User-level Builder state under `~/.builder/**` is allowed by default for plugin operations; other absolute paths require an explicit ACL policy.";
+export const ReadToolInputSchema = z
+    .object({
+    file_path: z.string().meta({ description: FILE_PATH_DESCRIPTION }),
+    offset: z.number().nullish().meta({
+        description: "The line number to start reading from.",
+    }),
+    limit: z.number().nullish().meta({
+        description: "The number of lines to read.",
+    }),
+})
+    .meta({ title: "ReadToolInput" });
+export const GlobSearchToolInputSchema = z
+    .object({
+    pattern: z.string().meta({ description: "The pattern to search for" }),
+})
+    .meta({ title: "GlobSearchToolInput" });
+export const GrepSearchToolInputSchema = z
+    .object({
+    query: z.string().meta({
+        description: 'A string literal or a JavaScript-flavored regex to search for in all project files. Only escape special characters such as {} and () in string literals to avoid confusion with regex patterns (e.g. "import \\{ foo \\}"). Avoid over-escaping as that will cause errors. Do NOT use inline regex flags like (?i) or (?s) — they are not supported. The search is case-insensitive by default; use the case_sensitive parameter to control this.',
+    }),
+    include_glob: z.string().nullish().meta({
+        description: "An optional single glob pattern to include only specific files (e.g. '**/*.(ts|tsx)' for all TypeScript files)",
+    }),
+    exclude_glob: z.string().nullish().meta({
+        description: "Optional glob pattern to exclude specific files or directories",
+    }),
+    case_sensitive: z.boolean().nullish().meta({
+        description: "Whether the search should be case-sensitive. Defaults to false (case-insensitive). Set to true for case-sensitive search.",
+    }),
+})
+    .meta({ title: "GrepSearchToolInput" });
+export const SkillToolInputSchema = z
+    .object({
+    skill: z.string().meta({
+        description: "The name of a skill from the available-skills list. Do not guess names.",
+    }),
+    args: z.string().nullish().meta({
+        description: "Optional invocation arguments; forwarded with the skill body in the tool result.",
+    }),
+})
+    .meta({ title: "SkillToolInput" });
+export const GetRuleToolInputSchema = z
+    .object({
+    name: z.string().meta({ description: "The name of the rule to get" }),
+})
+    .meta({ title: "GetRuleToolInput" });
+export const GetStyleInspirationToolInputSchema = z
+    .object({
+    url: z.string().meta({
+        description: "The URL of the website to analyze and mimic the style of, for example 'https://airbnb.com' or 'https://instagram.com'",
+    }),
+})
+    .meta({ title: "GetStyleInspirationToolInput" });
+export const GetBuildOutputToolInputSchema = z
+    .object({})
+    .meta({ title: "GetBuildOutputToolInput" });
+export const DevServerControlInputSchema = z
+    .object({
+    restart: z.boolean().nullish().meta({
+        description: "Whether to restart the dev server, it will also return the initial logs coming from the dev server. This tool can be very slow, only use as last resort, most of the times file changes do not require a restart.",
+    }),
+    set_dev_command: z.string().nullish().meta({
+        description: "Use to set the command of the dev server, for example 'npm run dev' or 'cd packages/frontend && yarn dev'. When updating the command, the dev server will be automatically restarted. After changing a command, the proxy port might change, so you need to use the 'set_proxy_port' tool to update the proxy port. Only use if there are explicit issues",
+    }),
+    set_proxy_port: z.number().nullish().meta({
+        description: "Used to configure the proxy port of the dev server. For example, if `npm run dev` open a port in 8392, but current proxy server listens 3000, you can use this tool to update the proxy port. Only use if there are explicit issues.",
+    }),
+    get_logs: z.boolean().nullish().meta({
+        description: "When used standalone, the tool will return logs of the dev server and other status. But don't change or restart anything. It's a read-only operation.",
+    }),
+    set_env_variable: z.tuple([z.string(), z.string()]).nullish().meta({
+        description: "Tuple of two strings, the first string is the name of the environment variable, the second string is the value of the environment variable. For example, ['DB_API_KEY', '___PRIVATE_KEY___']",
+    }),
+    set_and_run_setup_command: z.string().nullish().meta({
+        description: "Use to set the command of the setup command, for example 'npm install' or 'yarn'. Only use if there are explicit issues.",
+    }),
+})
+    .meta({ title: "DevServerControlInput" });
+export const DevServerLogsInputSchema = z
+    .object({})
+    .meta({ title: "DevServerLogsInput" });
+export const DevServerRestartInputSchema = z.object({}).meta({
+    title: "DevServerRestartInput",
+    description: "Restarts the dev server with current configuration.",
+});
+export const BashToolInputSchema = z
+    .object({
+    description: z.string().meta({
+        description: "A human readable description of the command to run, for example 'install dependencies' or 'run tests'. This description will be used to explain the command to the user.",
+    }),
+    command: z.string().meta({
+        description: "The shell command to run, for example 'npm install --save uuid', 'yarn test' or 'npm run build'...",
+    }),
+    timeout: z.number().nullish().meta({
+        description: "Optional timeout in milliseconds (max/default 600000)",
+    }),
+})
+    .meta({ title: "BashToolInput" });
+export const PowerShellToolInputSchema = z
+    .object({
+    command: z.string().nullish().meta({
+        description: "The PowerShell command to run, for example 'npm install' or 'yarn test'",
+    }),
+    timeout: z.number().nullish().meta({
+        description: "The timeout in milliseconds for the command to run. Choose an appropriate timeout based on the command",
+    }),
+    description: z.string().nullish().meta({
+        description: "A human readable description of the command to run, for example 'install dependencies' or 'run tests'. This description will be used to explain the command to the user.",
+    }),
+})
+    .meta({ title: "PowerShellToolInput" });
+export const WebSearchToolInputSchema = z
+    .object({
+    query: z.string().meta({
+        description: "The question to search on the internet, be specific and concise.",
+    }),
+})
+    .meta({ title: "WebSearchToolInput" });
+export const WriteFileInputSchema = z
+    .object({
+    title: z.string().meta({
+        description: "Human readable description of the change or generated code, it's mandatory",
+    }),
+    file_path: z.string().meta({ description: FILE_PATH_DESCRIPTION }),
+    content: z.string().meta({
+        description: "Actual content to write into the file, use an empty string to remove the file",
+    }),
+})
+    .meta({ title: "WriteFileInput" });
+export const SearchReplaceInputSchema = z
+    .object({
+    title: z.string().meta({
+        description: "Human readable description of the change or generated code, it's mandatory",
+    }),
+    file_path: z.string().meta({
+        description: `${FILE_PATH_DESCRIPTION} The content of this path must be previously known.`,
+    }),
+    old_str: z.string().meta({ description: "The text to replace" }),
+    new_str: z.string().meta({
+        description: "The text to replace it with (must be different from old_str)",
+    }),
+    replace_all: z.boolean().optional().meta({
+        description: "Replace all occurences of old_str (default false)",
+    }),
+    apply_with_error: z.boolean().optional(),
+})
+    .meta({ title: "SearchReplaceInput" });
+export const MultiSearchReplaceInputSchema = z
+    .object({
+    title: z.string().meta({
+        description: "Human readable description of the change or generated code, it's mandatory",
+    }),
+    file_path: z.string().meta({
+        description: `${FILE_PATH_DESCRIPTION} The content of this path must be previously known.`,
+    }),
+    edits: z
+        .array(z.object({
+        old_str: z.string().meta({
+            description: "The text to replace (must match the file contents exactly, including all whitespace and indentation)",
+        }),
+        new_str: z.string().meta({
+            description: "The edited text to replace the old_str",
+        }),
+        replace_all: z.boolean().optional().meta({
+            description: "Replace all occurrences of old_str. This parameter is optional and defaults to false.",
+        }),
+    }))
+        .meta({
+        description: "An array of edit operations to perform, where each edit contains: old_str, new_str, replace_all",
+    }),
+    apply_with_error: z.boolean().nullish(),
+})
+    .meta({ title: "MultiSearchReplaceInput" });
+export const FindMediaToolInputSchema = z
+    .object({
+    query: z.string(),
+    type: z.enum(["image", "video"]),
+    orientation: z.enum(["landscape", "portrait", "square"]).nullish(),
+    hex_color: z.string().nullish(),
+})
+    .meta({ title: "FindMediaToolInput" });
+export const MediaToolInputSchema = z
+    .object({
+    query: z.string().meta({
+        description: "The text prompt describing the media to find or generate",
+    }),
+    type: z.enum(["image", "video", "gen-image"]).meta({
+        description: "The type of media: 'image' to search images, 'video' to search videos, or 'gen-image' to generate an AI image",
+    }),
+    orientation: z.enum(["landscape", "portrait", "square"]).nullish().meta({
+        description: "The orientation/aspect ratio of the media (landscape=wide, portrait=tall, square=1:1)",
+    }),
+    hex_color: z.string().nullish().meta({
+        description: "Optionally use to find images with the predominant specified hex color, for example '#000000' or '#FFFFFF'",
+    }),
+    input_image_urls: z.array(z.string()).nullish().meta({
+        description: 'Reference image URLs for AI image generation (only used with type: "gen-image")',
+    }),
+})
+    .meta({ title: "MediaToolInput" });
+export const MemoryToolInputSchema = z
+    .object({
+    content: z.string().meta({
+        description: "Markdown content of the memory, keep it factual and to the point. Avoid using line numbers, code snippets as they are likely to change.",
+    }),
+    when: z.string().meta({
+        description: "The semantic search query that will be used to retrieve this memory later. Describe the situation, task, or context when this memory should be surfaced.",
+    }),
+    category: z
+        .union([
+        z.literal("architecture").meta({
+            description: "System structure, layers, and responsibilities",
+        }),
+        z.literal("data-and-sync").meta({
+            description: "Data storage, persistence, synchronization, IPC, and state flow",
+        }),
+        z.literal("patterns-and-standards").meta({
+            description: "Canonical ways of doing things in this codebase",
+        }),
+        z.literal("coupling-and-duplication").meta({
+            description: "Cross-file, cross-surface, or duplicated logic that must stay aligned",
+        }),
+        z.literal("ui-and-ux-contracts").meta({
+            description: "User-visible behavior, UX guarantees, and UI rules",
+        }),
+        z.literal("concurrency-and-lifecycle").meta({
+            description: "Async behavior, ordering, lifecycle, and race prevention",
+        }),
+        z
+            .literal("invariants")
+            .meta({ description: "Hard rules that must always remain true" }),
+        z
+            .literal("security-and-trust")
+            .meta({ description: "Security, permissions, and trust boundaries" }),
+        z.literal("gotchas").meta({
+            description: "Known sharp edges that will break things if ignored",
+        }),
+        z.literal("constraints-and-limits").meta({
+            description: "System limits, assumptions, and non-obvious constraints",
+        }),
+        z.literal("rationale-and-history").meta({
+            description: "Why something is the way it is (tradeoffs, history, intent)",
+        }),
+    ])
+        .meta({ description: "The general category that this memory fits into" }),
+    glob: z.string().optional().meta({
+        description: "Glob pattern for file-based memory retrieval. Use specific paths (e.g., 'src/components/Button.tsx', 'lib/api/**/*.ts') rather than broad patterns (e.g., '*.tsx'). When files matching this glob are read, this memory will be suggested.",
+    }),
+    importance: z.number().optional(),
+    glob_auto_include: z.boolean().optional().meta({
+        description: "Whenever the memory should be included whenever the glob is matched.",
+    }),
+})
+    .meta({ title: "MemoryToolInput" });
+export const SearchMemoriesToolInputSchema = z
+    .object({
+    query: z.string(),
+    limit: z.number().optional(),
+    minSimilarity: z.number().optional(),
+})
+    .meta({ title: "SearchMemoriesToolInput" });
+export const ScoreMemoriesToolInputSchema = z
+    .object({
+    outcome: z.enum(["worked", "failed", "partial", "unknown"]),
+    memory_scores: z.record(z.string(), z.enum(["worked", "failed", "partial", "unknown"])),
+})
+    .meta({ title: "ScoreMemoriesToolInput" });
+/**
+ * Reusable `{ label, description }` option shape used by AskUserQuestion,
+ * ExitToolInput, ProposedConfig, ProposeConfigParams, etc.
+ */
+export const LabelOptionSchema = z
+    .object({
+    label: z.string(),
+    description: z.string(),
+})
+    .meta({ title: "LabelOption" });
+export const AskUserQuestionOptionSchema = z
+    .strictObject({
+    label: z.string().meta({
+        description: "The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice.",
+    }),
+    description: z.string().meta({
+        description: "Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications.",
+    }),
+    preview: z.string().nullish().meta({
+        description: "Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format.",
+    }),
+})
+    .meta({ title: "AskUserQuestionOption" });
+export const AskUserQuestionSchema = z
+    .strictObject({
+    question: z.string().meta({
+        description: 'The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?"',
+    }),
+    header: z.string().meta({
+        description: 'Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach".',
+    }),
+    options: z.array(AskUserQuestionOptionSchema).min(2).max(4).meta({
+        description: "The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically.",
+    }),
+    multiSelect: z.boolean().optional().meta({
+        description: "Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive.",
+    }),
+})
+    .meta({ title: "AskUserQuestion" });
+export const AskUserQuestionToolInputSchema = z
+    .strictObject({
+    questions: z
+        .array(AskUserQuestionSchema)
+        .min(1, "Must have at least 1 question")
+        .max(4)
+        .meta({ description: "Questions to ask the user (1-4 questions)" }),
+    answers: z
+        .record(z.string(), z.union([z.string(), z.array(z.string())]))
+        .optional(),
+})
+    .meta({ title: "AskUserQuestionToolInput" });
+export const AgentToolInputSchema = z
+    .object({
+    description: z
+        .string()
+        .meta({ description: "A short (3-5 word) description of the task" }),
+    prompt: z
+        .string()
+        .meta({ description: "The task for the agent to perform" }),
+    subagent_type: z.string().optional().meta({
+        description: "The type of specialized agent to use for this task",
+    }),
+    resume: z
+        .string()
+        .optional()
+        .meta({ description: "Optional agent ID to resume from" }),
+    origin_channel_id: z.string().optional().meta({
+        description: "The original user's channel_id that triggered this work. When provided, it will be included in the worker report so you can route the response back to the correct channel. Always pass this when spawning agents on behalf of a user request.",
+    }),
+    attachmentUrls: z.array(z.string()).optional().meta({
+        description: "URLs of images or files to attach to the agent's context. Useful for providing visual context like screenshots, designs, or reference images.",
+    }),
+})
+    .meta({ title: "AgentToolInput" });
+export const RevertToolInputSchema = z
+    .object({
+    checkpoint_id: z.string().meta({
+        description: "The checkpoint ID to revert back to. All changes from this checkpoint to HEAD will be reverted.",
+    }),
+})
+    .meta({ title: "RevertToolInput" });
+export const TodoReadToolInputSchema = z
+    .object({})
+    .meta({ title: "TodoReadToolInput" });
+export const RunningAgentsToolInputSchema = z
+    .object({})
+    .meta({ title: "RunningAgentsToolInput" });
+export const TodoWriteToolInputSchema = z
+    .object({
+    mode: z.enum(["replace", "patch"]).meta({
+        description: "Determine how the new todos update the current list: 'patch' means existing items will remain and only the provided items will be updated. The same 'id' must be provided for items you want to update. 'replace' means all existing items will be replaced with the new array of todos.",
+    }),
+    todos: z.array(z.object({
+        content: z.string().meta({
+            description: "The imperative form describing what needs to be done",
+        }),
+        status: z.enum(["pending", "in_progress", "completed"]),
+        id: z.string(),
+    })),
+})
+    .meta({ title: "TodoWriteToolInput" });
+export const TaskCreateToolInputSchema = z
+    .object({
+    subject: z.string().meta({ description: "A brief title for the task" }),
+    description: z.string().meta({ description: "What needs to be done" }),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+})
+    .meta({ title: "TaskCreateToolInput" });
+export const TaskUpdateToolInputSchema = z
+    .object({
+    taskId: z.string().meta({ description: "The ID of the task to update" }),
+    subject: z.string().optional().meta({
+        description: "New subject for the task",
+    }),
+    description: z.string().optional().meta({
+        description: "New description for the task",
+    }),
+    status: z
+        .enum(["pending", "in_progress", "completed", "deleted"])
+        .optional()
+        .meta({ description: "New status for the task" }),
+    owner: z.string().optional().meta({
+        description: "New owner for the task",
+    }),
+    addBlocks: z.array(z.string()).optional().meta({
+        description: "Task IDs that this task blocks",
+    }),
+    addBlockedBy: z.array(z.string()).optional().meta({
+        description: "Task IDs that block this task",
+    }),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+})
+    .meta({ title: "TaskUpdateToolInput" });
+export const TaskListToolInputSchema = z
+    .object({})
+    .meta({ title: "TaskListToolInput" });
+export const BuilderEditToolInputSchema = z
+    .object({
+    filePath: z.string().meta({
+        description: "The path of the Mitosis file to edit (e.g., index.lite.tsx)",
+    }),
+    old_str: z.string().meta({
+        description: "Content to be replaced, this substring should appear verbatim in the selected file_path",
+    }),
+    new_str: z.string().meta({
+        description: "New content to replace the old content with",
+    }),
+})
+    .meta({ title: "BuilderEditToolInput" });
+export const GetScreenshotToolInputSchema = z
+    .object({
+    href: z.string().optional(),
+    selector: z.string().optional(),
+    width: z.number().optional(),
+    height: z.number().optional(),
+})
+    .meta({ title: "GetScreenshotToolInput" });
+export const NavigatePreviewToolInputSchema = z
+    .object({
+    href: z.string().meta({
+        description: "The URL or relative path to navigate the preview to (e.g., '/about' or 'https://example.com')",
+    }),
+})
+    .meta({ title: "NavigatePreviewToolInput" });
+export const WebFetchToolInputSchema = z
+    .object({
+    url: z.string().meta({ description: "The URL to fetch content from" }),
+    prompt: z.string().optional().meta({
+        description: "Optional prompt to describe the content you want to extract from the URL. Leave it blank to fetch images.",
+    }),
+    include_styles: z.boolean().optional().meta({
+        description: "If true, the computed styles of the page will be extracted, as well as a screenshot. Prompt must be provided",
+    }),
+})
+    .meta({ title: "WebFetchToolInput" });
+export const ExplorationMetadataToolInputSchema = z
+    .object({
+    category: z
+        .enum(["reusable_knowledge", "one_off", "bad_quality"])
+        .optional(),
+    gif_id: z.string().optional(),
+    timeline_id: z.string().optional(),
+    recording_id: z.string().optional(),
+    important_files: z.array(z.object({
+        file_path: z.string().meta({
+            description: "The relative path of the file to read",
+        }),
+        relevance: z.enum(["high", "medium", "low"]).optional().meta({
+            description: "The relevance of the file based on the initial user_prompt",
+        }),
+        offset: z.number().optional().meta({
+            description: "The offset of the file to read, in lines",
+        }),
+        limit: z.number().optional().meta({
+            description: "The limit of the file to read, in lines",
+        }),
+    })),
+})
+    .meta({ title: "ExplorationMetadataToolInput" });
+export const EnterPlanModeToolInputSchema = z
+    .object({})
+    .meta({ title: "EnterPlanModeToolInput" });
+export const ExitPlanModeToolInputSchema = z
+    .object({
+    plan: z.string().meta({
+        description: "The plan you came up with, that you want to run by the user for approval. Supports markdown. The plan should be pretty concise. Do not include follow up questions in the plan.",
+    }),
+    handled: z.boolean().optional(),
+})
+    .meta({ title: "ExitPlanModeToolInput" });
+export const ReadMcpResourceToolInputSchema = z
+    .object({
+    uri: z.string().meta({
+        description: "The URI of the resource to read, matching a resource template pattern (e.g., 'file:///path/to/file')",
+    }),
+    serverName: z.string().optional().meta({
+        description: "Optional name of the MCP server to use. If not provided, will auto-detect based on URI.",
+    }),
+})
+    .meta({ title: "ReadMcpResourceToolInput" });
+export const TimelineEventCategorySchema = z
+    .enum([
+    "navigation",
+    "interaction",
+    "assertion",
+    "error",
+    "milestone",
+    "code-change",
+    "observation",
+])
+    .meta({ title: "TimelineEventCategory" });
+export const TestOutcomeSchema = z
+    .enum(["succeeded", "couldnt_verify", "failed", "other"])
+    .meta({ title: "TestOutcome" });
+export const TestCaseFailureCategorySchema = z
+    .enum([
+    "env_issue",
+    "creds_missing",
+    "needs_user_input",
+    "server_not_ready",
+    "feature_not_reachable",
+    "timeout",
+    "assertion_failed",
+    "unexpected_error",
+    "not_applicable",
+    "escalated",
+])
+    .meta({ title: "TestCaseFailureCategory" });
+export const RecordFrameToolInputSchema = z
+    .object({
+    title: z.string().meta({
+        description: "A descriptive title for this frame (e.g., 'Login page loaded', 'Form submitted successfully')",
+    }),
+    frame: z.literal("last-image").meta({
+        description: "The frame source. Use 'last-image' to record the most recent screenshot.",
+    }),
+    category: TimelineEventCategorySchema.optional().meta({
+        description: "Category of this frame for timeline organization. Default: 'milestone'",
+    }),
+    description: z.string().optional().meta({
+        description: "Optional longer description providing context about what this frame shows.",
+    }),
+})
+    .meta({ title: "RecordFrameToolInput" });
+export const ReportTestOutcomeToolInputSchema = z
+    .object({
+    outcome: TestOutcomeSchema.meta({
+        description: "The structured test outcome",
+    }),
+    summary: z.string().meta({
+        description: "A concise 1–2 sentence summary explaining the test outcome",
+    }),
+    details: z.string().optional().meta({
+        description: "Optional additional context: error messages, steps attempted, etc.",
+    }),
+    test_case_id: z.string().optional().meta({
+        description: "Links to a test case ID (e.g., 'TC-01'). If present, this is a per-case report. If absent, this is the session-level summary.",
+    }),
+    evidence_frame_count: z.number().optional().meta({
+        description: "Number of RecordFrame calls made for this test case. Should be >= 1 for per-case reports.",
+    }),
+    failure_category: TestCaseFailureCategorySchema.optional().meta({
+        description: "Structured failure reason. Required when outcome is failed or couldnt_verify.",
+    }),
+    failure_detail: z.string().optional().meta({
+        description: "Human-readable failure explanation. E.g., 'Login page returned 403 — test account may have been disabled'",
+    }),
+    console_errors: z.string().optional(),
+    network_failures: z.string().optional(),
+    steps_attempted: z.string().optional(),
+    urls_tested: z.array(z.string()).optional(),
+})
+    .meta({ title: "ReportTestOutcomeToolInput" });
+/**
+ * Configuration values proposed by the setup analyzer agent
+ */
+export const SetupAnalysisValuesSchema = z
+    .object({
+    projectOverview: z.object({
+        framework: z.string().nullable(),
+        packageManager: z.enum(["npm", "yarn", "pnpm", "bun"]).nullable(),
+        isMonorepo: z.boolean(),
+        detectedLanguage: z.enum(["typescript", "javascript"]).nullable(),
+    }),
+    rootDirectory: z
+        .object({
+        path: z.string(),
+        reason: z.string(),
+    })
+        .nullable(),
+    installCommand: z
+        .object({
+        command: z.string(),
+        reason: z.string(),
+    })
+        .nullable(),
+    runtimeDependencies: z.array(z.object({
+        tool: z.string(),
+        version: z.string(),
+        source: z.string(),
+    })),
+    devServer: z
+        .object({
+        command: z.string(),
+        url: z.string(),
+        port: z.number(),
+        reason: z.string(),
+    })
+        .nullable(),
+    environmentVariables: z.array(z.object({
+        key: z.string(),
+        description: z.string(),
+        isRequired: z.boolean(),
+        isSecret: z.boolean(),
+        defaultValue: z.string().nullable(),
+        source: z.string(),
+    })),
+    validationScript: z
+        .object({
+        command: z.string(),
+        reason: z.string(),
+    })
+        .nullable(),
+    npmrcContents: z.string().nullable(),
+    hasHotModuleReload: z
+        .object({
+        value: z.boolean(),
+        reason: z.string(),
+    })
+        .nullable(),
+})
+    .meta({ title: "SetupAnalysisValues" });
+export const ProposeConfigToolInputSchema = z
+    .object({
+    config: SetupAnalysisValuesSchema,
+    message: z.string().optional(),
+})
+    .meta({ title: "ProposeConfigToolInput" });
+// Field types for single-value setup updates
+export const SetupValueFieldSchema = z
+    .enum([
+    "installCommand",
+    "devServer",
+    "validationScript",
+    "environmentVariables",
+])
+    .meta({ title: "SetupValueField" });
+export const UpdateSetupValueToolInputSchema = z
+    .object({
+    field: SetupValueFieldSchema.meta({ description: "Which field to update" }),
+    value: z.object({
+        command: z.string().optional().meta({
+            description: "The command to run (for installCommand, devServer, validationScript)",
+        }),
+        url: z.string().optional().meta({
+            description: "Dev server URL (only for devServer)",
+        }),
+        port: z.number().optional().meta({
+            description: "Dev server port (only for devServer)",
+        }),
+        environmentVariables: z
+            .array(z.object({
+            key: z.string().meta({ description: "Variable name" }),
+            description: z.string().optional().meta({
+                description: "What this variable is for",
+            }),
+            isRequired: z.boolean().optional().meta({
+                description: "Whether this variable is required",
+            }),
+            isSecret: z.boolean().optional().meta({
+                description: "Whether this is a secret/credential",
+            }),
+            defaultValue: z.string().nullish(),
+        }))
+            .optional(),
+    }),
+    reason: z.string(),
+})
+    .meta({ title: "UpdateSetupValueToolInput" });
+export const ExitStateSchema = z
+    .enum([
+    "verified",
+    "no-frontend",
+    "empty-project",
+    "mobile-project",
+    "user-question",
+    "code-change-required",
+    "other",
+    "started",
+    "failed",
+])
+    .meta({
+    title: "ExitState",
+    description: "Current state: verified (all done), no-frontend (project has no dev server), empty-project (project has almost no code), mobile-project (mobile app e.g. Expo/React Native — recommend desktop local mode), user-question (need input), code-change-required (repo has code issues user must fix), other (other problem), started (Session started but Exit tool was never called (orphaned session)), failed (Session failed before reaching the agent (e.g. branch/container creation failed))",
+});
+export const ExitToolInputSchema = z
+    .object({
+    state: ExitStateSchema.meta({
+        description: "Current state: verified (all done), no-frontend (project has no dev server), empty-project (project has almost no code), mobile-project (mobile app e.g. Expo/React Native), user-question (need input), code-change-required (repo has code issues user must fix), other (other problem)",
+    }),
+    summary: z.string().meta({
+        description: "Brief summary of configuration outcome (what succeeded or what's needed)",
+    }),
+    questions: z
+        .array(z.object({
+        question: z.string().meta({ description: "Full question text" }),
+        context: z.string().meta({
+            description: "Why this information is needed",
+        }),
+        header: z.string().optional().meta({
+            description: 'Short label (e.g., "API Key", "Database URL")',
+        }),
+        type: z.enum(["select", "multi-select", "text"]).optional().meta({
+            description: 'Question type: "select" for single-choice, "multi-select" for multiple choices, "text" for free-form input. Defaults to "select" if options are present, "text" if not.',
+        }),
+        placeholder: z.string().optional().meta({
+            description: "Placeholder/hint text for 'text' type questions (e.g., 'Enter your API key', 'https://localhost:3000')",
+        }),
+        options: z.array(LabelOptionSchema).optional().meta({
+            description: "Suggested answer choices (for 'select' and 'multi-select' types). User can always choose 'Other'.",
+        }),
+    }))
+        .optional()
+        .meta({
+        description: "Questions for user (only when state is 'user-question'). Include suggested options when possible.",
+    }),
+    isMonorepo: z
+        .boolean()
+        .optional()
+        .meta({ description: "Repository contains multiple packages/apps" }),
+    isMicrofrontend: z.boolean().optional().meta({
+        description: "Frontend code served over multiple ports/servers",
+    }),
+    setupNeedsCredentials: z.boolean().optional().meta({
+        description: "Setup requires credentials (e.g., NPM_TOKEN for private packages)",
+    }),
+    devServerNeedsCredentials: z.boolean().optional().meta({
+        description: "Dev server needs special environment variables to run",
+    }),
+    needsVPN: z
+        .boolean()
+        .optional()
+        .meta({ description: "Setup requires a VPN connection" }),
+    autoReload: z.boolean().optional().meta({
+        description: "The dev server is able to reload the page automatically when the code changes, either through HMR or full page reload. Usually vite, webpack etc support this.",
+    }),
+    usesBuilderCms: z.boolean().optional().meta({
+        description: "The connected app uses Builder CMS (detected via @builder.io/react or @builder.io/sdk-* dependencies, a builder-registry file, or Builder CMS API keys such as BUILDER_PUBLIC_KEY)",
+    }),
+    stack: z.array(z.string()).optional().meta({
+        description: 'Technologies used by the connected application (not monorepo-wide). Include specific, high-confidence signals only, e.g. ["React", "Next.js", "Postgres", "Drizzle", "Tailwind CSS", "Clerk"]. Omit vague or uncertain entries.',
+    }),
+    projectDescription: z.string().optional().meta({
+        description: "A human-readable description of what this project is about — focus on purpose and domain, not technical stack. This helps route user requests to the right project (e.g., 'Company blog and content management', 'E-commerce storefront for selling shoes', 'Internal admin dashboard for managing users').",
+    }),
+})
+    .meta({ title: "ExitToolInput" });
+/**
+ * Configuration proposed by the configuration agent, stored in Firebase
+ */
+const DevCommandStateValues = [
+    "running",
+    "stopped",
+    "starting",
+    "failed",
+    "unset",
+];
+const SetupCommandStateValues = [
+    "not-installed",
+    "installing",
+    "installed",
+    "install-failed",
+    "install-aborted",
+];
+const HttpServerStateValues = [
+    "ok-2xx",
+    "error-4xx",
+    "error-5xx",
+    "error-fetch",
+    "stopped",
+    "connecting",
+];
+const ValidateCommandStateValues = [
+    "unset",
+    "running",
+    "stopped",
+    "success",
+    "failure",
+];
+const ProposedQuestionSchema = z.object({
+    question: z.string(),
+    context: z.string(),
+    whatYouTried: z.string().optional(),
+    header: z
+        .string()
+        .optional()
+        .meta({ description: "Short label (e.g., 'API Key', 'Database URL')" }),
+    type: z.enum(["select", "multi-select", "text"]).optional().meta({
+        description: 'Question type: "select" for single-choice, "multi-select" for multiple choices, "text" for free-form input',
+    }),
+    placeholder: z
+        .string()
+        .optional()
+        .meta({ description: "Placeholder text for text-type questions" }),
+    options: z.array(LabelOptionSchema).optional(),
+});
+export const EnvironmentVariableSchema = z
+    .object({
+    key: z.string(),
+    value: z.string(),
+    isSecret: z.boolean(),
+    placeholder: z.boolean().optional().meta({
+        description: "If true, indicates this is a placeholder value that needs user replacement",
+    }),
+    explanation: z.string().optional().meta({
+        description: "Explanation of why this env var is needed and what value the user should provide",
+    }),
+})
+    .meta({ title: "EnvironmentVariable" });
+const ProposedConfigurationSchema = z.object({
+    setupCommand: z.object({
+        value: z.string().optional(),
+        verified: z
+            .boolean()
+            .meta({ description: "Based on setupState === 'installed'" }),
+        elapsed: z
+            .number()
+            .optional()
+            .meta({ description: "Time taken in milliseconds (if verified)" }),
+    }),
+    setupDependencies: z.object({
+        value: z.array(SetupDependencySchema).optional(),
+        verified: z
+            .boolean()
+            .meta({ description: "Based on setupState === 'installed'" }),
+    }),
+    devCommand: z.object({
+        value: z.string().optional(),
+        verified: z
+            .boolean()
+            .meta({ description: "Based on devState === 'running'" }),
+        elapsed: z
+            .number()
+            .optional()
+            .meta({ description: "Time taken in milliseconds (if verified)" }),
+    }),
+    devServer: z.object({
+        value: z.string().optional(),
+        verified: z
+            .boolean()
+            .meta({ description: "Based on httpServerState === 'ok-2xx'" }),
+        elapsed: z.number().optional().meta({
+            description: "Time taken in milliseconds waiting for the server to respond",
+        }),
+    }),
+    validateCommand: z.object({
+        value: z.string().optional(),
+        verified: z
+            .boolean()
+            .meta({ description: "Based on validateState === 'success'" }),
+        elapsed: z
+            .number()
+            .optional()
+            .meta({ description: "Time taken in milliseconds (if verified)" }),
+    }),
+    appOrigin: z.object({
+        value: z.string().optional(),
+        verified: z
+            .boolean()
+            .meta({ description: "Based on httpServerState === 'ok-2xx'" }),
+    }),
+    defaultOrigin: z.object({
+        value: z.string().optional(),
+        verified: z.boolean().meta({
+            description: "Always true if set (used with wildcard appOrigin)",
+        }),
+    }),
+    environmentVariables: z.object({
+        value: z.array(EnvironmentVariableSchema).optional(),
+        verified: z
+            .boolean()
+            .meta({ description: "Based on devState === 'running'" }),
+    }),
+    autoDetectDevServer: z.object({
+        value: z.boolean().optional(),
+        verified: z.boolean().meta({ description: "Always true if set" }),
+    }),
+    autoDetectDevServerPatterns: z.object({
+        value: z.array(z.string()).optional(),
+        verified: z.boolean().meta({ description: "Always true if set" }),
+    }),
+    hasHotModuleReload: z.object({
+        value: z.boolean().optional(),
+        reason: z
+            .string()
+            .optional()
+            .meta({ description: "Detection-only, not auto-applied" }),
+    }),
+});
+const ProposedOrchestratorStatesSchema = z.object({
+    setupState: z.enum(SetupCommandStateValues),
+    devState: z.enum(DevCommandStateValues),
+    httpServerState: z.enum(HttpServerStateValues),
+    validateState: z.enum(ValidateCommandStateValues),
+});
+export const ProposedConfigSchema = z
+    .object({
+    id: z.string().meta({ description: "Auto-generated document ID" }),
+    projectId: z.string(),
+    branchName: z.string(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+    ownerId: z.string(),
+    state: ExitStateSchema.meta({
+        description: "Configuration state from Exit tool",
+    }),
+    summary: z.string().meta({ description: "Summary from Exit tool" }),
+    questions: z.array(ProposedQuestionSchema).optional(),
+    configuration: ProposedConfigurationSchema,
+    // Metadata
+    sessionId: z.string(),
+    orchestratorStates: ProposedOrchestratorStatesSchema,
+    // Resource usage tracking
+    peakDiskUsage: z
+        .number()
+        .optional()
+        .meta({ description: "Peak disk usage in bytes" }),
+    peakMemoryUsage: z
+        .number()
+        .optional()
+        .meta({ description: "Peak memory usage in bytes" }),
+    screenshotUrl: z.string().optional().meta({
+        description: "Screenshot URL from verification (e.g., error page screenshot)",
+    }),
+    // Repository metadata and classifications
+    isMonorepo: z.boolean().optional(),
+    isMicrofrontend: z.boolean().optional(),
+    setupNeedsCredentials: z.boolean().optional(),
+    devServerNeedsCredentials: z.boolean().optional(),
+    projectDescription: z.string().optional(),
+    cost: z.number().optional(),
+    durationMs: z.number().optional(),
+    needsVPN: z.boolean().optional(),
+    autoReload: z.boolean().optional(),
+    usesBuilderCms: z.boolean().optional(),
+    stack: z.array(z.string()).optional(),
+})
+    .meta({
+    title: "ProposedConfig",
+    description: "Configuration proposed by the configuration agent, stored in Firebase",
+});
+/**
+ * Parameters for proposing a configuration to the backend
+ */
+export const ProposeConfigParamsSchema = z
+    .object({
+    projectId: z.string(),
+    branchName: z.string(),
+    state: ExitStateSchema,
+    summary: z.string(),
+    questions: z
+        .array(z.object({
+        question: z.string(),
+        context: z.string(),
+        whatYouTried: z.string().optional(),
+        header: z.string().optional(),
+        options: z.array(LabelOptionSchema).optional(),
+        multiSelect: z.boolean().optional(),
+    }))
+        .optional(),
+    configuration: ProposedConfigurationSchema,
+    sessionId: z.string(),
+    orchestratorStates: ProposedOrchestratorStatesSchema,
+    peakDiskUsage: z.number().optional(),
+    peakMemoryUsage: z.number().optional(),
+    screenshotUrl: z.string().optional(),
+    isMonorepo: z.boolean().optional(),
+    isMicrofrontend: z.boolean().optional(),
+    setupNeedsCredentials: z.boolean().optional(),
+    devServerNeedsCredentials: z.boolean().optional(),
+    needsVPN: z.boolean().optional(),
+    projectDescription: z.string().optional(),
+    autoReload: z.boolean().optional(),
+    usesBuilderCms: z.boolean().optional(),
+    stack: z.array(z.string()).optional(),
+})
+    .meta({ title: "ProposeConfigParams" });
+// Verification tool inputs for project-configuration agent
+export const VerifySetupCommandToolInputSchema = z
+    .object({
+    command: z.string().meta({
+        description: "The install command to run (e.g., 'npm install', 'yarn', 'pnpm install'). It can be a multi-line command too, just like a shell script.",
+    }),
+    dependencies: z
+        .array(z.object({
+        tool: z.string().meta({
+            description: "The tool/binary to verify (e.g., 'node', 'npm', 'git')",
+        }),
+        version: z.string().optional().meta({
+            description: "Optional version requirement (e.g., '>=18.0.0', '20.x')",
+        }),
+    }))
+        .optional(),
+})
+    .meta({ title: "VerifySetupCommandToolInput" });
+export const VerifyDevCommandToolInputSchema = z
+    .object({
+    command: z.string().meta({
+        description: "The dev server command to run (e.g., 'npm run dev', 'cd packages/frontend && yarn dev')",
+    }),
+})
+    .meta({ title: "VerifyDevCommandToolInput" });
+export const VerifyDevServerToolInputSchema = z
+    .object({
+    autoDetect: z.boolean().meta({
+        description: "Whether to automatically detect the dev server URL from terminal output",
+    }),
+    autoDetectPattern: z.string().optional().meta({
+        description: "Pattern to match and extract URL from terminal output when multiple URLs are present (e.g., 'Local:.*http://localhost:\\\\d+')",
+    }),
+    hardcodedUrl: z.string().optional().meta({
+        description: "The hardcoded dev server URL to use when autoDetect is false (e.g., 'http://localhost:3000')",
+    }),
+    appOrigin: z.string().meta({
+        description: "The origin where the app should be accessed (e.g., 'https://acme.com', 'https://*.acme.com'). Can be a pattern with wildcard.",
+    }),
+    defaultOrigin: z.string().optional().meta({
+        description: "Default origin to use when appOrigin is a pattern (e.g., 'https://dev.acme.com'). Required if appOrigin contains a wildcard.",
+    }),
+})
+    .meta({ title: "VerifyDevServerToolInput" });
+export const VerifyValidateCommandToolInputSchema = z
+    .object({
+    command: z.string(),
+    timeout: z.number().optional().meta({
+        description: "Default: 300000 (5 minutes)",
+    }),
+})
+    .meta({ title: "VerifyValidateCommandToolInput" });
+export const ProposeEnvVariableToolInputSchema = z
+    .object({
+    key: z.string().meta({
+        description: "The environment variable name (e.g., 'NODE_ENV', 'API_KEY')",
+    }),
+    value: z.string().meta({
+        description: "The environment variable value. Must be a concrete value, not a placeholder.",
+    }),
+    secret: z.boolean().optional().meta({
+        description: "Whether this is a secret value (will be masked in logs). Default: false",
+    }),
+})
+    .meta({ title: "ProposeEnvVariableToolInput" });
+export const SetEnvVariableToolInputSchema = z
+    .object({
+    key: z.string().meta({
+        description: "The environment variable name (e.g., 'NODE_ENV', 'API_KEY')",
+    }),
+    value: z.string().meta({
+        description: "The environment variable value. Use clear placeholder like 'PLACEHOLDER_DATABASE_URL' if actual value is unknown.",
+    }),
+    secret: z.boolean().optional().meta({
+        description: "Whether this is a secret value (will be masked in logs). Default: false",
+    }),
+    placeholder: z.boolean().optional().meta({
+        description: "If true, indicates this is a placeholder value that needs user replacement",
+    }),
+    explanation: z.string().optional().meta({
+        description: "Explanation of why this env var is needed and what value the user should provide",
+    }),
+})
+    .meta({ title: "SetEnvVariableToolInput" });
+export const SetFileOverrideToolInputSchema = z
+    .object({
+    path: z.string().meta({
+        description: 'Path where the file should be written. Supports absolute paths ("/app/.npmrc"), tilde ("~/.npmrc") and paths relative to the project working directory ("./.npmrc"). Use this tool ONLY for configuration-only files that should NOT be committed to the repo (e.g. `.npmrc` with auth tokens, machine-local env files) — never to patch source code or fix software issues.',
+    }),
+    content: z.string().optional().meta({
+        description: "Plain text content to write to the file. Mutually exclusive with `base64`.",
+    }),
+    base64: z.string().optional().meta({
+        description: "Base64-encoded binary content to write to the file. Mutually exclusive with `content`. Use only when the file is genuinely binary.",
+    }),
+})
+    .meta({ title: "SetFileOverrideToolInput" });
+export const SendMessageToolInputSchema = z
+    .object({
+    channel_id: z.string().meta({
+        description: "The channel identifier in URI format (see supported formats in the tool description)",
+    }),
+    markdown: z.string().meta({
+        description: "The message content to send in markdown format",
+    }),
+    status: z.enum([
+        "starting",
+        "question",
+        "will-follow-up",
+        "done:success",
+        "done:error",
+    ]),
+    loading_message: z.string().optional().meta({
+        description: "Loading message displayed in the Slack thread while the agent is working (only used when status is 'starting').",
+    }),
+    voice_response: z.boolean().optional().meta({
+        description: "When true, send the response as a voice message using text-to-speech. Only supported for Telegram channels. Only set to true when the user's original message was a voice/audio message (look for '[Voice message transcription]' or '[Audio' markers), the channel is Telegram, and the response is short and conversational with no URLs, code, lists, or other content that doesn't translate to audio. Default to false (text) for all text-originated messages.",
+    }),
+    from_user_id: z.string().optional().meta({
+        description: "Builder.io user ID this message is from / should be attributed to. Only allowed when channel_id is 'builder/branch/{project_id}/{branch_name}'. When set, the message is delivered to the target branch as coming from this user (role 'user') instead of from the agent. Use whenever the message represents user feedback/intent that should be assigned to someone — even if it was composed, summarized, or merged from multiple people.",
+    }),
+})
+    .meta({ title: "SendMessageToolInput" });
+export const SpawnBranchToolInputSchema = z
+    .object({
+    project_id: z.string().meta({
+        description: "The project ID to create the branch in",
+    }),
+    message: z.string().meta({
+        description: "The initial message or task description for the branch. Do NOT include instructions to open or create a PR unless the user's original request explicitly asked for a PR.",
+    }),
+    builder_user_id: z.string().optional().meta({
+        description: "Builder.io user ID to act as. When provided, the branch will be created as if this user created it.",
+    }),
+    hidden: z.boolean().optional().meta({
+        description: "Whether to hide the branch from the user. Useful for exploratory branches not intended to ever get merged back to main. Default: false.",
+    }),
+    origin_channel_id: z.string().optional().meta({
+        description: "The channel identifier that originally triggered this work. Used for tracking purposes and coming back to the original slack thread with updates.",
+    }),
+    session_mode: z.enum(["normal", "planning", "deep-research"]).optional(),
+    model: z.enum(["auto", "opus", "sonnet", "haiku"]).optional(),
+    attachment_urls: z.array(z.string()).optional(),
+    git_base_branch: z.string().optional(),
+    auto_archive_on_idle: z.boolean().optional(),
+})
+    .meta({ title: "SpawnBranchToolInput" });
+export const CreateProjectToolInputSchema = z
+    .object({
+    repo_url: z.string().meta({
+        description: "Repository URL (regular Git URL or template:// URL)",
+    }),
+    name: z.string().optional().meta({
+        description: "Human-readable name for the project. If not provided, a name will be generated from the repo name.",
+    }),
+    builder_user_id: z.string().meta({
+        description: "Builder.io user ID to act as. The project and branch will be created as if this user created them, and their git credentials will be validated before creation.",
+    }),
+    origin_channel_id: z.string().optional().meta({
+        description: "The channel_id identifier that originally triggered this work. Used for routing status updates back to the user.",
+    }),
+    initial_message: z.string().optional().meta({
+        description: "Only valid for template:// URLs — creates a branch with this message",
+    }),
+})
+    .meta({ title: "CreateProjectToolInput" });
+export const GetAvailableReposToolInputSchema = z
+    .object({})
+    .meta({ title: "GetAvailableReposToolInput" });
+export const ReadBranchToolInputSchema = z
+    .object({
+    project_id: z.string().meta({
+        description: "The project ID containing the branch",
+    }),
+    branch_name: z.string().meta({
+        description: "The name of the branch to read",
+    }),
+})
+    .meta({ title: "ReadBranchToolInput" });
+export const ArchiveBranchToolInputSchema = z
+    .object({
+    project_id: z.string().meta({
+        description: "The project ID containing the branch",
+    }),
+    branch_name: z.string().meta({
+        description: "The name of the branch to archive",
+    }),
+    builder_user_id: z.string().meta({
+        description: "The Builder.io user ID of the person requesting the archive. This is used to attribute the archive action to a specific user.",
+    }),
+    reason: z.string().optional().meta({
+        description: "The reason for archiving this branch (max 500 chars). Examples: 'Work completed and merged', 'No longer needed', 'Superseded by branch X'.",
+    }),
+})
+    .meta({ title: "ArchiveBranchToolInput" });
+export const ReviewSeveritySchema = z
+    .enum(["high", "medium", "low"])
+    .meta({ title: "ReviewSeverity" });
+/** Comment for PR review - used by SubmitPRReview */
+export const PRReviewCommentSchema = z
+    .object({
+    file_path: z.string().meta({
+        description: "Relative file path - MUST be a file that appears in the PR diff",
+    }),
+    line: z.number().meta({
+        description: "Line number in the file (end line for multi-line). MUST be a line within the PR diff",
+    }),
+    start_line: z.number().optional().meta({
+        description: "For multi-line comments (optional)",
+    }),
+    side: z.enum(["LEFT", "RIGHT"]).optional().meta({
+        description: "Diff side. RIGHT (default) = NEW file (added/context). LEFT = OLD file (removed/context). Use LEFT only when commenting on deleted code with no semantically related new-side anchor.",
+    }),
+    title: z.string().meta({
+        description: "Brief plain-text issue title. MUST NOT start with severity emojis",
+    }),
+    body: z.string().meta({ description: "Review comment (1-2 sentences)" }),
+    severity: ReviewSeveritySchema.meta({
+        description: "Issue severity: high (blocking), medium (should fix), or low (minor observation)",
+    }),
+    debugInfo: z.string().optional(),
+    gif_id: z.string().optional().meta({
+        description: "Per-comment GIF (optional)",
+    }),
+})
+    .meta({ title: "PRReviewComment" });
+export const ReviewVerdictSchema = z
+    .enum(["looks_good", "has_findings", "blocking"])
+    .meta({ title: "ReviewVerdict" });
+/** SubmitPRReview - Fast code review without recording */
+export const SubmitPRReviewToolInputSchema = z
+    .object({
+    summary: z.string().meta({
+        description: "Your detailed analysis of the changes (displayed in a collapsible 'Review Details' section)",
+    }),
+    comments: z.array(PRReviewCommentSchema).optional(),
+    risk_level: ReviewSeveritySchema.optional(),
+    verdict: ReviewVerdictSchema.optional(),
+})
+    .meta({ title: "SubmitPRReviewToolInput" });
+export const ResolveQACommentsToolInputSchema = z
+    .object({
+    thread_node_ids: z.array(z.string()).meta({
+        description: "GraphQL thread node_ids (PRRT_...) from previous review response",
+    }),
+})
+    .meta({ title: "ResolveQACommentsToolInput" });
+export const ReportUIIssueToolInputSchema = z
+    .object({
+    title: z.string().meta({
+        description: "Brief summary of the issue (e.g., 'Button click has no effect')",
+    }),
+    description: z.string().meta({
+        description: "Detailed description of what went wrong, what was expected, and what actually happened",
+    }),
+    debugInfo: z.string().optional().meta({
+        description: "Optional console errors, stack traces, or other diagnostic information",
+    }),
+})
+    .meta({ title: "ReportUIIssueToolInput" });
+export const ReportIssueToolInputSchema = z
+    .object({
+    file_path: z.string().meta({
+        description: "File path where the issue occurs (e.g., 'packages/api/src/auth.ts')",
+    }),
+    line: z.number().meta({
+        description: "End line number of the issue range (or single line if no start_line)",
+    }),
+    start_line: z.number().optional().meta({
+        description: "Optional start line for multi-line issues. When provided, the comment spans from start_line to line",
+    }),
+    title: z.string().meta({
+        description: "Short, descriptive title (one line, no markdown)",
+    }),
+    severity: ReviewSeveritySchema.meta({
+        description: "Issue severity: high for critical bugs, medium for should-fix, low for minor observations",
+    }),
+    body: z.string().meta({
+        description: "Detailed explanation in markdown format. Should include: What the issue is, Why it's problematic, Impact, How to fix it, Evidence",
+    }),
+})
+    .meta({ title: "ReportIssueToolInput" });
+export const EscalateToPlannerSchema = z
+    .object({
+    issue: z.string().meta({ description: "What's blocking execution" }),
+    steps_attempted: z
+        .string()
+        .meta({ description: "What was tried before escalating" }),
+    current_url: z.string().meta({ description: "Current browser URL" }),
+    test_case_id: z
+        .string()
+        .meta({ description: "Which test case is blocked" }),
+})
+    .meta({ title: "EscalateToPlanner" });
+export const GetLastBrowserTestToolInputSchema = z
+    .object({})
+    .meta({ title: "GetLastBrowserTestToolInput" });
+export const IDEDiagnosticsToolInputSchema = z
+    .object({
+    file_path: z.string().optional().meta({
+        description: "Optional relative or absolute path to filter diagnostics to a single file. Omit to retrieve diagnostics for the entire workspace.",
+    }),
+})
+    .meta({ title: "IDEDiagnosticsToolInput" });
+export const PullPrototypeToolInputSchema = z
+    .object({
+    url: z.string().meta({
+        description: "The prototype URL (e.g., https://builder.io/app/projects/<projectId>/<branchName>)",
+    }),
+    project_id: z.string().optional().meta({
+        description: "The project ID (optional, parsed from URL if not provided)",
+    }),
+    branch_name: z.string().optional().meta({
+        description: "The branch name (optional, parsed from URL if not provided)",
+    }),
+})
+    .meta({ title: "PullPrototypeToolInput" });
+export const EnsurePRToolInputSchema = z
+    .object({
+    project_id: z.string().meta({
+        description: "The Builder.io project ID containing the branch",
+    }),
+    branch_name: z.string().meta({
+        description: "The Fusion branch name to push and open a PR for",
+    }),
+    builder_user_id: z.string().optional().meta({
+        description: "Builder.io user ID to attribute the PR to. When provided, the PR body will credit this user and the user must be a member of the organization. Highly recommended when the PR is being opened on behalf of a specific user.",
+    }),
+    draft: z.boolean().optional().meta({
+        description: 'Whether to create the PR as a draft. When omitted, defaults to the branch\'s configured commitMode: true for "draft-prs" branches, false for "prs" branches.',
+    }),
+})
+    .meta({ title: "EnsurePRToolInput" });
+export const ConnectMCPToolInputSchema = z
+    .object({
+    name: z.string().meta({
+        description: 'Human-readable name of the service to connect, e.g. "Jira", "Linear", "Sentry"',
+    }),
+    url: z.string().optional().meta({
+        description: "Remote MCP endpoint URL (e.g. https://mcp.linear.app/mcp). When omitted, the tool discovers known URLs for the named service instead.",
+    }),
+})
+    .meta({ title: "ConnectMCPToolInput" });
+export const CodeGenToolMapSchema = z.object({
+    Read: ReadToolInputSchema,
+    Write: WriteFileInputSchema,
+    Edit: SearchReplaceInputSchema,
+    ReadRule: GetRuleToolInputSchema,
+    Skill: SkillToolInputSchema,
+    GetStyleInspiration: GetStyleInspirationToolInputSchema,
+    GetScreenshot: GetScreenshotToolInputSchema,
+    NavigatePreview: NavigatePreviewToolInputSchema,
+    MultiEdit: MultiSearchReplaceInputSchema,
+    FindMedia: FindMediaToolInputSchema,
+    Media: MediaToolInputSchema,
+    AddMemory: MemoryToolInputSchema,
+    SearchMemories: SearchMemoriesToolInputSchema,
+    ScoreMemories: ScoreMemoriesToolInputSchema,
+    Bash: BashToolInputSchema,
+    PowerShell: PowerShellToolInputSchema,
+    WebSearch: WebSearchToolInputSchema,
+    AskUserQuestion: AskUserQuestionToolInputSchema,
+    Agent: AgentToolInputSchema,
+    Grep: GrepSearchToolInputSchema,
+    Glob: GlobSearchToolInputSchema,
+    DevServerControl: DevServerControlInputSchema,
+    DevServerLogs: DevServerLogsInputSchema,
+    DevServerRestart: DevServerRestartInputSchema,
+    Revert: RevertToolInputSchema,
+    TodoRead: TodoReadToolInputSchema,
+    TodoWrite: TodoWriteToolInputSchema,
+    TaskCreate: TaskCreateToolInputSchema,
+    TaskUpdate: TaskUpdateToolInputSchema,
+    TaskList: TaskListToolInputSchema,
+    BuilderEdit: BuilderEditToolInputSchema,
+    WebFetch: WebFetchToolInputSchema,
+    ExplorationMetadata: ExplorationMetadataToolInputSchema,
+    EnterPlanMode: EnterPlanModeToolInputSchema,
+    ExitPlanMode: ExitPlanModeToolInputSchema,
+    ReadMcpResource: ReadMcpResourceToolInputSchema,
+    RecordFrame: RecordFrameToolInputSchema,
+    SubmitPRReview: SubmitPRReviewToolInputSchema,
+    ProposeConfig: ProposeConfigToolInputSchema,
+    UpdateSetupValue: UpdateSetupValueToolInputSchema,
+    Exit: ExitToolInputSchema,
+    ResolveQAComments: ResolveQACommentsToolInputSchema,
+    GetLastBrowserTest: GetLastBrowserTestToolInputSchema,
+    ReportUIIssue: ReportUIIssueToolInputSchema,
+    ReportIssue: ReportIssueToolInputSchema,
+    ReportTestOutcome: ReportTestOutcomeToolInputSchema,
+    VerifySetupCommand: VerifySetupCommandToolInputSchema,
+    VerifyDevCommand: VerifyDevCommandToolInputSchema,
+    VerifyDevServer: VerifyDevServerToolInputSchema,
+    VerifyValidateCommand: VerifyValidateCommandToolInputSchema,
+    ProposeEnvVariable: ProposeEnvVariableToolInputSchema,
+    SetEnvVariable: SetEnvVariableToolInputSchema,
+    SetFileOverride: SetFileOverrideToolInputSchema,
+    SendMessage: SendMessageToolInputSchema,
+    SpawnBranch: SpawnBranchToolInputSchema,
+    CreateProject: CreateProjectToolInputSchema,
+    GetAvailableRepos: GetAvailableReposToolInputSchema,
+    ReadBranch: ReadBranchToolInputSchema,
+    ArchiveBranch: ArchiveBranchToolInputSchema,
+    RunningAgents: RunningAgentsToolInputSchema,
+    IDEDiagnostics: IDEDiagnosticsToolInputSchema,
+    EscalateToPlanner: EscalateToPlannerSchema,
+    PullPrototype: PullPrototypeToolInputSchema,
+    ConnectMCP: ConnectMCPToolInputSchema,
+    EnsurePR: EnsurePRToolInputSchema,
+});
+export const CodeGenToolsSchema = CodeGenToolMapSchema.keyof().meta({
+    title: "CodeGenTools",
+});
+export const SessionModeSchema = z
+    .enum(["planning", "normal", "auto-planning", "deep-research"])
+    .meta({ title: "SessionMode" });
+export const CodeGenModeSchema = z
+    .enum([
+    "quality",
+    "quality-v4",
+    /**
+     * @deprecated Use `quality-v4` instead. Kept for backwards compatibility
+     * with older dev-tools clients in the wild that may still request this mode
+     * for sub-agents. New code should not produce this value.
+     */
+    "quality-v4-agent",
+])
+    .meta({ title: "CodeGenMode" });
 export const DEFAULT_QUEUE_BEHAVIOR = {
     schedule: "next-turn",
     coalesce: "merge",
@@ -47,3 +1555,378 @@ export const BASE_CODEGEN_POSITIONS = [
     "design-system-indexer",
     "builder-publish-integration",
 ];
+export const BaseCodeGenPositionSchema = z
+    .enum(BASE_CODEGEN_POSITIONS)
+    .meta({ title: "BaseCodeGenPosition" });
+export const CodeGenPositionSchema = z
+    .union([
+    BaseCodeGenPositionSchema,
+    z.templateLiteral([BaseCodeGenPositionSchema, "-agent"]),
+])
+    .meta({ title: "CodeGenPosition" });
+export const RepoIndexingConfigSchema = z
+    .object({
+    designSystems: z.array(z.string()),
+})
+    .meta({ title: "RepoIndexingConfig" });
+export const LocalMCPToolsSchema = z
+    .object({
+    name: z.string(),
+    description: z.string().optional(),
+    inputSchema: z.any().optional(),
+    serverName: z.string(),
+})
+    .meta({ title: "LocalMCPTools" });
+export const CodeGenCategorySchema = z
+    .union([
+    z.templateLiteral(["repair-", z.string()]),
+    z.literal("user-normal"),
+    z.literal("user-figma"),
+    z.literal("user-pdf"),
+    z.literal("user-image"),
+    z.literal("setup-agent"),
+    z.templateLiteral(["background-", z.string()]),
+    z.templateLiteral(["indexing-", z.string()]),
+])
+    .meta({ title: "CodeGenCategory" });
+export const UserSourcePermissionSchema = z
+    .enum([
+    "editCode",
+    "modifyMcpServers",
+    "modifyProjectSettings",
+    "createBranches",
+    "sendPullRequests",
+    "view",
+])
+    .meta({ title: "UserSourcePermission" });
+const userSourceBaseShape = {
+    role: z.enum(["user", "agent"]),
+    principals: z
+        .array(z.string())
+        .optional()
+        .meta({ description: "teams/roles like ['developer', 'admin']" }),
+    jobs: z.array(z.string()).optional().meta({
+        description: "job titles like ['designer', 'developer'] - used for role-aware communication instead of principals when available",
+    }),
+    permissions: z.array(UserSourcePermissionSchema).optional(),
+    channelId: z.string().optional(),
+};
+export const UserSourceBaseSchema = z
+    .object(userSourceBaseShape)
+    .meta({ title: "UserSourceBase" });
+/** All integration sources: Slack, Teams, Jira, Linear, and git providers (GitHub, GitLab, Azure, Bitbucket). */
+export const UserSourceOtherSchema = z
+    .object({
+    ...userSourceBaseShape,
+    source: z.enum([
+        "slack",
+        "telegram",
+        "whatsapp",
+        "teams",
+        "jira",
+        "linear",
+        "github",
+        "gitlab",
+        "azure",
+        "bitbucket",
+    ]),
+    userId: z.string().optional().meta({
+        description: "User ID from the external platform (Slack user ID, GitHub user id, etc.)",
+    }),
+    userName: z.string().optional(),
+    userEmail: z.string().optional(),
+    photoURL: z.string().optional(),
+    builderUserId: z.string().optional().meta({
+        description: "Resolved Builder user ID for attribution/credits",
+    }),
+    link: z.string().optional().meta({
+        description: "Optional link (e.g. comment/PR URL) for git provider sources",
+    }),
+})
+    .meta({ title: "UserSourceOther" });
+export const UserSourceBuilderSchema = z
+    .object({
+    ...userSourceBaseShape,
+    source: z.literal("builder.io"),
+    userId: z.string().optional(),
+    userName: z.string().optional(),
+    userEmail: z.string().optional(),
+    photoURL: z.string().optional(),
+})
+    .meta({ title: "UserSourceBuilder" });
+export const UserSourceAgentSchema = z
+    .object({
+    ...userSourceBaseShape,
+    source: z.literal("agent"),
+    userId: z.string().optional(),
+    userName: z.string().optional(),
+    userEmail: z.string().optional(),
+})
+    .meta({ title: "UserSourceAgent" });
+export const UserSourceSchema = z
+    .discriminatedUnion("source", [
+    UserSourceOtherSchema,
+    UserSourceBuilderSchema,
+    UserSourceAgentSchema,
+])
+    .meta({ title: "UserSource" });
+export const PermissionSchema = z
+    .enum(["read", "write", "list"])
+    .meta({ title: "Permission" });
+// One ACL rule
+export const AclEntrySchema = z
+    .object({
+    action: z
+        .enum(["allow", "deny"])
+        .meta({ description: "whether this rule allows or denies access" }),
+    resource: z
+        .string()
+        .meta({ description: "what — supports glob patterns like /files/*.txt" }),
+    permissions: z
+        .array(PermissionSchema)
+        .meta({ description: "actions this rule applies to" }),
+    description: z.string().optional().meta({
+        description: "custom message, in deny case, this is the error message. This will override denyDescription on AclPolicy if defined.",
+    }),
+    principals: z.array(z.string()).optional().meta({
+        description: "array of teams/roles this rule applies to (e.g., ['developer', 'admin'])",
+    }),
+})
+    .meta({ title: "AclEntry" });
+// A full ACL policy is just a list of rules
+export const AclPolicySchema = z
+    .object({
+    secrets: z.array(z.string()).optional(),
+    entries: z.array(AclEntrySchema).optional(),
+    denyDescription: z.string().optional().meta({
+        description: "Default message to use when a resource is denied access",
+    }),
+})
+    .meta({ title: "AclPolicy" });
+export const SystemReminderObjSchema = z
+    .object({
+    text: z.string(),
+    tag: z.string().optional(),
+    ephemeral: z.boolean().optional(),
+})
+    .meta({ title: "SystemReminderObj" });
+export const SystemReminderSchema = z
+    .union([z.string(), SystemReminderObjSchema])
+    .meta({ title: "SystemReminder" });
+// Schema for CodeGenInputOptions. This is `z.looseObject` so unknown / forward-compat
+// fields pass through. Fields marked `@internal` (function values, middleware-set
+// markers) are excluded from the schema and added back via TypeScript intersection
+// in the `CodeGenInputOptions` type below.
+//
+// BuilderContent and PrettierOptions are declared in other modules.
+// For those we use `z.custom<T>()` as a forward-reference: the inferred TS type is correct,
+// runtime validation is identity-only.
+export const CodeGenInputOptionsSchema = z
+    .looseObject({
+    position: CodeGenPositionSchema,
+    eventName: z.string().optional(),
+    sessionId: z.string(),
+    codeGenMode: CodeGenModeSchema.optional(),
+    sessionMode: SessionModeSchema.optional(),
+    url: z.string().optional(),
+    diffActions: z.boolean().optional(),
+    planningPrompt: z.boolean().optional(),
+    customInstructions: z.array(CustomInstructionSchema).optional(),
+    customAgents: z.array(CustomAgentInfoSchema).optional(),
+    systemPromptOverride: z.union([z.string(), z.array(z.string())]).optional(),
+    userPrompt: z.string().optional(),
+    systemReminders: z.array(SystemReminderSchema).optional(),
+    ephemeralUserPrompt: z.string().optional(),
+    uiContextPrompt: z.string().optional(),
+    displayUserPrompt: z.string().optional(),
+    files: z.array(ProjectFileSchema).optional(),
+    rerankFiles: z.number().optional(),
+    toolResults: z.array(ContentMessageItemToolResultSchema).optional(),
+    attachments: z.array(AttachmentSchema).optional(),
+    beforeCommit: GitSnapshotSchema.optional(),
+    workingDirectory: z.string().optional(),
+    includeRelevantMemories: z.boolean().optional(),
+    encryptKey: z.string().optional(),
+    modelOverride: z.string().optional(),
+    errorIfHadCompaction: z.boolean().optional(),
+    softContextWindow: z.number().optional(),
+    promptVersion: z.enum(["v1", "v2", "v3"]).optional(),
+    reasoning: ReasoningEffortSchema.optional(),
+    redactUserMessages: z.boolean().optional(),
+    redactLLMMessages: z.boolean().optional(),
+    environmentVariables: z.array(EnvironmentVariableSchema).optional(),
+    skipCommandSecurity: z.boolean().optional(),
+    // Code options
+    builderContent: z.custom().optional(),
+    framework: CodeGenFrameworkSchema.optional(),
+    styleLibrary: CodeGenStyleLibrarySchema.optional(),
+    typescript: z.boolean().optional(),
+    userContext: UserContextSchema.optional(),
+    aclPolicy: AclPolicySchema.optional(),
+    repoIndexingConfig: RepoIndexingConfigSchema.optional(),
+    recommendedRoot: z.string().optional(),
+    enabledTools: z.array(CodeGenToolsSchema).optional(),
+    enabledMCPs: z.array(z.string()).optional(),
+    skipFileDiff: z.boolean().optional(),
+    interruptActiveTask: z.boolean().optional().meta({
+        description: "When true, the agent should interrupt its current task to handle this message immediately, rather than finishing the current task first.",
+    }),
+    localMCPTools: z.array(LocalMCPToolsSchema).optional().meta({
+        description: "Local MCP tool definitions from stdio servers (CLI-side only). These tools will be executed on the client side and passed through from the server.",
+    }),
+    isLocal: z.boolean().optional().meta({
+        description: "Indicates whether the codegen is running in local mode (local filesystem) vs cloud/container mode. Used to determine git auto-commit behavior.",
+    }),
+    maxAgentLoops: z.number().optional(),
+    maxAgentTiming: z.number().optional(),
+    maxTokens: z.number().optional().meta({
+        description: "Maximum output tokens allowed in the LLM response. This will set the maximum token output for the LLM.",
+    }),
+    maxPages: z.number().optional(),
+    autoContinue: z.number().optional(),
+    isManualContinue: z.boolean().optional(),
+    llmSuggestions: z.boolean().optional(),
+    conclusionText: z.boolean().optional(),
+    mcpServers: z.boolean().optional(),
+    pingEvents: z.boolean().optional(),
+    forceCompact: z.boolean().optional(),
+    hadPagination: z.boolean().optional(),
+    category: CodeGenCategorySchema.optional(),
+    metadata: z.record(z.string(), z.any()).optional(),
+    searchResponse: z.any().nullish(),
+    prettierConfig: z.custom().optional(),
+    // Role
+    role: z.enum(["user", "agent"]).optional(),
+    user: UserSourceSchema.optional(),
+    // Context
+    projectId: z.string().optional(),
+    branchName: z.string().optional(),
+    repoHash: z.string().optional(),
+    repoBranch: z.string().optional(),
+    parentSessionId: z.string().optional().meta({
+        description: "Immediate parent session id when this completion runs inside a sub-agent.",
+    }),
+    mainSessionId: z.string().optional().meta({
+        description: "Root session of the agent tree. Sub-agents inherit this from their parent so cost rolls up to the root in one hop, regardless of nesting depth.",
+    }),
+    /** @deprecated */
+    prevId: z.string().optional(),
+    /** @deprecated */
+    vcpId: z.string().optional(),
+    /** @deprecated */
+    repair: z.boolean().optional(),
+    /** @deprecated */
+    systemReminderPrompt: z.string().optional(),
+})
+    .meta({ title: "CodeGenInputOptions" });
+export const AutoPushModeSchema = z
+    .enum(["force-push", "merge-push", "ff-push", "safe-push", "none"])
+    .meta({ title: "AutoPushMode" });
+export const SyncChangesFromRemoteSchema = z
+    .object({
+    remoteBranches: z.enum(["both", "main", "ai"]).optional(),
+    fastForward: z.enum(["never", "required", "auto"]).optional(),
+    canPush: z.boolean().optional(),
+    uncommittedChanges: z.enum(["stash", "commit", "fail"]).optional(),
+    requestRefresh: z.boolean().optional(),
+    allowUnrelatedHistory: z.boolean().optional(),
+    resetToBase: z.boolean().optional().meta({
+        description: "When true, reset the AI branch hard to the remote feature/base branch instead of merging. This gives a clean slate that exactly matches the checked-out feature branch on remote, avoiding any merge-style conflicts or divergence. Fails clearly if the feature/base branch cannot be determined or is absent from the remote.",
+    }),
+    updateLastCommits: z.boolean().optional().meta({
+        description: "Whether to update the internal 'last AI commits' baseline after the sync completes. Defaults to `true` for backwards compatibility. Set to `false` when the caller wants `getChangesReport()` to keep diffing from the pre-sync baseline (e.g. so a downstream prompt can see exactly what changed since the last reset/sync)",
+    }),
+})
+    .meta({ title: "SyncChangesFromRemote" });
+export const GenerateUserMessageSchema = z
+    .object({
+    idempotencyKey: z.string().optional(),
+    user: UserSourceSchema.optional(),
+    userPrompt: z.string(),
+    uiContextPrompt: z.string().optional(),
+    ephemeralUserPrompt: z.string().optional(),
+    displayPrompt: z.string().optional(),
+    files: z.array(z.string()).optional(),
+    systemReminders: z.array(SystemReminderObjSchema).optional(),
+    includeBaseFiles: z.boolean().optional(),
+    attachments: z.array(AttachmentSchema).optional(),
+    logsCheckpoint: z.boolean().optional(),
+    dropAbortedPrompt: z.boolean().optional(),
+    runValidateCommand: z.boolean().optional(),
+    modelOverride: z.string().optional(),
+    agentModelOverrides: AgentModelOverridesSchema.optional(),
+    softContextWindow: z.number().optional(),
+    maxCompletions: z.number().optional(),
+    isManualContinue: z.boolean().optional(),
+    includeRelevantMemories: z.boolean().optional(),
+    category: CodeGenCategorySchema.optional(),
+    metadata: z.record(z.string(), z.any()).optional(),
+    autoPush: AutoPushModeSchema.optional(),
+    syncChanges: SyncChangesFromRemoteSchema.optional(),
+    enabledMCPs: z.array(z.string()).optional(),
+    sessionMode: SessionModeSchema.optional(),
+    queue: z.boolean().optional(),
+    agentType: z.string().optional().meta({
+        description: "Custom agent type to use for this message",
+    }),
+    enableQAReviewTool: z.boolean().optional().meta({
+        description: "Enable AddQAReview tool for QA PR review branches",
+    }),
+    reasoning: ReasoningEffortSchema.optional().meta({
+        description: "Per-message reasoning effort override",
+    }),
+    /** @deprecated */
+    repair: z.boolean().optional(),
+    forceCompact: z.boolean().optional().meta({
+        description: "Force compaction of the conversation before generating the next completion",
+    }),
+})
+    .meta({ title: "GenerateUserMessage" });
+/**
+ * Request for generating a commit message via LLM
+ */
+export const CommitMessageRequestSchema = z
+    .object({
+    diff: z.string().meta({ description: "Git diff from previous commit" }),
+    userMessages: z
+        .array(z.string())
+        .meta({ description: "User messages sent during AI work" }),
+    recentCommits: z.array(z.string()).meta({
+        description: "Last 10 commits from main branch for style reference",
+    }),
+    longCommit: z
+        .boolean()
+        .optional()
+        .meta({ description: "Whether to generate a long commit message" }),
+    projectId: z.string().optional().meta({
+        description: "Project ID for fetching project-specific commit instructions",
+    }),
+})
+    .meta({ title: "CommitMessageRequest" });
+/**
+ * Response from commit message generation
+ */
+export const CommitMessageResponseSchema = z
+    .object({
+    message: z.string().meta({ description: "Full commit message" }),
+    title: z
+        .string()
+        .meta({ description: "First line (50-72 chars) - the commit title" }),
+    body: z
+        .string()
+        .optional()
+        .meta({ description: "Optional extended description" }),
+})
+    .meta({ title: "CommitMessageResponse" });
+/**
+ * Request body for `POST /codegen/model-permission-response`. Sent by the
+ * frontend to approve or deny a model permission prompt.
+ */
+export const ModelPermissionResponseRequestSchema = z
+    .object({
+    sessionId: z.string(),
+    toolId: z.string(),
+    approved: z.boolean(),
+    reason: z.string().optional(),
+})
+    .meta({ title: "ModelPermissionResponseRequest" });