@co0ontty/wand 4.3.0 → 4.4.0-beta.gdcdccb2

package/dist/structured-content.d.ts

@@ -0,0 +1,5 @@
+/** Preserve both Responses content parts and arbitrary structured tool output. */
+export declare function normalizeStructuredToolResultContent(content: unknown): string | Array<{
+    type: string;
+    [key: string]: unknown;
+}>;

package/dist/structured-content.js

@@ -0,0 +1,17 @@
+/** Preserve both Responses content parts and arbitrary structured tool output. */
+export function normalizeStructuredToolResultContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = content.filter((item) => !!item && typeof item === "object" && typeof item.type === "string");
+        if (parts.length === content.length)
+            return parts;
+        try {
+            return JSON.stringify(content, null, 2);
+        }
+        catch {
+            return String(content);
+        }
+    }
+    return typeof content === "undefined" || content === null ? "" : String(content);
+}

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

@@ -1,11 +1,14 @@
-import type { ContentBlock, ConversationTurn, SessionSnapshot } from "./types.js";
-export interface OpenCodeTurnState {
-    blocks: ContentBlock[];
-    result: string;
-    sessionId: string | null;
-    usage?: ConversationTurn["usage"];
-}
+import { spawn } from "node:child_process";
+import type { StructuredRunnerAdapter, StructuredRunnerContext, StructuredRunnerExecution, StructuredRunnerObserver, StructuredRunnerTurnState } from "./structured-runner.js";
+import type { SessionSnapshot } from "./types.js";
+export type OpenCodeTurnState = StructuredRunnerTurnState;
 export declare function buildOpenCodeArgs(session: SessionSnapshot): string[];
 export declare function openCodeToolName(name: string): string;
 /** Apply one OpenCode NDJSON event to the current transport-neutral turn state. */
 export declare function applyOpenCodeEvent(turnState: OpenCodeTurnState, event: Record<string, unknown>, createId?: () => string): string | null;
+/** Production adapter for the external `opencode run --format json` process. */
+export declare class OpenCodeRunner implements StructuredRunnerAdapter {
+    private readonly spawnProcess;
+    constructor(spawnProcess?: typeof spawn);
+    start(context: StructuredRunnerContext, observer: StructuredRunnerObserver): StructuredRunnerExecution;
+}

package/dist/structured-opencode-adapter.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
 import { thinkingEffortToOpenCodeVariant } from "./structured-provider-common.js";
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
@@ -113,3 +114,105 @@ export function applyOpenCodeEvent(turnState, event, createId = randomUUID) {
     }
     return null;
 }
