@co0ontty/wand 4.3.0 → 4.4.0-beta.gdcdccb2

package/dist/structured-claude-protocol.js

@@ -0,0 +1,246 @@
+import { normalizeStructuredToolResultContent } from "./structured-content.js";
+export function captureTaskMeta(blocks, registry) {
+    for (const block of blocks) {
+        if (block.type !== "tool_use" || registry.has(block.id))
+            continue;
+        const input = block.input ?? {};
+        const agentType = typeof input.subagent_type === "string" ? input.subagent_type : undefined;
+        if (!agentType && block.name !== "Task" && block.name !== "Agent")
+            continue;
+        const description = typeof input.description === "string" ? input.description : undefined;
+        registry.set(block.id, { agentType, description });
+    }
+}
+export function tagSubagentBlocks(blocks, parentToolUseId, registry) {
+    if (!parentToolUseId)
+        return blocks;
+    const meta = registry.get(parentToolUseId);
+    const stamp = {
+        taskId: parentToolUseId,
+        ...(meta?.agentType ? { agentType: meta.agentType } : {}),
+        ...(meta?.description ? { taskDescription: meta.description } : {}),
+    };
+    return blocks.map((block) => ({ ...block, __subagent: stamp }));
+}
+export function stampSelfTask(blocks, registry) {
+    return blocks.map((block) => {
+        if (block.type !== "tool_use" || block.__subagent)
+            return block;
+        const meta = registry.get(block.id);
+        if (!meta && block.name !== "Task" && block.name !== "Agent")
+            return block;
+        const stamp = {
+            taskId: block.id,
+            ...(meta?.agentType ? { agentType: meta.agentType } : {}),
+            ...(meta?.description ? { taskDescription: meta.description } : {}),
+        };
+        return { ...block, __subagent: stamp };
+    });
+}
+export function stampParentTaskResults(blocks, registry) {
+    return blocks.map((block) => {
+        if (block.type !== "tool_result" || block.__subagent)
+            return block;
+        const meta = registry.get(block.tool_use_id);
+        if (!meta)
+            return block;
+        const stamp = {
+            taskId: block.tool_use_id,
+            ...(meta.agentType ? { agentType: meta.agentType } : {}),
+            ...(meta.description ? { taskDescription: meta.description } : {}),
+        };
+        return { ...block, __subagent: stamp };
+    });
+}
+export function normalizeClaudeToolInput(name, input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return {};
+    const record = input;
+    const field = name === "TodoWrite" ? "todos" : name === "AskUserQuestion" ? "questions" : undefined;
+    if (field && typeof record[field] === "string") {
+        try {
+            const parsed = JSON.parse(record[field]);
+            if (Array.isArray(parsed))
+                record[field] = parsed;
+        }
+        catch { /* Preserve malformed provider data verbatim. */ }
+    }
+    return record;
+}
+export function extractClaudeUsage(source) {
+    if (!source || !source.usage || typeof source.usage !== "object")
+        return undefined;
+    const usage = source.usage;
+    const value = {
+        inputTokens: typeof usage.input_tokens === "number" ? usage.input_tokens : undefined,
+        outputTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : undefined,
+        cacheReadInputTokens: typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : undefined,
+        cacheCreationInputTokens: typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : undefined,
+        totalCostUsd: typeof source.total_cost_usd === "number" ? source.total_cost_usd : undefined,
+    };
+    return Object.values(value).every((entry) => entry === undefined) ? undefined : value;
+}
+export function extractClaudeModelName(modelUsage) {
+    return modelUsage ? Object.keys(modelUsage)[0] : undefined;
+}
+export function extractClaudeAssistantMessage(message) {
+    const rawContent = Array.isArray(message.content) ? message.content : [];
+    const content = [];
+    for (const rawBlock of rawContent) {
+        if (!rawBlock || typeof rawBlock !== "object")
+            continue;
+        const block = rawBlock;
+        if (block.type === "text" && typeof block.text === "string") {
+            content.push({ type: "text", text: block.text });
+        }
+        else if (block.type === "thinking" && typeof block.thinking === "string") {
+            content.push({ type: "thinking", thinking: block.thinking });
+        }
+        else if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+            content.push({
+                type: "tool_use",
+                id: block.id,
+                name: block.name,
+                description: typeof block.description === "string" ? block.description : undefined,
+                input: normalizeClaudeToolInput(block.name, block.input),
+            });
+        }
+    }
+    return { content, usage: extractClaudeUsage({ usage: message.usage }) };
+}
+export class ClaudeCliProtocolReducer {
+    state;
+    askUserQuestionDetected = false;
+    blocksByKey = new Map();
+    keyOrder = [];
+    taskMetaRegistry = new Map();
+    toolResultSequence = 0;
+    constructor(session) {
+        this.state = { blocks: [], result: "", sessionId: session.claudeSessionId, model: undefined, usage: undefined };
+    }
+    apply(parsed, managed) {
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return false;
+        const event = parsed;
+        if (typeof event.session_id === "string" && event.session_id)
+            this.state.sessionId = event.session_id;
+        if (event.type === "assistant" && event.message && typeof event.message === "object") {
+            const message = event.message;
+            const extracted = extractClaudeAssistantMessage(message);
+            const key = typeof message.id === "string" && message.id
+                ? `assistant:${message.id}`
+                : `assistant:anon:${this.keyOrder.length}`;
+            const parentId = typeof event.parent_tool_use_id === "string" && event.parent_tool_use_id
+                ? event.parent_tool_use_id
+                : null;
+            if (parentId === null)
+                captureTaskMeta(extracted.content, this.taskMetaRegistry);
+            const stamped = parentId === null
+                ? stampSelfTask(extracted.content, this.taskMetaRegistry)
+                : tagSubagentBlocks(extracted.content, parentId, this.taskMetaRegistry);
+            if (stamped.length > 0)
+                this.upsertBlocks(key, stamped);
+            if (!managed && extracted.content.some((block) => block.type === "tool_use" && block.name === "AskUserQuestion")) {
+                this.askUserQuestionDetected = true;
+            }
+            return true;
+        }
+        if (event.type === "user" && event.message && typeof event.message === "object") {
+            const content = event.message.content;
+            if (!Array.isArray(content))
+                return true;
+            const collected = [];
+            for (const rawBlock of content) {
+                if (!rawBlock || typeof rawBlock !== "object")
+                    continue;
+                const block = rawBlock;
+                if (block.type !== "tool_result")
+                    continue;
+                collected.push({
+                    type: "tool_result",
+                    tool_use_id: typeof block.tool_use_id === "string" ? block.tool_use_id : "",
+                    content: normalizeStructuredToolResultContent(block.content),
+                    is_error: block.is_error === true,
+                });
+            }
+            const parentId = typeof event.parent_tool_use_id === "string" && event.parent_tool_use_id
+                ? event.parent_tool_use_id
+                : null;
+            const stamped = parentId === null
+                ? stampParentTaskResults(collected, this.taskMetaRegistry)
+                : tagSubagentBlocks(collected, parentId, this.taskMetaRegistry);
+            if (stamped.length > 0)
+                this.upsertBlocks(`tool_result:${this.toolResultSequence++}`, stamped);
+            return true;
+        }
+        if (event.type === "result") {
+            if (typeof event.result === "string")
+                this.state.result = event.result.trim();
+            this.state.model = extractClaudeModelName(event.modelUsage && typeof event.modelUsage === "object"
+                ? event.modelUsage
+                : undefined) ?? this.state.model;
+            this.state.usage = extractClaudeUsage(event) ?? this.state.usage;
+            return true;
+        }
+        return typeof event.session_id === "string";
+    }
+    blockVolume(block) {
+        if (!block)
+            return 0;
+        let total = 0;
+        if (block.type === "text")
+            total += block.text.length;
+        if (block.type === "thinking")
+            total += block.thinking.length;
+        if (block.type === "tool_result" && typeof block.content === "string")
+            total += block.content.length;
+        if (block.type === "tool_use") {
+            try {
+                total += JSON.stringify(block.input).length;
+            }
+            catch { /* best effort */ }
+        }
+        return total;
+    }
+    upsertBlocks(key, blocks) {
+        const previous = this.blocksByKey.get(key);
+        if (!previous) {
+            this.keyOrder.push(key);
+            this.blocksByKey.set(key, blocks);
+            this.rebuildBlocks();
+            return;
+        }
+        const cumulative = blocks.length >= previous.length
+            && previous.every((block, index) => !blocks[index] || block.type === blocks[index].type);
+        if (cumulative) {
+            this.blocksByKey.set(key, blocks.map((block, index) => this.blockVolume(block) >= this.blockVolume(previous[index]) ? block : previous[index]));
+            this.rebuildBlocks();
+            return;
+        }
+        const merged = [...previous];
+        for (const block of blocks) {
+            if (block.type === "tool_use") {
+                const index = merged.findIndex((entry) => entry.type === "tool_use" && entry.id === block.id);
+                if (index < 0)
+                    merged.push(block);
+                else if (this.blockVolume(block) >= this.blockVolume(merged[index]))
+                    merged[index] = block;
+            }
+            else if (block.type === "tool_result") {
+                merged.push(block);
+            }
+            else {
+                const duplicate = block.type === "text"
+                    ? merged.some((entry) => entry.type === "text" && entry.text === block.text)
+                    : merged.some((entry) => entry.type === "thinking" && entry.thinking === block.thinking);
+                if (!duplicate)
+                    merged.push(block);
+            }
+        }
+        this.blocksByKey.set(key, merged);
+        this.rebuildBlocks();
+    }
+    rebuildBlocks() {
+        this.state.blocks = this.keyOrder.flatMap((key) => this.blocksByKey.get(key) ?? []);
+    }
+}

