@co0ontty/wand 4.7.1 → 4.8.0

package/dist/structured-provider-common.js

@@ -3,13 +3,17 @@ export function isStructuredRunnerForProvider(provider, runner) {
         return runner === "claude-sdk" || runner === "claude-cli-print";
     if (provider === "codex")
         return runner === "codex-cli-exec";
-    return runner === "opencode-cli-run";
+    if (provider === "opencode")
+        return runner === "opencode-cli-run";
+    return runner === "grok-cli-headless";
 }
 export function defaultStructuredRunner(provider, configuredClaudeRunner = "cli") {
     if (provider === "codex")
         return "codex-cli-exec";
     if (provider === "opencode")
         return "opencode-cli-run";
+    if (provider === "grok")
+        return "grok-cli-headless";
     return configuredClaudeRunner === "sdk" ? "claude-sdk" : "claude-cli-print";
 }
 export function resolveStructuredRunner(provider, requestedRunner, configuredClaudeRunner = "cli") {
@@ -75,3 +79,14 @@ export function thinkingEffortToOpenCodeVariant(effort) {
         return "max";
     return effort.startsWith("codex:") ? effort.slice("codex:".length) || null : null;
 }
+export function thinkingEffortToGrokEffort(effort) {
+    if (!effort || effort === "off")
+        return null;
+    if (effort === "standard")
+        return "low";
+    if (effort === "deep")
+        return "high";
+    if (effort === "max")
+        return "max";
+    return effort.startsWith("codex:") ? effort.slice("codex:".length) || null : null;
+}

package/dist/structured-session-manager.d.ts

@@ -8,6 +8,7 @@ export interface StructuredSessionManagerRunners {
     claudeCli?: StructuredRunnerAdapter;
     codex?: StructuredRunnerAdapter;
     opencode?: StructuredRunnerAdapter;
+    grok?: StructuredRunnerAdapter;
 }
 interface CreateStructuredSessionOptions {
     cwd: string;
@@ -81,6 +82,7 @@ export declare class StructuredSessionManager {
     private readonly claudeCliRunner;
     private readonly codexRunner;
     private readonly openCodeRunner;
+    private readonly grokRunner;
     private disposed;
     constructor(storage: WandStorage, config: WandConfig, logger?: SessionLogger | null, sdkQueryFactory?: typeof sdkQuery, runners?: StructuredSessionManagerRunners);
     private archiveExpiredSessions;
@@ -167,6 +169,7 @@ export declare class StructuredSessionManager {
     private emit;
     private incrementApprovalStats;
     private runCodexStreaming;
+    private runGrokStreaming;
     private runOpenCodeStreaming;
     /**
      * Spawn `claude -p --output-format stream-json` and parse NDJSON lines as

package/dist/structured-session-manager.js

@@ -12,7 +12,9 @@ import { normalizeStructuredToolResultContent } from "./structured-content.js";
 import { buildAppendSystemPromptParts, buildClaudeSdkThinking, ClaudeCliRunner, derivePermissionPolicy, } from "./structured-claude-adapter.js";
 import { captureTaskMeta, extractClaudeAssistantMessage, extractClaudeModelName, normalizeClaudeToolInput, stampParentTaskResults, stampSelfTask, tagSubagentBlocks, } from "./structured-claude-protocol.js";
 import { OpenCodeRunner } from "./structured-opencode-adapter.js";
+import { GrokRunner } from "./structured-grok-adapter.js";
 import { defaultStructuredRunner, defaultStructuredState, isStructuredRunnerForProvider, normalizeThinkingEffort, resolveStructuredRunner, } from "./structured-provider-common.js";
+import { enrichStructuredMessages, WAND_PROTOCOL_VERSION } from "./structured-client-protocol.js";
 export { isStructuredRunnerForProvider, normalizeThinkingEffort, resolveStructuredRunner, thinkingEffortToClaudeCliEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToOpenCodeVariant, thinkingEffortToSdkBudget, } from "./structured-provider-common.js";
 /** The runner already persisted/emitted its detailed terminal snapshot. */
 class PersistedStructuredRunnerError extends Error {
@@ -89,8 +91,9 @@ function shouldAutoApproveForMode(mode) {
 }
 function buildStructuredOutputPayload(snapshot) {
     return {
+        wandProtocolVersion: WAND_PROTOCOL_VERSION,
         output: snapshot.output,
-        messages: snapshot.messages,
+        messages: snapshot.messages ? enrichStructuredMessages(snapshot.messages) : undefined,
         queuedMessages: snapshot.queuedMessages,
         sessionKind: "structured",
         structuredState: snapshot.structuredState,
@@ -139,12 +142,16 @@ export function isDuplicateStructuredQueueInput(snapshot, input) {
 }
 function buildIncrementalStructuredPayload(snapshot, cardDefaults) {
     const messages = snapshot.messages ?? [];
-    const lastTurn = messages.length > 0 ? messages[messages.length - 1] : undefined;
+    // Derive semantics from the complete current turn before taking the
+    // incremental tail; TaskCreate results can live in an earlier provider frame.
+    const clientMessages = enrichStructuredMessages(messages);
+    const lastTurn = clientMessages.length > 0 ? clientMessages[clientMessages.length - 1] : undefined;
     // Streaming turn (index 0 here) is preserved verbatim; truncation only kicks
     // in if the live response is already bigger than the transport threshold,
     // matching the PTY runner's behaviour in process-manager.ts.
     const lastMessage = lastTurn ? truncateMessagesForTransport([lastTurn], cardDefaults, 0)[0] : undefined;
     return {
+        wandProtocolVersion: WAND_PROTOCOL_VERSION,
         incremental: true,
         queuedMessages: snapshot.queuedMessages,
         sessionKind: "structured",
@@ -195,6 +202,7 @@ export class StructuredSessionManager {
     claudeCliRunner;
     codexRunner;
     openCodeRunner;
+    grokRunner;
     disposed = false;
     constructor(storage, config, logger = null, sdkQueryFactory = sdkQuery, runners = {}) {
         this.storage = storage;
@@ -204,12 +212,13 @@ export class StructuredSessionManager {
         this.claudeCliRunner = runners.claudeCli ?? new ClaudeCliRunner({ language: () => this.config.language });
         this.codexRunner = runners.codex ?? new CodexRunner();
         this.openCodeRunner = runners.opencode ?? new OpenCodeRunner();
+        this.grokRunner = runners.grok ?? new GrokRunner();
         for (const snapshot of this.storage.loadSessions()) {
             if ((snapshot.sessionKind ?? "pty") !== "structured")
                 continue;
             const restoredStatus = snapshot.status === "running" ? "idle" : snapshot.status;
             const storedProvider = snapshot.provider ?? snapshot.structuredState?.provider;
-            const provider = storedProvider === "codex" || storedProvider === "opencode"
+            const provider = storedProvider === "codex" || storedProvider === "opencode" || storedProvider === "grok"
                 ? storedProvider
                 : "claude";
             const storedRunner = snapshot.runner ?? snapshot.structuredState?.runner;
@@ -489,7 +498,7 @@ export class StructuredSessionManager {
         const id = randomUUID();
         const startedAt = new Date().toISOString();
         const requestedProvider = options.provider ?? "claude";
-        if (requestedProvider !== "claude" && requestedProvider !== "codex" && requestedProvider !== "opencode") {
+        if (requestedProvider !== "claude" && requestedProvider !== "codex" && requestedProvider !== "opencode" && requestedProvider !== "grok") {
             throw new Error(`不支持的结构化 provider: ${String(requestedProvider)}`);
         }
         const provider = requestedProvider;
@@ -511,9 +520,11 @@ export class StructuredSessionManager {
                 ? "codex exec --json"
                 : provider === "opencode"
                     ? "opencode run --format json"
-                    : runner === "claude-sdk"
-                        ? "claude-agent-sdk (stream-json)"
-                        : "claude -p --output-format stream-json",
+                    : provider === "grok"
+                        ? "grok -p --output-format streaming-json"
+                        : runner === "claude-sdk"
+                            ? "claude-agent-sdk (stream-json)"
+                            : "claude -p --output-format stream-json",
             cwd: worktreeSetup?.cwd ?? baseCwd,
             mode: options.mode,
             worktreeEnabled: Boolean(worktreeSetup),
@@ -714,6 +725,9 @@ export class StructuredSessionManager {
             else if (provider === "opencode") {
                 await this.runOpenCodeStreaming(id, updated, prompt, requestId);
             }
+            else if (provider === "grok") {
+                await this.runGrokStreaming(id, updated, prompt, requestId);
+            }
             else if (runner === "claude-sdk") {
                 await this.runClaudeSdkStreaming(id, updated, prompt, requestId);
             }
@@ -1306,6 +1320,150 @@ export class StructuredSessionManager {
         }
         setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
     }
+    async runGrokStreaming(sessionId, session, prompt, requestId) {
+        let emitTimer = null;
+        const syncSnapshot = (turnState) => {
+            const current = this.currentSessionForRequest(sessionId, requestId);
+            if (!current)
+                return;
+            const turn = {
+                role: "assistant",
+                content: this.compactContentBlocks([...turnState.blocks], turnState.result),
+                usage: turnState.usage,
+            };
+            const messages = [...(current.messages ?? [])];
+            if (messages.at(-1)?.role === "assistant")
+                messages[messages.length - 1] = turn;
+            else
+                messages.push(turn);
+            const patched = {
+                ...current,
+                claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
+                messages,
+                output: turnState.result || current.output,
+            };
+            this.sessions.set(sessionId, patched);
+            this.saveStreamingSnapshot(patched);
+        };
+        const flushEmit = () => {
+            if (emitTimer)
+                this.clearStreamEmitTimer(emitTimer);
+            emitTimer = null;
+            const current = this.currentSessionForRequest(sessionId, requestId);
+            if (current)
+                this.emit({
+                    type: "output",
+                    sessionId,
+                    data: buildIncrementalStructuredPayload(current, this.config.cardDefaults ?? {}),
+                });
+        };
+        const scheduleEmit = () => {
+            if (!emitTimer)
+                emitTimer = this.trackStreamEmitTimer(setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS));
+        };
+        const execution = this.grokRunner.start({
+            session,
+            prompt,
+            env: buildChildEnv(this.config.inheritEnv !== false),
+        }, {
+            isActive: () => this.isCurrentRequest(sessionId, requestId),
+            onStdout: (text) => this.logger?.appendStructuredStdout(sessionId, text),
+            onStderr: (text) => this.logger?.appendStructuredStderr(sessionId, text),
+            onEvent: (event) => this.logger?.appendStreamEvent(sessionId, event),
+            onUpdate: (turnState) => { syncSnapshot(turnState); scheduleEmit(); },
+        });
+        this.pendingRunnerExecutions.set(sessionId, execution);
+        this.logger?.appendStructuredSpawn(sessionId, {
+            kind: "grok-headless",
+            provider: "grok",
+            pid: execution.pid,
+            cwd: session.cwd,
+            args: execution.args,
+            prompt: prompt.slice(0, 2048),
+            promptLength: prompt.length,
+            sessionId: session.claudeSessionId,
+            spawnedAt: execution.spawnedAt,
+        });
+        let result;
+        try {
+            result = await execution.completion;
+        }
+        finally {
+            const released = this.releasePendingRunnerExecution(sessionId, execution);
+            if (released)
+                this.cancelStreamingCheckpointTimer(sessionId);
+        }
+        if (!this.isCurrentRequest(sessionId, requestId)) {
+            if (emitTimer)
+                this.clearStreamEmitTimer(emitTimer);
+            return;
+        }
+        flushEmit();
+        if (result.spawnError) {
+            const hint = result.spawnError.code === "ENOENT"
+                ? "（PATH 中找不到 grok；请安装 Grok Build CLI，或重跑 `wand service:install` 刷新服务 PATH）"
+                : "";
+            throw new Error(`grok 启动失败：${result.spawnError.message}${hint}`);
+        }
+        this.logger?.appendStructuredSpawn(sessionId, {
+            kind: "grok-headless-close",
+            pid: execution.pid,
+            spawnedAt: execution.spawnedAt,
+            closedAt: new Date().toISOString(),
+            exitCode: result.exitCode,
+            stderrTail: result.stderr.slice(-2048),
+            primaryError: result.primaryError,
+        });
+        const current = this.currentSessionForRequest(sessionId, requestId);
+        if (!current)
+            return;
+        const interruptedByUser = this.interruptedWith.has(sessionId);
+        const interruptPrompt = this.interruptedWith.get(sessionId);
+        if ((result.primaryError || (result.exitCode !== 0 && result.exitCode !== null) || result.signal) && !interruptedByUser) {
+            const errorText = this.formatStructuredExitError("grok", result.exitCode, result.signal, { stderr: result.stderr, primary: result.primaryError });
+            const failed = this.finishStructuredFailure(current, typeof result.exitCode === "number" ? result.exitCode : 1, errorText, result.state);
+            this.sessions.set(sessionId, failed);
+            this.saveAuthoritativeSession(failed);
+            this.emitStructuredSnapshot(failed);
+            this.emitStructuredSnapshot(failed, "ended");
+            throw new PersistedStructuredRunnerError(errorText);
+        }
+        const messages = this.buildCompletedAssistantMessages(current, result.state);
+        const keepRunning = !!interruptPrompt;
+        const finished = {
+            ...current,
+            status: keepRunning ? "running" : "idle",
+            exitCode: keepRunning ? null : 0,
+            endedAt: keepRunning ? null : new Date().toISOString(),
+            output: result.state.result,
+            claudeSessionId: result.state.sessionId ?? current.claudeSessionId,
+            messages,
+            queuedMessages: this.resolveQueuedMessagesAfterInterrupt(sessionId, current, interruptPrompt),
+            pendingEscalation: null,
+            permissionBlocked: false,
+            structuredState: {
+                ...current.structuredState,
+                model: result.state.model ?? current.structuredState?.model,
+                inFlight: false,
+                activeRequestId: null,
+                lastError: null,
+            },
+        };
+        this.sessions.set(sessionId, finished);
+        this.saveAuthoritativeSession(finished);
+        this.emitStructuredSnapshot(finished);
+        if (!keepRunning)
+            this.emitStructuredSnapshot(finished, "ended");
+        if (interruptPrompt) {
+            this.interruptedWith.delete(sessionId);
+            this.preserveQueueOnInterrupt.delete(sessionId);
+            setImmediate(() => this.sendMessage(sessionId, interruptPrompt).catch((error) => {
+                console.error("[WAND] grok interrupt-and-send failed:", error);
+            }));
+            return;
+        }
+        setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
+    }
     async runOpenCodeStreaming(sessionId, session, prompt, requestId) {
         let emitTimer = null;
         const syncSnapshot = (turnState) => {

package/dist/system-ai.js

@@ -99,6 +99,8 @@ export function discoverCliSystemAiConfig(preferred, home = os.homedir()) {
     const discoverers = { claude: discoverClaude, codex: discoverCodex, opencode: discoverOpenCode };
     const order = [preferred ?? "claude", "claude", "opencode", "codex"];
     for (const provider of [...new Set(order)]) {
+        if (provider === "grok")
+            continue;
         const found = discoverers[provider](home);
         if (found)
             return found;

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 export type SessionKind = "pty" | "structured";
-export type SessionProvider = "claude" | "codex" | "opencode";
+export type SessionProvider = "claude" | "codex" | "opencode" | "grok";
 export type CommitAiSource = "cli" | "api";
-export type SessionRunner = "claude-cli" | "claude-cli-print" | "claude-sdk" | "codex-cli-exec" | "opencode-cli-run" | "pty";
+export type SessionRunner = "claude-cli" | "claude-cli-print" | "claude-sdk" | "codex-cli-exec" | "opencode-cli-run" | "grok-cli-headless" | "pty";
 export type SessionSource = "interactive" | "automation" | "startup";
 export type ExecutionMode = "assist" | "agent" | "agent-max" | "default" | "auto-edit" | "full-access" | "native" | "managed";
 export type AutonomyPolicy = "assist" | "agent" | "agent-max";
@@ -392,12 +392,40 @@ export interface ThinkingBlock {
     thinking: string;
     __subagent?: SubagentMeta;
 }
+export interface StructuredQuestionOption {
+    label: string;
+    description?: string;
+}
+export interface StructuredQuestion {
+    question: string;
+    header?: string;
+    multiSelect: boolean;
+    options: StructuredQuestionOption[];
+}
+export interface StructuredTaskItem {
+    id: string;
+    content: string;
+    status: string;
+    activeForm?: string;
+}
+/**
+ * Wand-owned semantic projection of provider-specific tools. Clients should
+ * render this field and treat `name` / `input` as a legacy fallback only.
+ */
+export type ToolUseSemantic = {
+    kind: "question_request";
+    questions: StructuredQuestion[];
+} | {
+    kind: "task_list";
+    items: StructuredTaskItem[];
+};
 export interface ToolUseBlock {
     type: "tool_use";
     id: string;
     name: string;
     description?: string;
     input: Record<string, unknown>;
+    semantic?: ToolUseSemantic;
     __subagent?: SubagentMeta;
 }
 export interface ToolResultBlock {