+/** Production adapter for the external `opencode run --format json` process. */
+export class OpenCodeRunner {
+    spawnProcess;
+    constructor(spawnProcess = spawn) {
+        this.spawnProcess = spawnProcess;
+    }
+    start(context, observer) {
+        const args = buildOpenCodeArgs(context.session);
+        const spawnedAt = new Date().toISOString();
+        const child = this.spawnProcess("opencode", args, {
+            cwd: context.session.cwd,
+            env: context.env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        child.stdin?.end(context.prompt);
+        const state = {
+            blocks: [],
+            result: "",
+            sessionId: context.session.claudeSessionId,
+            model: context.session.selectedModel ?? context.session.structuredState?.model,
+            usage: undefined,
+        };
+        let lineBuffer = "";
+        let stderr = "";
+        let primaryError = null;
+        let settled = false;
+        const result = (exitCode, signal, spawnError) => ({
+            state,
+            exitCode,
+            signal,
+            stderr,
+            primaryError,
+            ...(spawnError ? { spawnError } : {}),
+        });
+        const processLine = (line) => {
+            if (!observer.isActive())
+                return;
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            let event;
+            try {
+                event = JSON.parse(trimmed);
+            }
+            catch {
+                return;
+            }
+            observer.onEvent?.(event);
+            const error = applyOpenCodeEvent(state, event);
+            if (error)
+                primaryError = error;
+            observer.onUpdate(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-runner.d.ts

@@ -0,0 +1,42 @@
+import type { ContentBlock, ConversationTurn, SessionSnapshot } from "./types.js";
+export interface StructuredRunnerTurnState {
+    blocks: ContentBlock[];
+    result: string;
+    sessionId: string | null;
+    model?: string;
+    usage?: ConversationTurn["usage"];
+}
+export interface StructuredRunnerContext {
+    session: SessionSnapshot;
+    prompt: string;
+    env: NodeJS.ProcessEnv;
+}
+export interface StructuredRunnerObserver {
+    isActive(): boolean;
+    onStdout?(text: string): void;
+    onStderr?(text: string): void;
+    onEvent?(event: Record<string, unknown>): void;
+    onUpdate(state: StructuredRunnerTurnState): void;
+}
+export interface StructuredRunnerResult {
+    state: StructuredRunnerTurnState;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    stderr: string;
+    primaryError: string | null;
+    errors?: string[];
+    stdoutTail?: string;
+    stopReason?: "ask-user-question";
+    spawnError?: NodeJS.ErrnoException;
+}
+export interface StructuredRunnerExecution {
+    args: string[];
+    spawnedAt: string;
+    pid: number | null;
+    completion: Promise<StructuredRunnerResult>;
+    /** Idempotent, best-effort, and never throws. Completion must still settle. */
+    interrupt(): void;
+}
+export interface StructuredRunnerAdapter {
+    start(context: StructuredRunnerContext, observer: StructuredRunnerObserver): StructuredRunnerExecution;
+}

package/dist/structured-runner.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,8 +1,14 @@
 import { query as sdkQuery } from "@anthropic-ai/claude-agent-sdk";
 import { SessionLogger } from "./session-logger.js";
 import { WandStorage } from "./storage.js";
-import { ContentBlock, ExecutionMode, ProcessEvent, SessionProvider, SessionRunner, SessionSnapshot, SessionSource, WandConfig } from "./types.js";
+import { ExecutionMode, ProcessEvent, SessionProvider, SessionRunner, SessionSnapshot, SessionSource, WandConfig } from "./types.js";
+import type { StructuredRunnerAdapter } from "./structured-runner.js";
 export { isStructuredRunnerForProvider, normalizeThinkingEffort, resolveStructuredRunner, thinkingEffortToClaudeCliEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToOpenCodeVariant, thinkingEffortToSdkBudget, } from "./structured-provider-common.js";
+export interface StructuredSessionManagerRunners {
+    claudeCli?: StructuredRunnerAdapter;
+    codex?: StructuredRunnerAdapter;
+    opencode?: StructuredRunnerAdapter;
+}
 interface CreateStructuredSessionOptions {
     cwd: string;
     mode: ExecutionMode;
@@ -23,29 +29,6 @@ interface CreateStructuredSessionOptions {
      */
     claudeSessionId?: string;
 }
-/**
- * Preserve both Responses content-part arrays and arbitrary structured tool output.
- * Arrays without a `type` discriminator (for example Codex tool_search results)
- * are serialized instead of being filtered to an empty result.
- */
-export declare function normalizeStructuredToolResultContent(content: unknown): string | Array<{
-    type: string;
-    [key: string]: unknown;
-}>;
-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;
 /**
  * 返回最近一次真正提交给结构化会话的用户输入。
  *
@@ -62,7 +45,7 @@ export declare class StructuredSessionManager {
     private readonly logger;
     private readonly sdkQueryFactory;
     private readonly sessions;
-    private readonly pendingChildren;
+    private readonly pendingRunnerExecutions;
     private readonly pendingSdkAbort;
     /**
      * Active SDK Query handle per session, kept around so we can call
@@ -95,8 +78,11 @@ export declare class StructuredSessionManager {
     private archiveTimer;
     private readonly topicRequests;
     private readonly streamEmitTimers;
+    private readonly claudeCliRunner;
+    private readonly codexRunner;
+    private readonly openCodeRunner;
     private disposed;
-    constructor(storage: WandStorage, config: WandConfig, logger?: SessionLogger | null, sdkQueryFactory?: typeof sdkQuery);
+    constructor(storage: WandStorage, config: WandConfig, logger?: SessionLogger | null, sdkQueryFactory?: typeof sdkQuery, runners?: StructuredSessionManagerRunners);
     private archiveExpiredSessions;
     setEventEmitter(emitEvent: (event: ProcessEvent) => void): void;
     /** Stop every runner and flush terminal state before storage is closed. */
@@ -173,7 +159,7 @@ export declare class StructuredSessionManager {
     private isCurrentRequest;
     private currentSessionForRequest;
     /** Delete a handle only if it still belongs to the execution doing cleanup. */
-    private releasePendingChild;
+    private releasePendingRunnerExecution;
     private releasePendingSdkAbort;
     private releasePendingSdkQuery;
     private emitStructuredSnapshot;
@@ -205,58 +191,10 @@ export declare class StructuredSessionManager {
      * SDKAssistantMessage with the authoritative complete content.
      */
     private runClaudeSdkStreaming;
-    private extractAssistantMessage;
     private compactContentBlocks;
     private buildCompletedAssistantMessages;
     private resolveQueuedMessagesAfterInterrupt;
-    private normalizeToolInput;
     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;
     /**
      * 组装结构化 runner 退出失败时的可读错误字符串。
      *
@@ -269,9 +207,6 @@ export declare class StructuredSessionManager {
      */
     private formatStructuredExitError;
     private finishStructuredFailure;
-    private extractModelName;
-    private extractUsage;
     /** Extract usage from an SDKResultSuccess message (sdk runner). */
     private extractSdkUsage;
-    private extractCodexUsage;
 }