grok-dev 1.0.0-rc8 → 1.1.1

package/dist/agent/agent.js

@@ -1,6 +1,9 @@
+import { convertToBase64 } from "@ai-sdk/provider-utils";
 import { stepCountIs, streamText } from "ai";
+import { addBatchRequests, createBatch, getBatchChatCompletion, pollBatchRequestResult, } from "../grok/batch";
 import { createProvider, generateTitle as genTitle, resolveModelRuntime } from "../grok/client";
 import { DEFAULT_MODEL, getModelInfo, normalizeModelId } from "../grok/models";
+import { toolSetToBatchTools } from "../grok/tool-schemas";
 import { createTools } from "../grok/tools";
 import { buildMcpToolSet } from "../mcp/runtime";
 import { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getNextMessageSequence, getSessionTotalTokens, loadTranscript, loadTranscriptState, recordUsageEvent, SessionStore, } from "../storage/index";
@@ -9,6 +12,7 @@ import { ScheduleManager } from "../tools/schedule";
 import { loadCustomInstructions } from "../utils/instructions";
 import { loadMcpServers, loadValidSubAgents, } from "../utils/settings";
 import { discoverSkills, formatSkillsForPrompt } from "../utils/skills";
+import { buildVerifyDetectPrompt, normalizeVerifyRecipe } from "../verify/entrypoint";
 import { createCompactionSummaryMessage, DEFAULT_KEEP_RECENT_TOKENS, DEFAULT_RESERVE_TOKENS, estimateConversationTokens, generateCompactionSummary, prepareCompaction, relaxCompactionSettings, shouldCompactContext, } from "./compaction";
 import { DelegationManager } from "./delegations";
 import { containsEncryptedReasoning, sanitizeModelMessages } from "./reasoning";
@@ -36,7 +40,7 @@ TOOLS:
 - process_logs: View recent output from a background process by ID.
 - process_stop: Stop a background process by ID.
 - process_list: List all background processes with status and uptime.
-- task: Delegate a focused foreground task to a sub-agent. Use general for multi-step execution, explore for fast read-only research, or a configured custom sub-agent name when listed under CUSTOM SUB-AGENTS.
+- task: Delegate a focused foreground task to a sub-agent. Use general for multi-step execution, explore for fast read-only research, verify for sandbox-aware validation, or a configured custom sub-agent name when listed under CUSTOM SUB-AGENTS.
 - delegate: Launch a read-only background agent for longer research while you continue working.
 - delegation_read: Retrieve a completed background delegation result by ID.
 - delegation_list: List running and completed background delegations. Do not poll it repeatedly.
@@ -65,10 +69,11 @@ WORKFLOW:
 9. Use search_web or search_x when you need up-to-date information
 
 DEFAULT DELEGATION POLICY:
-- Prefer the task tool by default for code review, code quality analysis, architecture research, root-cause investigation, bug triage, or any request that likely needs reading multiple files before acting.
+- Prefer the task tool by default for code review, code quality analysis, architecture research, root-cause investigation, bug triage, verification, or any request that likely needs reading multiple files before acting.
 - Prefer delegate for longer-running read-only exploration when you can keep making progress without blocking.
 - Use the explore sub-agent for read-only investigation, reviews, research, and "how does this work?" tasks.
 - Use the general sub-agent for delegated work that may need editing files, running commands, or producing a concrete implementation.
+- Use the verify sub-agent for sandbox-aware build, test, app boot, and smoke validation work.
 - Use a matching custom sub-agent when the task fits one of the configured specializations.
 - Never use delegate for tasks that should edit files or make shell changes.
 - When a background delegation is running, do not wait idly and do not spam delegation_list(). Continue useful work.
@@ -80,6 +85,7 @@ EXAMPLES:
 - "research how auth works" -> delegate to explore first
 - "investigate why this test fails" -> delegate to explore first, then continue with findings
 - "refactor this module" -> delegate a focused part to general when helpful
+- "verify this feature locally" -> use verify
 - "generate a logo" -> use generate_image
 - "animate this still image" -> use generate_video
 - Recurring specialized workflows -> use the matching custom sub-agent via task