package/dist/structured-codex-adapter.d.ts

@@ -1,3 +1,8 @@
 import type { SessionSnapshot } from "./types.js";
+import type { StructuredRunnerAdapter, StructuredRunnerContext, StructuredRunnerExecution, StructuredRunnerObserver } from "./structured-runner.js";
 /** Build the stable CLI contract for a structured Codex turn. */
 export declare function buildCodexArgs(session: SessionSnapshot): string[];
+/** Owns the Codex CLI process and translates its NDJSON protocol into runner-neutral state. */
+export declare class CodexRunner implements StructuredRunnerAdapter {
+    start(context: StructuredRunnerContext, observer: StructuredRunnerObserver): StructuredRunnerExecution;
+}

package/dist/structured-codex-adapter.js

@@ -1,3 +1,5 @@
+import { spawn } from "node:child_process";
+import { CodexProtocolReducer } from "./structured-codex-protocol.js";
 import { thinkingEffortToCodexReasoningEffort } from "./structured-provider-common.js";
 /** Build the stable CLI contract for a structured Codex turn. */
 export function buildCodexArgs(session) {
@@ -27,3 +29,95 @@ export function buildCodexArgs(session) {
         args.push("-");
     return args;
 }
+/** Owns the Codex CLI process and translates its NDJSON protocol into runner-neutral state. */
+export class CodexRunner {
+    start(context, observer) {
+        const args = buildCodexArgs(context.session);
+        const spawnedAt = new Date().toISOString();
+        const child = spawn("codex", args, {
+            cwd: context.session.cwd,
+            env: context.env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        child.stdin?.end(context.prompt);
+        const reducer = new CodexProtocolReducer(context.session);
+        let lineBuffer = "";
+        let stderr = "";
+        let settled = false;
+        const result = (exitCode, signal, spawnError) => ({
+            state: reducer.state,
+            exitCode,
+            signal,
+            stderr,
+            primaryError: reducer.primaryError,
+            errors: reducer.errors,
+            spawnError,
+        });
+        const processLine = (line) => {
+            if (!observer.isActive())
+                return;
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            let event;
+            try {
+                event = JSON.parse(trimmed);
+            }
+            catch {
+                return;
+            }
+            if (event && typeof event === "object" && !Array.isArray(event)) {
+                observer.onEvent?.(event);
+            }
+            if (reducer.apply(event))
+                observer.onUpdate(reducer.state);
+        };
+        const completion = new Promise((resolve) => {
+            child.stdout?.on("data", (chunk) => {
+                if (!observer.isActive())
+                    return;
+                const text = chunk.toString();
+                observer.onStdout?.(text);
+                lineBuffer += text;
+                const lines = lineBuffer.split("\n");
+                lineBuffer = lines.pop() ?? "";
+                for (const line of lines)
+                    processLine(line);
+            });
+            child.stderr?.on("data", (chunk) => {
+                if (!observer.isActive())
+                    return;
+                const text = chunk.toString();
+                observer.onStderr?.(text);
+                stderr += text;
+            });
+            child.on("error", (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(result(null, null, error));
+            });
+            child.on("close", (exitCode, signal) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (lineBuffer.trim())
+                    processLine(lineBuffer);
+                lineBuffer = "";
+                resolve(result(exitCode, signal));
+            });
+        });
+        return {
+            args,
+            spawnedAt,
+            pid: child.pid ?? null,
+            completion,
+            interrupt: () => {
+                try {
+                    child.kill("SIGTERM");
+                }
+                catch { /* best-effort external interruption */ }
+            },
+        };
+    }
+}

package/dist/structured-codex-protocol.d.ts

@@ -0,0 +1,78 @@
+import type { ContentBlock, SessionSnapshot } from "./types.js";
+import type { StructuredRunnerTurnState } from "./structured-runner.js";
+export declare function buildCodexPatchApplyBlocks(item: Record<string, unknown>): ContentBlock[];
+export interface CodexFileSnapshot {
+    exists: boolean;
+    text: string | null;
+    unavailableReason?: string;
+}
+type CodexFileSnapshotMap = Map<string, CodexFileSnapshot>;
+export declare function buildCodexFileChangeBlocks(item: Record<string, unknown>, completed: boolean, beforeSnapshots?: CodexFileSnapshotMap, afterSnapshots?: CodexFileSnapshotMap): ContentBlock[];
+/**
+ * Codex `exec --json` only publishes authoritative usage with `turn.completed`.
+ * Keep the bottom usage row useful while the turn is running by estimating the
+ * model-produced text/tool arguments; the final provider value replaces this.
+ */
+export declare function estimateCodexOutputTokens(blocks: ContentBlock[]): number;
+interface CodexTurnState extends StructuredRunnerTurnState {
+    codexBlockIndex: Map<string, number>;
+    codexFileSnapshots: CodexFileSnapshotMap;
+    cwd: string;
+}
+export declare class CodexProtocolReducer {
+    readonly state: CodexTurnState;
+    readonly errors: string[];
+    primaryError: string | null;
+    constructor(session: SessionSnapshot);
+    apply(parsed: unknown): boolean;
+    private refreshUsage;
+    private normalizeToolResultContent;
+    private unwrapCodexStreamEvent;
+    private applyCodexLooseEvent;
+    private codexFunctionToolUse;
+    private codexMcpToolBlocks;
+    private extractCodexText;
+    /**
+     * Merge one codex `item.*` event into `turnState.blocks`.
+     *
+     * 三种 phase 行为：
+     *   - "started":   首次出现的 item，块直接 push（tool_result 走 upsert 配对）。
+     *                  text/thinking/TodoWrite 这种"靠 id 替换"的块记录到
+     *                  codexBlockIndex 里，方便后续 updated/completed 找回原位。
+     *   - "updated":   codex 重发完整 ThreadItem（不是 delta）。已记录过的块就
+     *                  替换；新块按 started 路径处理。
+     *   - "completed": 把"in_progress"卡片定型——text 同时更新 turnState.result
+     *                  以便 result fallback 不为空；tool_use ↔ tool_result 通过
+     *                  共享 id 配对到一起（包括 file_change 子项的 `${id}#i`）。
+     */
+    private applyCodexItem;
+    /**
+     * Map a codex `item.{started,updated,completed}` payload into wand's
+     * `ContentBlock[]` so the chat UI's existing tool/diff/todo cards just work.
+     *
+     * Codex `exec --json` emits 8 item.type values (see
+     * `codex-rs/exec/src/exec_events.rs`); below they're routed to whatever wand
+     * tool name reuses an existing renderer:
+     *
+     *   agent_message     → text
+     *   reasoning         → thinking
+     *   command_execution → tool_use "Bash" + tool_result
+     *   file_change       → one Edit/Write per file; snapshots taken between
+     *                       item.started/completed restore the omitted diff body
+     *   mcp_tool_call     → tool_use named "<server>__<tool>" + tool_result
+     *   web_search        → tool_use "WebSearch" + tool_result (results not in stream)
+     *   todo_list         → tool_use "TodoWrite" (replaced in place on each update)
+     *   error             → text block prefixed with ❌
+     *
+     * Returns [] when there is nothing to emit yet (e.g. agent_message at
+     * `item.started` before any text has been produced).
+     *
+     * Callers handle in-place replacement for `item.updated` via
+     * `turnState.codexBlockIndex`; tool_use ↔ tool_result pairing still goes
+     * through `upsertCodexBlock` by matching ids.
+     */
+    private extractCodexItemBlock;
+    private upsertCodexBlock;
+    private extractCodexUsage;
+}
+export {};