@co0ontty/wand 4.53.0 → 4.54.0-beta.gcb99d89

package/dist/structured-grok-adapter.js

@@ -6,6 +6,113 @@ function asRecord(value) {
         ? value
         : null;
 }
+function grokText(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(grokText).filter(Boolean).join("\n");
+    const record = asRecord(value);
+    if (!record)
+        return "";
+    if (typeof record.text === "string" && record.text)
+        return record.text;
+    if (record.content !== undefined)
+        return grokText(record.content);
+    if (record.stdout !== undefined || record.stderr !== undefined) {
+        return [grokText(record.stdout), grokText(record.stderr)].filter(Boolean).join("\n");
+    }
+    try {
+        return JSON.stringify(record);
+    }
+    catch {
+        return "";
+    }
+}
+function grokToolName(event) {
+    const raw = [
+        typeof event.toolName === "string" ? event.toolName : "",
+        typeof event.kind === "string" ? event.kind : "",
+        typeof event.title === "string" ? event.title : "",
+    ].find((value) => value.trim());
+    if (!raw)
+        return null;
+    const mapped = {
+        run_terminal_command: "Bash",
+        bash: "Bash",
+        shell: "Bash",
+        read_file: "Read",
+        read: "Read",
+        search_replace: "Edit",
+        edit: "Edit",
+        write: "Write",
+        list_dir: "Glob",
+        glob: "Glob",
+        grep: "Grep",
+        web_search: "WebSearch",
+        webfetch: "WebFetch",
+        todo_write: "TodoWrite",
+    };
+    return mapped[raw.toLowerCase()] ?? raw;
+}
+function grokToolInput(event) {
+    return asRecord(event.rawInput) ?? asRecord(event.input) ?? {};
+}
+function grokToolOutput(event) {
+    const fromRaw = grokText(event.rawOutput);
+    if (fromRaw)
+        return fromRaw;
+    return grokText(event.content);
+}
+function upsertGrokTool(state, event, completed) {
+    const id = typeof event.toolCallId === "string" && event.toolCallId
+        ? event.toolCallId
+        : typeof event.id === "string" && event.id ? event.id : "tool";
+    const input = grokToolInput(event);
+    const name = grokToolName(event);
+    const title = typeof event.title === "string" ? event.title : undefined;
+    const existingUse = state.blocks.find((block) => block.type === "tool_use" && block.id === id);
+    if (existingUse?.type === "tool_use") {
+        if (name)
+            existingUse.name = name;
+        existingUse.description = title ?? existingUse.description;
+        existingUse.input = Object.keys(input).length ? input : existingUse.input;
+    }
+    else {
+        state.blocks.push({ type: "tool_use", id, name: name ?? "tool", description: title, input });
+    }
+    if (!completed)
+        return;
+    const content = grokToolOutput(event);
+    const failed = event.status === "failed" || event.status === "error";
+    const existingResult = state.blocks.find((block) => block.type === "tool_result" && block.tool_use_id === id);
+    if (existingResult?.type === "tool_result") {
+        existingResult.content = content || existingResult.content;
+        existingResult.is_error = failed;
+        return;
+    }
+    state.blocks.push({ type: "tool_result", tool_use_id: id, content, is_error: failed });
+}
+/** Headless `--output-format streaming-json` is type-tagged; ACP stdio uses session/update. */
+function normalizeGrokEvent(event) {
+    if (typeof event.type === "string" && event.type)
+        return event;
+    if (event.method !== "session/update")
+        return event;
+    const params = asRecord(event.params);
+    const update = asRecord(params?.update) ?? asRecord(event.update);
+    if (!update)
+        return event;
+    const kind = typeof update.sessionUpdate === "string" ? update.sessionUpdate : "";
+    const content = asRecord(update.content);
+    const text = typeof content?.text === "string" ? content.text : grokText(update.content);
+    if (kind === "agent_message_chunk")
+        return { type: "text", data: text };
+    if (kind === "agent_thought_chunk" || kind === "thought")
+        return { type: "thought", data: text };
+    if (kind === "tool_call" || kind === "tool_call_update")
+        return { type: kind, ...update };
+    return event;
+}
 export function buildGrokArgs(session, prompt) {
     const args = ["--no-auto-update", "-p", prompt, "--output-format", "streaming-json"];
     const model = session.selectedModel?.trim();
@@ -26,6 +133,7 @@ export function buildGrokArgs(session, prompt) {
 }
 /** Apply one official Grok Build `streaming-json` event. */
 export function applyGrokEvent(state, event) {
+    event = normalizeGrokEvent(event);
     const type = typeof event.type === "string" ? event.type : "";
     if (type === "text" && typeof event.data === "string" && event.data) {
         const previous = state.blocks.at(-1);
@@ -44,6 +152,14 @@ export function applyGrokEvent(state, event) {
             state.blocks.push({ type: "thinking", thinking: event.data });
         return null;
     }
+    if (type === "tool_call") {
+        upsertGrokTool(state, event, event.status === "completed" || event.status === "failed" || event.status === "error");
+        return null;
+    }
+    if (type === "tool_call_update") {
+        upsertGrokTool(state, event, event.status !== "in_progress");
+        return null;
+    }
     if (type === "end") {
         if (typeof event.sessionId === "string" && event.sessionId)
             state.sessionId = event.sessionId;

package/dist/structured-opencode-adapter.js

@@ -34,7 +34,7 @@ export function buildOpenCodeArgs(session) {
         || session.mode === "full-access"
         || session.mode === "managed"
         || session.mode === "auto-edit") {
-        args.push("--dangerously-skip-permissions");
+        args.push("--auto");
     }
     if (session.claudeSessionId)
         args.push("--session", session.claudeSessionId);

package/dist/structured-pi-adapter.js

@@ -33,6 +33,62 @@ export function piToolName(name) {
     const mapped = { bash: "Bash", read: "Read", edit: "Edit", write: "Write", grep: "Grep", find: "Glob", ls: "Glob" };
     return mapped[name.toLowerCase()] ?? `Pi/${name}`;
 }
+function applyPiAssistantMessage(state, message) {
+    if (typeof message.model === "string")
+        state.model = message.model;
+    const usage = record(message.usage);
+    const cost = record(usage?.cost);
+    if (usage) {
+        state.usage = {
+            inputTokens: typeof usage.input === "number" ? usage.input : 0,
+            outputTokens: typeof usage.output === "number" ? usage.output : 0,
+            cacheReadInputTokens: typeof usage.cacheRead === "number" ? usage.cacheRead : 0,
+            cacheCreationInputTokens: typeof usage.cacheWrite === "number" ? usage.cacheWrite : 0,
+            totalCostUsd: typeof cost?.total === "number" ? cost.total : 0,
+        };
+    }
+    const texts = [];
+    const thinkings = [];
+    const parts = Array.isArray(message.content) ? message.content : [];
+    for (const part of parts) {
+        const item = record(part);
+        if (!item)
+            continue;
+        if (item.type === "text") {
+            const text = typeof item.text === "string" ? item.text : textContent(item);
+            if (text)
+                texts.push(text);
+        }
+        else if (item.type === "thinking") {
+            const thinking = typeof item.thinking === "string"
+                ? item.thinking
+                : typeof item.text === "string" ? item.text : "";
+            if (thinking)
+                thinkings.push(thinking);
+        }
+    }
+    const thinking = thinkings.join("");
+    if (thinking && !state.blocks.some((block) => block.type === "thinking")) {
+        state.blocks.push({ type: "thinking", thinking });
+    }
+    const text = texts.join("");
+    if (text) {
+        const lastText = [...state.blocks].reverse().find((block) => block.type === "text");
+        if (lastText?.type === "text") {
+            if (text.length >= lastText.text.length)
+                lastText.text = text;
+        }
+        else {
+            state.blocks.push({ type: "text", text });
+        }
+        if (text.length >= state.result.length)
+            state.result = text;
+    }
+    if (message.stopReason === "error") {
+        return typeof message.errorMessage === "string" ? message.errorMessage : "Pi CLI execution failed";
+    }
+    return null;
+}
 export function applyPiEvent(state, event) {
     if (event.type === "session" && typeof event.id === "string")
         state.sessionId = event.id;
@@ -54,6 +110,22 @@ export function applyPiEvent(state, event) {
             else
                 state.blocks.push({ type: "thinking", thinking: delta });
         }
+        else if (update?.type === "text_end" && typeof update.content === "string" && update.content) {
+            const last = state.blocks.at(-1);
+            if (last?.type === "text")
+                last.text = update.content;
+            else
+                state.blocks.push({ type: "text", text: update.content });
+            if (update.content.length >= state.result.length)
+                state.result = update.content;
+        }
+        else if (update?.type === "thinking_end" && typeof update.content === "string" && update.content) {
+            const last = state.blocks.at(-1);
+            if (last?.type === "thinking")
+                last.thinking = update.content;
+            else
+                state.blocks.push({ type: "thinking", thinking: update.content });
+        }
     }
     if (event.type === "tool_execution_start") {
         const id = typeof event.toolCallId === "string" ? event.toolCallId : crypto.randomUUID();
@@ -64,23 +136,19 @@ export function applyPiEvent(state, event) {
         const id = typeof event.toolCallId === "string" ? event.toolCallId : "unknown";
         state.blocks.push({ type: "tool_result", tool_use_id: id, content: textContent(event.result), is_error: event.isError === true });
     }
-    if (event.type === "message_end") {
+    if (event.type === "message_end" || event.type === "turn_end") {
         const message = record(event.message);
-        if (message?.role === "assistant") {
-            if (typeof message.model === "string")
-                state.model = message.model;
-            const usage = record(message.usage);
-            const cost = record(usage?.cost);
-            if (usage)
-                state.usage = {
-                    inputTokens: typeof usage.input === "number" ? usage.input : 0,
-                    outputTokens: typeof usage.output === "number" ? usage.output : 0,
-                    cacheReadInputTokens: typeof usage.cacheRead === "number" ? usage.cacheRead : 0,
-                    cacheCreationInputTokens: typeof usage.cacheWrite === "number" ? usage.cacheWrite : 0,
-                    totalCostUsd: typeof cost?.total === "number" ? cost.total : 0,
-                };
-            if (message.stopReason === "error")
-                return typeof message.errorMessage === "string" ? message.errorMessage : "Pi CLI execution failed";
+        if (message?.role === "assistant")
+            return applyPiAssistantMessage(state, message);
+    }
+    if (event.type === "agent_end" && Array.isArray(event.messages)) {
+        for (const raw of event.messages) {
+            const message = record(raw);
+            if (message?.role === "assistant") {
+                const error = applyPiAssistantMessage(state, message);
+                if (error)
+                    return error;
+            }
         }
     }
     return null;

package/dist/structured-qoder-adapter.js

@@ -1,11 +1,15 @@
 import { spawn } from "node:child_process";
 import { ClaudeCliProtocolReducer } from "./structured-claude-protocol.js";
 import { startStructuredCli } from "./structured-exec-pump.js";
+import { thinkingEffortToQoderEffort } from "./structured-provider-common.js";
 export function buildQoderArgs(session, prompt) {
     const args = ["-p", prompt, "--output-format", "stream-json"];
     const model = session.selectedModel?.trim();
     if (model && model !== "default")
         args.push("--model", model);
+    const effort = thinkingEffortToQoderEffort(session.thinkingEffort);
+    if (effort)
+        args.push("--reasoning-effort", effort);
     if (session.autoApprovePermissions === true
         || session.mode === "full-access"
         || session.mode === "managed") {

package/dist/terminal-daemon-client.d.ts

@@ -32,6 +32,7 @@ export declare class TerminalDaemonClient implements TerminalHost, StructuredExe
     /** Refresh the structured inventory and catch live handles up after a reconnect. */
     private refreshStructuredAfterReconnect;
     private handleFromState;
+    private deliverStructuredEvent;
     disconnect(): void;
     /**
      * Socket teardown path. Without a reconnect, a daemon restart would leave

package/dist/terminal-daemon-client.js

@@ -377,21 +377,45 @@ export class TerminalDaemonClient {
     }
     handleFromState(state, reuse) {
         this.structuredInventory.set(state.runId, state);
-        if (state.status !== "running") {
-            this.structuredHandles.delete(state.runId);
-            return reuse ?? new RemoteStructuredProcess(state.runId, state.incarnationId, state.pid, this);
-        }
         let process = this.structuredHandles.get(state.runId) ?? null;
         if (!process || process.incarnationId !== state.incarnationId) {
-            process = new RemoteStructuredProcess(state.runId, state.incarnationId, state.pid, this);
+            process = reuse && reuse.incarnationId === state.incarnationId
+                ? reuse
+                : new RemoteStructuredProcess(state.runId, state.incarnationId, state.pid, this);
+        }
+        if (state.status === "running")
             this.structuredHandles.set(state.runId, process);
-            const pending = this.pendingStructuredEvents.get(state.runId) ?? [];
-            this.pendingStructuredEvents.delete(state.runId);
-            for (const event of pending)
-                this.routeStructuredEvent(event);
+        else
+            this.structuredHandles.delete(state.runId);
+        // Events can arrive (and the child can even exit) before this RPC returns.
+        // Always drain the backlog onto THIS handle. If the run already finished,
+        // also replay daemon logs and synthesize exit so a fast Codex/Pi turn is
+        // not lost just because listeners were not attached yet.
+        const pending = this.pendingStructuredEvents.get(state.runId) ?? [];
+        this.pendingStructuredEvents.delete(state.runId);
+        for (const event of pending)
+            this.deliverStructuredEvent(process, event);
+        if (state.status !== "running") {
+            process.replayFromLogs(state);
+            process.acceptExit({ exitCode: state.exitCode, signal: state.signal });
         }
         return process;
     }
+    deliverStructuredEvent(handle, event) {
+        if (event.incarnationId !== handle.incarnationId)
+            return;
+        if (event.event === "sdata" && typeof event.data === "string" && typeof event.seq === "number") {
+            handle.acceptStream({
+                stream: event.stream === "stderr" ? "stderr" : "stdout",
+                data: event.data,
+                seq: event.seq,
+            });
+            return;
+        }
+        if (event.event === "sexit") {
+            handle.acceptExit({ exitCode: event.exitCode ?? null, signal: event.signal ?? null });
+        }
+    }
     disconnect() {
         this.disposed = true;
         if (this.reconnectTimer) {

package/dist/types.d.ts

@@ -648,11 +648,15 @@ export interface TaskWindowLayout {
     windows: WorkWindowLayout[];
     activeWindowId: string | null;
 }
+export type WorkspaceKind = "project" | "global";
+/** Hidden workspace that owns standalone tasks without a user project. */
+export declare const GLOBAL_WORKSPACE_ID = "wand-global";
 /** 项目 / 工作空间。锚定一个目录（如 wand 仓库），内含多个并行「任务」。 */
 export interface Workspace {
     id: string;
     name: string;
     cwd: string;
+    kind?: WorkspaceKind;
     defaultProvider?: WorkspaceDefaultProvider;
     /**
      * 工作空间级的布局占位（保留字段）。标签 / 分屏布局实际挂在 Task 上
@@ -674,6 +678,8 @@ export interface WorkspaceTask {
     workspaceId: string;
     name: string;
     worktree: WorkspaceTaskWorktree | null;
+    /** Optional directory override; empty/undefined falls back to the workspace cwd. */
+    cwd?: string;
     /** 该任务的工作窗口 Tabs；每个窗口内部可含一棵分屏树。 */
     layout: TaskWindowLayout | null;
     status: WorkspaceTaskStatus;

package/dist/types.js

@@ -1 +1,2 @@
-export {};
+/** Hidden workspace that owns standalone tasks without a user project. */
+export const GLOBAL_WORKSPACE_ID = "wand-global";