@@ -161,27 +167,46 @@ Current working directory: ${cwd}`;
 function buildSubagentPrompt(request, cwd, custom, sandboxMode, subagents, sandboxSettings) {
     const isExplore = request.agent === "explore";
     const isVision = request.agent === "vision";
-    const mode = isExplore ? "ask" : "agent";
+    const isVerify = request.agent === "verify";
+    const isVerifyDetect = request.agent === "verify-detect";
+    const mode = isExplore || isVerifyDetect ? "ask" : "agent";
     const role = custom
         ? `You are the custom sub-agent "${custom.name}". You can investigate, edit files, and run commands unless the delegated task says otherwise.`
         : request.agent === "explore"
             ? "You are the Explore sub-agent. You are read-only and focus on fast codebase research."
             : isVision
                 ? "You are the Vision sub-agent."
-                : "You are the General sub-agent. You can investigate, edit files, and run commands to complete delegated work.";
+                : isVerifyDetect
+                    ? "You are the Verify Detect sub-agent. You inspect a repository to produce a structured verification recipe. You are read-only."
+                    : isVerify
+                        ? "You are the Verify sub-agent. You specialize in sandbox-aware local verification using builds, tests, app boot checks, and optional browser smoke tests."
+                        : "You are the General sub-agent. You can investigate, edit files, and run commands to complete delegated work.";
     const rules = isExplore
         ? [
             "Do not create, modify, or delete files.",
             "Prefer `read_file` and search commands over broad shell exploration.",
             "Return concise findings for the parent agent.",
         ]
-        : isVision
-            ? ["Validate the image."]
-            : [
-                "Work only on the delegated task below.",
-                "Use tools directly instead of narrating your intent.",
-                "Return a concise summary for the parent agent with key outcomes and any open risks.",
-            ];
+        : isVerifyDetect
+            ? [
+                "Do not create, modify, or delete files.",
+                "Read config files, package manifests, scripts, and source layout to understand the project.",
+                "Return ONLY a valid JSON object with the VerifyRecipe schema. No markdown, no prose, no explanation outside the JSON.",
+            ]
+            : isVision
+                ? ["Validate the image."]
+                : isVerify
+                    ? [
+                        "Focus on verification first. Do not make durable source edits unless the delegated task explicitly asks for fixes.",
+                        "Prefer the smallest meaningful set of validation commands and explain any environment blockers clearly.",
+                        "IMPORTANT: When the recipe includes a smoke target URL and a forwarded port, you MUST attempt browser smoke testing using agent-browser via the bash tool. The agent-browser command runs on the HOST, not inside the sandbox. It will work even in sandbox mode. Do not skip it or assume it is unavailable. Just run the command.",
+                        "Return a concise structured verification report for the parent agent.",
+                    ]
+                    : [
+                        "Work only on the delegated task below.",
+                        "Use tools directly instead of narrating your intent.",
+                        "Return a concise summary for the parent agent with key outcomes and any open risks.",
+                    ];
     const instructionLines = custom?.instruction.trim() ? ["", "SUB-AGENT INSTRUCTIONS:", custom.instruction.trim()] : [];
     return [
         role,
@@ -262,6 +287,7 @@ export class Agent {
     planContext = null;
     subagentStatusListeners = new Set();
     sendTelegramFile = null;
+    batchApi = false;
     constructor(apiKey, baseURL, model, maxToolRounds, options = {}) {
         this.baseURL = baseURL || null;
         if (apiKey) {
@@ -277,6 +303,7 @@ export class Agent {
         this.maxToolRounds = maxToolRounds || MAX_TOOL_ROUNDS;
         const envMax = Number(process.env.GROK_MAX_TOKENS);
         this.maxTokens = Number.isFinite(envMax) && envMax > 0 ? envMax : 16_384;
+        this.batchApi = options.batchApi ?? false;
         if (options.persistSession !== false) {
             this.sessionStore = new SessionStore(this.bash.getCwd());
             this.workspace = this.sessionStore.getWorkspace();
@@ -461,6 +488,173 @@ export class Agent {
             return [];
         }
     }
+    getBatchClientOptions(signal) {
+        if (!this.apiKey) {
+            throw new Error("API key required. Add an API key to continue.");
+        }
+        return {
+            apiKey: this.apiKey,
+            baseURL: this.baseURL ?? undefined,
+            signal,
+        };
+    }
+    async executeBatchToolCall(tools, toolCall, messages, signal) {
+        const tool = tools[toolCall.function.name];
+        if (!tool || tool.type === "provider" || typeof tool.execute !== "function") {
+            return {
+                input: parseToolArgumentsOrRaw(toolCall.function.arguments),
+                result: {
+                    success: false,
+                    output: `Tool "${toolCall.function.name}" is unavailable in batch mode.`,
+                },
+            };
+        }
+        let parsedInput;
+        try {
+            parsedInput = toolCall.function.arguments.trim() ? JSON.parse(toolCall.function.arguments) : {};
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                input: toolCall.function.arguments,
+                result: {
+                    success: false,
+                    output: `Tool "${toolCall.function.name}" received invalid JSON arguments: ${message}`,
+                },
+            };
+        }
+        try {
+            const output = await tool.execute(parsedInput, {
+                toolCallId: toolCall.id,
+                messages,
+                abortSignal: signal,
+            });
+            return {
+                input: parsedInput,
+                result: toToolResult(output),
+            };
+        }
+        catch (error) {
+            if (signal?.aborted) {
+                throw error;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                input: parsedInput,
+                result: {
+                    success: false,
+                    output: `Tool "${toolCall.function.name}" failed: ${message}`,
+                },
+            };
+        }
+    }
+    async runTaskRequestBatch(args) {
+        const { request, childMessages, childSystem, childRuntime, childTools, maxSteps, initialDetail, onActivity, signal, } = args;
+        if (childRuntime.modelInfo?.responsesOnly) {
+            throw new Error("Batch mode currently supports chat-completions models only.");
+        }
+        const batchTools = childRuntime.modelInfo?.supportsClientTools === false ? [] : await toolSetToBatchTools(childTools);
+        const batch = await createBatch({
+            ...this.getBatchClientOptions(signal),
+            name: buildBatchName(`task-${request.agent}`, request.description),
+        });
+        const turnMessages = [];
+        const totalUsage = {};
+        let assistantText = "";
+        let lastActivity = initialDetail;
+        for (let round = 0; round < maxSteps; round++) {
+            const batchRequestId = `task-${Date.now()}-${round + 1}`;
+            await addBatchRequests({
+                ...this.getBatchClientOptions(signal),
+                batchId: batch.batch_id,
+                batchRequests: [
+                    {
+                        batch_request_id: batchRequestId,
+                        batch_request: {
+                            chat_get_completion: buildBatchChatCompletionRequest({
+                                modelId: childRuntime.modelId,
+                                system: childSystem,
+                                messages: [...childMessages, ...turnMessages],
+                                temperature: request.agent === "explore" ? 0.2 : 0.5,
+                                maxOutputTokens: childRuntime.modelInfo?.supportsMaxOutputTokens === false
+                                    ? undefined
+                                    : Math.min(this.maxTokens, 8_192),
+                                reasoningEffort: childRuntime.providerOptions?.xai.reasoningEffort,
+                                tools: batchTools,
+                            }),
+                        },
+                    },
+                ],
+            });
+            const result = await pollBatchRequestResult({
+                ...this.getBatchClientOptions(signal),
+                batchId: batch.batch_id,
+                batchRequestId,
+            });
+            const response = getBatchChatCompletion(result);
+            accumulateUsage(totalUsage, getBatchUsage(response));
+            const choice = response.choices[0];
+            if (!choice) {
+                throw new Error("Batch response did not contain any choices.");
+            }
+            const content = choice?.message.content ?? "";
+            if (content) {
+                assistantText += content;
+            }
+            const requestMessages = [...childMessages, ...turnMessages];
+            const toolCalls = (choice?.message.tool_calls ?? []).map(toLocalToolCall);
+            const assistantMessage = buildAssistantBatchMessage(content, toolCalls);
+            if (assistantMessage) {
+                turnMessages.push(assistantMessage);
+            }
+            if (toolCalls.length === 0) {
+                if (hasUsage(totalUsage)) {
+                    this.recordUsage(totalUsage, "task", childRuntime.modelId);
+                }
+                const output = assistantText.trim() || `Task completed. Last action: ${lastActivity}`;
+                return {
+                    success: true,
+                    output,
+                    task: {
+                        agent: request.agent,
+                        description: request.description,
+                        summary: firstLine(output),
+                        activity: lastActivity,
+                    },
+                };
+            }
+            const toolParts = [];
+            for (const toolCall of toolCalls) {
+                const nextActivity = formatSubagentActivity(toolCall.function.name, parseToolArgumentsOrRaw(toolCall.function.arguments));
+                lastActivity = nextActivity;
+                onActivity?.(nextActivity);
+                const executed = await this.executeBatchToolCall(childTools, toolCall, requestMessages, signal);
+                toolParts.push({
+                    toolCall,
+                    input: executed.input,
+                    toolResult: executed.result,
+                });
+            }
+            const toolMessage = buildToolBatchMessage(toolParts);
+            if (toolMessage) {
+                turnMessages.push(toolMessage);
+            }
+        }
+        if (hasUsage(totalUsage)) {
+            this.recordUsage(totalUsage, "task", childRuntime.modelId);
+        }
+        const output = assistantText.trim() || `Task stopped after ${maxSteps} batch rounds. Last action: ${lastActivity}`;
+        return {
+            success: false,
+            output,
+            task: {
+                agent: request.agent,
+                description: request.description,
+                summary: output,
+                activity: lastActivity,
+            },
+        };
+    }
     async runTaskRequest(request, onActivity, abortSignal) {
         const provider = this.requireProvider();
         const signal = abortSignal;
@@ -468,10 +662,14 @@ export class Agent {
         const isExplore = agentKey === "explore";
         const isGeneral = agentKey === "general";
         const isVision = agentKey === "vision";
+        const isVerify = agentKey === "verify";
+        const isVerifyDetect = agentKey === "verify-detect";
         const subagents = loadValidSubAgents();
-        const custom = !isExplore && !isGeneral && !isVision ? findCustomSubagent(agentKey, subagents) : undefined;
-        if (!isExplore && !isGeneral && !isVision && !custom) {
-            const message = `Unknown sub-agent "${agentKey}". Use general, explore, vision, or a configured name from ~/.grok/user-settings.json.`;
+        const custom = !isExplore && !isGeneral && !isVision && !isVerify && !isVerifyDetect
+            ? findCustomSubagent(agentKey, subagents)
+            : undefined;
+        if (!isExplore && !isGeneral && !isVision && !isVerify && !isVerifyDetect && !custom) {
+            const message = `Unknown sub-agent "${agentKey}". Use general, explore, vision, verify, or a configured name from ~/.grok/user-settings.json.`;
             return {
                 success: false,
                 output: message,
@@ -482,13 +680,24 @@ export class Agent {
                 },
             };
         }
-        const childMode = isExplore ? "ask" : "agent";
+        const childMode = isExplore || isVerifyDetect ? "ask" : "agent";
+        const verifySandboxOverrides = isVerify
+            ? { allowNet: true, allowedHosts: undefined, allowEphemeralInstall: true, hostBrowserCommandsOnHost: true }
+            : {};
         const childBash = new BashTool(this.bash.getCwd(), {
-            sandboxMode: this.bash.getSandboxMode(),
-            sandboxSettings: this.bash.getSandboxSettings(),
+            sandboxMode: isVerify ? "shuru" : this.bash.getSandboxMode(),
+            sandboxSettings: isVerify
+                ? { ...this.bash.getSandboxSettings(), ...verifySandboxOverrides }
+                : this.bash.getSandboxSettings(),
         });
         const childBaseTools = createTools(childBash, provider, childMode);
-        const initialDetail = isExplore ? "Scanning the codebase" : "Planning delegated work";
+        const initialDetail = isExplore
+            ? "Scanning the codebase"
+            : isVerifyDetect
+                ? "Detecting verification recipe"
+                : isVerify
+                    ? "Preparing verification pass"
+                    : "Planning delegated work";
         let assistantText = "";
         let lastActivity = initialDetail;
         let childTools = childBaseTools;
@@ -512,6 +721,19 @@ export class Agent {
             const childMessages = isVision
                 ? await buildVisionUserMessages(request.prompt, childBash.getCwd(), signal)
                 : [{ role: "user", content: request.prompt }];
+            if (this.batchApi) {
+                return await this.runTaskRequestBatch({
+                    request,
+                    childMessages,
+                    childSystem,
+                    childRuntime,
+                    childTools,
+                    maxSteps: Math.min(this.maxToolRounds, isExplore ? 60 : 120),
+                    initialDetail,
+                    onActivity,
+                    signal,
+                });
+            }
             const result = streamText({
                 model: childRuntime.model,
                 system: childSystem,
@@ -605,6 +827,7 @@ export class Agent {
                 sandboxSettings: this.bash.getSandboxSettings(),
                 maxToolRounds: this.maxToolRounds,
                 maxTokens: this.maxTokens,
+                batchApi: this.batchApi,
             });
         }
         catch (err) {
@@ -681,6 +904,183 @@ export class Agent {
         this.messageSeqs = [null, ...keptSeqs];
         return true;
     }
+    async *processMessageBatchTurn(args) {
+        const { userModelMessage, observer, provider, subagents, system, runtime, modelInfo, signal } = args;
+        let attemptedOverflowRecovery = false;
+        while (true) {
+            let closeMcp;
+            const turnMessages = [];
+            const totalUsage = {};
+            try {
+                const settings = attemptedOverflowRecovery
+                    ? relaxCompactionSettings(this.getCompactionSettings())
+                    : this.getCompactionSettings();
+                if (modelInfo) {
+                    await this.compactForContext(provider, system, modelInfo.contextWindow, signal, settings, attemptedOverflowRecovery);
+                }
+                if (runtime.modelInfo?.responsesOnly) {
+                    throw new Error("Batch mode currently supports chat-completions models only.");
+                }
+                const baseTools = createTools(this.bash, provider, this.mode, {
+                    runTask: (request, abortSignal) => this.runTask(request, combineAbortSignals(signal, abortSignal)),
+                    runDelegation: (request, abortSignal) => this.runDelegation(request, combineAbortSignals(signal, abortSignal)),
+                    readDelegation: (id) => this.readDelegation(id),
+                    listDelegations: () => this.listDelegations(),
+                    scheduleManager: this.schedules,
+                    subagents,
+                    sendTelegramFile: this.sendTelegramFile ?? undefined,
+                });
+                let tools = runtime.modelInfo?.supportsClientTools === false ? {} : baseTools;
+                if (this.mode === "agent" && runtime.modelInfo?.supportsClientTools !== false) {
+                    const mcpBundle = await buildMcpToolSet(loadMcpServers());
+                    closeMcp = mcpBundle.close;
+                    tools = { ...baseTools, ...mcpBundle.tools };
+                    if (mcpBundle.errors.length > 0) {
+                        yield { type: "content", content: `MCP unavailable: ${mcpBundle.errors.join(" | ")}\n\n` };
+                    }
+                }
+                const batchTools = runtime.modelInfo?.supportsClientTools === false ? [] : await toolSetToBatchTools(tools);
+                const batch = await createBatch({
+                    ...this.getBatchClientOptions(signal),
+                    name: buildBatchName("session", this.getSessionId() || runtime.modelId),
+                });
+                for (let round = 0; round < this.maxToolRounds; round++) {
+                    const stepNumber = round + 1;
+                    notifyObserver(observer?.onStepStart, {
+                        stepNumber,
+                        timestamp: Date.now(),
+                    });
+                    const batchRequestId = `turn-${Date.now()}-${stepNumber}`;
+                    await addBatchRequests({
+                        ...this.getBatchClientOptions(signal),
+                        batchId: batch.batch_id,
+                        batchRequests: [
+                            {
+                                batch_request_id: batchRequestId,
+                                batch_request: {
+                                    chat_get_completion: buildBatchChatCompletionRequest({
+                                        modelId: runtime.modelId,
+                                        system,
+                                        messages: [...this.messages, ...turnMessages],
+                                        temperature: 0.7,
+                                        maxOutputTokens: runtime.modelInfo?.supportsMaxOutputTokens === false ? undefined : this.maxTokens,
+                                        reasoningEffort: runtime.providerOptions?.xai.reasoningEffort,
+                                        tools: batchTools,
+                                    }),
+                                },
+                            },
+                        ],
+                    });
+                    const result = await pollBatchRequestResult({
+                        ...this.getBatchClientOptions(signal),
+                        batchId: batch.batch_id,
+                        batchRequestId,
+                    });
+                    const response = getBatchChatCompletion(result);
+                    const choice = response.choices[0];
+                    if (!choice) {
+                        throw new Error("Batch response did not contain any choices.");
+                    }
+                    const usage = getBatchUsage(response);
+                    accumulateUsage(totalUsage, usage);
+                    const finishReason = getBatchFinishReason(choice.finish_reason);
+                    const content = choice.message.content ?? "";
+                    if (content) {
+                        yield { type: "content", content };
+                    }
+                    const requestMessages = [...this.messages, ...turnMessages];
+                    const toolCalls = (choice.message.tool_calls ?? []).map(toLocalToolCall);
+                    const assistantMessage = buildAssistantBatchMessage(content, toolCalls);
+                    if (assistantMessage) {
+                        turnMessages.push(assistantMessage);
+                    }
+                    if (toolCalls.length === 0) {
+                        notifyObserver(observer?.onStepFinish, {
+                            stepNumber,
+                            timestamp: Date.now(),
+                            finishReason,
+                            usage,
+                        });
+                        if (hasUsage(totalUsage)) {
+                            this.recordUsage(totalUsage, "message", runtime.modelId);
+                        }
+                        this.appendCompletedTurn(userModelMessage, turnMessages);
+                        yield { type: "done" };
+                        return;
+                    }
+                    yield { type: "tool_calls", toolCalls };
+                    const toolParts = [];
+                    for (const toolCall of toolCalls) {
+                        notifyObserver(observer?.onToolStart, {
+                            toolCall,
+                            timestamp: Date.now(),
+                        });
+                        const executed = await this.executeBatchToolCall(tools, toolCall, requestMessages, signal);
+                        notifyObserver(observer?.onToolFinish, {
+                            toolCall,
+                            toolResult: executed.result,
+                            timestamp: Date.now(),
+                        });
+                        yield { type: "tool_result", toolCall, toolResult: executed.result };
+                        toolParts.push({
+                            toolCall,
+                            input: executed.input,
+                            toolResult: executed.result,
+                        });
+                    }
+                    const toolMessage = buildToolBatchMessage(toolParts);
+                    if (toolMessage) {
+                        turnMessages.push(toolMessage);
+                    }
+                    notifyObserver(observer?.onStepFinish, {
+                        stepNumber,
+                        timestamp: Date.now(),
+                        finishReason,
+                        usage,
+                    });
+                }
+                const message = `Error: Reached max tool rounds (${this.maxToolRounds}) in batch mode.`;
+                notifyObserver(observer?.onError, {
+                    message,
+                    timestamp: Date.now(),
+                });
+                if (hasUsage(totalUsage)) {
+                    this.recordUsage(totalUsage, "message", runtime.modelId);
+                }
+                this.appendCompletedTurn(userModelMessage, turnMessages);
+                yield { type: "error", content: message };
+                yield { type: "done" };
+                return;
+            }
+            catch (err) {
+                if (signal.aborted) {
+                    this.discardAbortedTurn(userModelMessage);
+                    yield { type: "content", content: "\n\n[Cancelled]" };
+                    yield { type: "done" };
+                    return;
+                }
+                if (!attemptedOverflowRecovery && turnMessages.length === 0 && modelInfo && isContextLimitError(err)) {
+                    attemptedOverflowRecovery = true;
+                    continue;
+                }
+                const msg = err instanceof Error ? err.message : String(err);
+                notifyObserver(observer?.onError, {
+                    message: `Error: ${msg}`,
+                    timestamp: Date.now(),
+                });
+                if (hasUsage(totalUsage)) {
+                    this.recordUsage(totalUsage, "message", runtime.modelId);
+                }
+                this.appendCompletedTurn(userModelMessage, turnMessages);
+                yield { type: "error", content: `Error: ${msg}` };
+                yield { type: "done" };
+                return;
+            }
+            finally {
+                await closeMcp?.().catch(() => { });
+            }
+        }
+    }
     appendCompletedTurn(userMessage, newMessages) {
         if (newMessages.length === 0)
             return;
@@ -717,6 +1117,26 @@ export class Agent {
         const modelInfo = runtime.modelInfo;
         this.planContext = null;
         let attemptedOverflowRecovery = false;
+        if (this.batchApi) {
+            try {
+                yield* this.processMessageBatchTurn({
+                    userModelMessage,
+                    observer,
+                    provider,
+                    subagents,
+                    system,
+                    runtime,
+                    modelInfo,
+                    signal,
+                });
+            }
+            finally {
+                if (this.abortController?.signal === signal) {
+                    this.abortController = null;
+                }
+            }
+            return;
+        }
         try {
             while (true) {
                 let assistantText = "";
@@ -913,6 +1333,272 @@ export class Agent {
         }
         return this.provider;
     }
+    async detectVerifyRecipe(settings, abortSignal) {
+        try {
+            const result = await this.runTaskRequest({
+                agent: "verify-detect",
+                description: "Detect verification recipe",
+                prompt: buildVerifyDetectPrompt(this.bash.getCwd(), settings ?? this.bash.getSandboxSettings()),
+            }, undefined, abortSignal);
+            if (!result.success || !result.output)
+                return null;
+            const maybeJson = extractJsonObject(result.output);
+            if (!maybeJson)
+                return null;
+            return normalizeVerifyRecipe(JSON.parse(maybeJson));
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function extractJsonObject(text) {
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start < 0 || end < start)
+        return null;
+    return text.slice(start, end + 1);
+}
+function buildBatchName(prefix, label) {
+    const compact = label
+        .replace(/\s+/g, "-")
+        .replace(/[^a-zA-Z0-9._-]+/g, "")
+        .slice(0, 48) || "run";
+    return `grok-cli-${prefix}-${compact}`;
+}
+function buildBatchChatCompletionRequest(args) {
+    return {
+        model: args.modelId,
+        messages: toBatchChatMessages(args.system, args.messages),
+        temperature: args.temperature,
+        ...(args.maxOutputTokens != null ? { max_completion_tokens: args.maxOutputTokens } : {}),
+        ...(args.reasoningEffort ? { reasoning_effort: args.reasoningEffort } : {}),
+        ...(args.tools.length > 0 ? { tools: args.tools } : {}),
+    };
+}
+function toBatchChatMessages(system, messages) {
+    const batchMessages = [{ role: "system", content: system }];
+    for (const message of messages) {
+        const { role, content } = message;
+        switch (role) {
+            case "system":
+                batchMessages.push({ role: "system", content });
+                break;
+            case "user": {
+                if (typeof content === "string") {
+                    batchMessages.push({ role: "user", content });
+                    break;
+                }
+                if (!Array.isArray(content)) {
+                    break;
+                }
+                if (content.length === 1 && content[0]?.type === "text") {
+                    batchMessages.push({ role: "user", content: content[0].text });
+                    break;
+                }
+                const userContent = [];
+                for (const part of content) {
+                    switch (part.type) {
+                        case "text":
+                            userContent.push({ type: "text", text: part.text });
+                            break;
+                        case "image": {
+                            const mediaType = part.mediaType === "image/*" || !part.mediaType ? "image/jpeg" : part.mediaType;
+                            const data = part.image instanceof URL
+                                ? part.image.toString()
+                                : `data:${mediaType};base64,${toBase64DataContent(part.image)}`;
+                            userContent.push({ type: "image_url", image_url: { url: data } });
+                            break;
+                        }
+                        case "file": {
+                            if (!part.mediaType.startsWith("image/")) {
+                                break;
+                            }
+                            const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                            const data = part.data instanceof URL
+                                ? part.data.toString()
+                                : `data:${mediaType};base64,${toBase64DataContent(part.data)}`;
+                            userContent.push({ type: "image_url", image_url: { url: data } });
+                            break;
+                        }
+                    }
+                }
+                batchMessages.push({
+                    role: "user",
+                    content: userContent,
+                });
+                break;
+            }
+            case "assistant": {
+                if (typeof content === "string") {
+                    batchMessages.push({ role: "assistant", content });
+                    break;
+                }
+                if (!Array.isArray(content)) {
+                    break;
+                }
+                let assistantText = "";
+                const toolCalls = [];
+                for (const part of content) {
+                    if (part.type === "text") {
+                        assistantText += part.text;
+                    }
+                    else if (part.type === "tool-call") {
+                        toolCalls.push({
+                            id: part.toolCallId,
+                            type: "function",
+                            function: {
+                                name: part.toolName,
+                                arguments: JSON.stringify(part.input),
+                            },
+                        });
+                    }
+                }
+                if (assistantText || toolCalls.length > 0) {
+                    batchMessages.push({
+                        role: "assistant",
+                        content: assistantText,
+                        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+                    });
+                }
+                break;
+            }
+            case "tool":
+                for (const part of content) {
+                    if (part.type === "tool-approval-response") {
+                        continue;
+                    }
+                    batchMessages.push({
+                        role: "tool",
+                        tool_call_id: part.toolCallId,
+                        content: toolOutputToText(part.output),
+                    });
+                }
+                break;
+        }
+    }
+    return batchMessages;
+}
+function toBase64DataContent(value) {
+    return convertToBase64(value instanceof ArrayBuffer ? new Uint8Array(value) : value);
+}
+function toolOutputToText(output) {
+    switch (output.type) {
+        case "text":
+        case "error-text":
+            return String(output.value ?? "");
+        case "execution-denied":
+            return output.reason ?? "Tool execution denied.";
+        case "json":
+        case "error-json":
+        case "content":
+            return JSON.stringify(output.value ?? null);
+    }
+}
+function getBatchUsage(response) {
+    const usage = response.usage ?? {};
+    const inputTokens = asNumber(usage.input_tokens) ?? asNumber(usage.prompt_tokens);
+    const outputTokens = asNumber(usage.output_tokens) ?? asNumber(usage.completion_tokens);
+    const totalTokens = asNumber(usage.total_tokens) ?? sumDefined(inputTokens, outputTokens);
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        costUsdTicks: asNumber(usage.cost_in_usd_ticks),
+    };
+}
+function accumulateUsage(target, usage) {
+    target.inputTokens = (target.inputTokens ?? 0) + (usage.inputTokens ?? 0);
+    target.outputTokens = (target.outputTokens ?? 0) + (usage.outputTokens ?? 0);
+    target.totalTokens = (target.totalTokens ?? 0) + (usage.totalTokens ?? 0);
+    target.costUsdTicks = (target.costUsdTicks ?? 0) + (usage.costUsdTicks ?? 0);
+}
+function hasUsage(usage) {
+    return Boolean((usage.inputTokens ?? 0) || (usage.outputTokens ?? 0) || (usage.totalTokens ?? 0) || (usage.costUsdTicks ?? 0));
+}
+function getBatchFinishReason(finishReason) {
+    switch (finishReason) {
+        case "stop":
+        case "length":
+        case "content-filter":
+        case "tool-calls":
+        case "error":
+        case "other":
+            return finishReason;
+        case "tool_calls":
+            return "tool-calls";
+        default:
+            return "other";
+    }
+}
+function toLocalToolCall(toolCall) {
+    return {
+        id: toolCall.id,
+        type: "function",
+        function: {
+            name: toolCall.function.name,
+            arguments: toolCall.function.arguments,
+        },
+    };
+}
+function buildAssistantBatchMessage(content, toolCalls) {
+    if (toolCalls.length === 0) {
+        return content ? { role: "assistant", content } : null;
+    }
+    const parts = [];
+    if (content) {
+        parts.push({ type: "text", text: content });
+    }
+    for (const toolCall of toolCalls) {
+        parts.push({
+            type: "tool-call",
+            toolCallId: toolCall.id,
+            toolName: toolCall.function.name,
+            input: parseToolArgumentsOrRaw(toolCall.function.arguments),
+        });
+    }
+    return { role: "assistant", content: parts };
+}
+function buildToolBatchMessage(toolParts) {
+    if (toolParts.length === 0) {
+        return null;
+    }
+    return {
+        role: "tool",
+        content: toolParts.map((part) => ({
+            type: "tool-result",
+            toolCallId: part.toolCall.id,
+            toolName: part.toolCall.function.name,
+            output: part.toolResult.success
+                ? { type: "json", value: toSerializableValue(part.toolResult) }
+                : { type: "error-json", value: toSerializableValue(part.toolResult) },
+        })),
+    };
+}
+function parseToolArgumentsOrRaw(raw) {
+    try {
+        return raw.trim() ? JSON.parse(raw) : {};
+    }
+    catch {
+        return raw;
+    }
+}
+function toSerializableValue(value) {
+    try {
+        return JSON.parse(JSON.stringify(value ?? null));
+    }
+    catch {
+        return String(value);
+    }
+}
+function asNumber(value) {
+    return typeof value === "number" ? value : undefined;
+}
+function sumDefined(left, right) {
+    if (left == null && right == null) {
+        return undefined;
+    }
+    return (left ?? 0) + (right ?? 0);
 }
 function toToolCall(part) {
     return {