@co0ontty/wand 4.82.0 → 4.83.1

package/dist/structured-session-manager.js

@@ -7,6 +7,7 @@ import { getErrorMessage } from "./error-utils.js";
 import { getDefaultModelForProvider } from "./config.js";
 import { recordIterationPrompt } from "./iteration-log.js";
 import { startEmployeeKnowledgeRunner } from "./employee-knowledge.js";
+import { withDecisionAccess } from "./decision-runner.js";
 import { signalNameFromNumber } from "./signal-utils.js";
 import { provisionalSessionTopic, SessionNativeTitleTracker, SessionTopicCoordinator, sessionTopicBlocklistForSnapshot, shouldAcceptGeneratedSessionTitle, shouldGenerateSessionTopicFromInput, } from "./session-topic.js";
 import { resolveSessionCwd } from "./session-cwd.js";
@@ -26,6 +27,7 @@ import { GeminiRunner, applyGeminiEvent, isMissingGeminiSession } from "./struct
 import { structuredRunId, } from "./structured-exec-host.js";
 import { defaultStructuredRunner, defaultStructuredState, isStructuredRunnerForProvider, normalizeThinkingEffort, resolveStructuredRunner, } from "./structured-provider-common.js";
 import { enrichStructuredMessages, WAND_PROTOCOL_VERSION } from "./structured-client-protocol.js";
+import { RETENTION_IDLE_MS } from "./retention.js";
 class PersistedStructuredRunnerError extends Error {
     constructor(message) {
         super(message);
@@ -158,7 +160,7 @@ const STREAM_EMIT_DEBOUNCE_MS = 16;
 // second on the event loop.
 const STREAM_SAVE_THROTTLE_MS = 1_000;
 const DETACHED_RECOVERY_RETRY_MS = 500;
-const ARCHIVE_AFTER_MS = 1000 * 60 * 60 * 24;
+const ARCHIVE_AFTER_MS = RETENTION_IDLE_MS;
 /**
  * 找出最后一条 assistant turn 中尚未配对 tool_result 的 AskUserQuestion tool_use。
  * 用来识别"刚被 SIGTERM 中断、正在等用户提交答案"的状态。
@@ -400,7 +402,11 @@ export class StructuredSessionManager {
     logger;
     execHost;
     sessions = new Map();
+    // Both freshly started runners and adopted daemon runs own the same input gate.
     pendingRunnerExecutions = new Map();
+    // Server-only, one-shot execution UUIDs. Actual request lifecycle clears them; metadata updates do not.
+    // Never persisted or included in session DTOs.
+    unacceptedTeamStarts = new Map();
     interruptedWith = new Map();
     preserveQueueOnInterrupt = new Set();
     /** Last wall-clock time (ms) a streaming checkpoint reached SQLite. */
@@ -434,18 +440,19 @@ export class StructuredSessionManager {
     detachedRecoveryRetryTimer = null;
     detachedRecoveryFailureLogged = false;
     disposed = false;
-    constructor(storage, config, logger = null, runners = {}, execHost) {
+    constructor(storage, config, logger = null, runners = {}, execHost, decisionRuntime = () => null) {
         this.storage = storage;
         this.config = config;
         this.logger = logger;
         this.execHost = execHost;
-        this.claudeCliRunner = runners.claudeCli ?? new ClaudeCliRunner({ language: () => this.config.language }, this.execHost);
-        this.codexRunner = runners.codex ?? new CodexRunner(undefined, this.execHost);
-        this.openCodeRunner = runners.opencode ?? new OpenCodeRunner(undefined, this.execHost);
-        this.grokRunner = runners.grok ?? new GrokRunner(undefined, this.execHost);
-        this.qoderRunner = runners.qoder ?? new QoderRunner(undefined, this.execHost);
-        this.piRunner = runners.pi ?? new PiRunner(undefined, this.execHost);
-        this.geminiRunner = runners.gemini ?? new GeminiRunner(undefined, this.execHost);
+        const wrap = (runner) => withDecisionAccess(runner, storage, decisionRuntime);
+        this.claudeCliRunner = wrap(runners.claudeCli ?? new ClaudeCliRunner({ language: () => this.config.language }, this.execHost));
+        this.codexRunner = wrap(runners.codex ?? new CodexRunner(undefined, this.execHost));
+        this.openCodeRunner = wrap(runners.opencode ?? new OpenCodeRunner(undefined, this.execHost));
+        this.grokRunner = wrap(runners.grok ?? new GrokRunner(undefined, this.execHost));
+        this.qoderRunner = wrap(runners.qoder ?? new QoderRunner(undefined, this.execHost));
+        this.piRunner = wrap(runners.pi ?? new PiRunner(undefined, this.execHost));
+        this.geminiRunner = wrap(runners.gemini ?? new GeminiRunner(undefined, this.execHost));
         for (const snapshot of this.storage.loadSessions()) {
             if ((snapshot.sessionKind ?? "pty") !== "structured")
                 continue;
@@ -532,6 +539,7 @@ export class StructuredSessionManager {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.unacceptedTeamStarts.clear();
         if (this.archiveTimer) {
             clearInterval(this.archiveTimer);
             this.archiveTimer = null;
@@ -635,13 +643,16 @@ export class StructuredSessionManager {
             this.scheduleDetachedRecovery();
             return;
         }
-        const ids = this.pendingRecoveryIds;
-        this.pendingRecoveryIds = [];
+        if (this.disposed)
+            return;
+        const ids = [...this.pendingRecoveryIds];
         const byRunId = new Map(runs.map((run) => [run.runId, run]));
         for (const sessionId of ids) {
             const session = this.sessions.get(sessionId);
-            if (!session)
+            if (!session) {
+                this.pendingRecoveryIds = this.pendingRecoveryIds.filter((id) => id !== sessionId);
                 continue;
+            }
             const state = byRunId.get(structuredRunId(sessionId));
             if (!state) {
                 // Inventory was read successfully, so this is a genuinely lost run,
@@ -661,16 +672,20 @@ export class StructuredSessionManager {
                 this.sessions.set(sessionId, interrupted);
                 this.saveAuthoritativeSession(interrupted);
                 this.emitStructuredSnapshot(interrupted);
+                this.pendingRecoveryIds = this.pendingRecoveryIds.filter((id) => id !== sessionId);
                 continue;
             }
             try {
                 // listRuns is metadata-only on Render v2. Fetch the authoritative
                 // paged replay from the owner before feeding any provider reducer.
                 const attached = await this.execHost.attachRun(state.runId);
+                if (this.disposed)
+                    return;
                 if (!attached || attached.incarnationId !== state.incarnationId) {
                     throw new Error("Structured run changed owner between inventory and replay");
                 }
-                await this.resumeDetachedRun(session, attached);
+                await this.resumeDetachedRun(this.requireSession(sessionId), attached);
+                this.pendingRecoveryIds = this.pendingRecoveryIds.filter((id) => id !== sessionId);
             }
             catch (error) {
                 console.error(`[WAND] structured run recovery failed for ${sessionId}:`, error);
@@ -692,9 +707,20 @@ export class StructuredSessionManager {
     }
     async resumeDetachedRun(snapshot, initialState) {
         const sessionId = snapshot.id;
-        if (!this.execHost || !snapshot.structuredState)
+        if (this.disposed || !this.execHost || !snapshot.structuredState)
             return;
         const requestId = `recover-${initialState.incarnationId}`;
+        let runningHandle = null;
+        let interruptRequested = false;
+        const execution = {
+            interrupt: () => {
+                interruptRequested = true;
+                runningHandle?.interrupt();
+            },
+        };
+        // Reserve ownership before publishing inFlight or awaiting adoption. Inputs
+        // arriving during replay/attach must queue just like inputs to a fresh runner.
+        this.pendingRunnerExecutions.set(sessionId, execution);
         // Re-arm the in-flight marker so UI and request guards treat the resumed
         // turn like any other streaming turn.
         const resumed = {
@@ -800,7 +826,6 @@ export class StructuredSessionManager {
                 runningHandle.interrupt();
             }
         };
-        let runningHandle = null;
         let lastStdoutSeq = initialState.stdoutSeq;
         let lastStderrSeq = initialState.stderrSeq;
         const feedLine = (line) => {
@@ -843,7 +868,22 @@ export class StructuredSessionManager {
             for (const line of lines)
                 feedLine(line);
         }
-        runningHandle = await this.execHost.adoptRun(structuredRunId(sessionId));
+        try {
+            runningHandle = await this.execHost.adoptRun(structuredRunId(sessionId));
+        }
+        catch (error) {
+            this.releasePendingRunnerExecution(sessionId, execution, false);
+            throw error;
+        }
+        // Server shutdown detaches persistent runs; only an explicit stop/delete
+        // should cancel a handle that arrived after its request was invalidated.
+        if (this.disposed)
+            return;
+        if (!this.isCurrentRequest(sessionId, requestId)) {
+            runningHandle?.interrupt();
+            this.releasePendingRunnerExecution(sessionId, execution);
+            return;
+        }
         if (!runningHandle) {
             // Run vanished between listing and adoption; fall back to failure notes.
             this.finalizeRecoveredRun(sessionId, requestId, processor, replayView, {
@@ -891,11 +931,18 @@ export class StructuredSessionManager {
             });
             flushEmit();
         });
+        // Install exit listeners before delivering an interrupt that arrived during adopt.
+        if (interruptRequested)
+            runningHandle.interrupt();
     }
     finalizeRecoveredRun(sessionId, requestId, processor, replayView, outcome) {
-        this.execHost?.forgetRun(structuredRunId(sessionId));
         if (!this.isCurrentRequest(sessionId, requestId))
             return;
+        const execution = this.pendingRunnerExecutions.get(sessionId);
+        if (execution)
+            this.releasePendingRunnerExecution(sessionId, execution);
+        else
+            this.execHost?.forgetRun(structuredRunId(sessionId));
         const current = this.sessions.get(sessionId);
         if (!current)
             return;
@@ -907,7 +954,8 @@ export class StructuredSessionManager {
         const failedExit = outcome.lost
             || (outcome.exitCode !== null && outcome.exitCode !== 0)
             || outcome.signal !== null;
-        if ((processor.primaryError || failedExit) && !interruptedForQuestion) {
+        const interruptPrompt = this.interruptedWith.get(sessionId);
+        if ((processor.primaryError || failedExit) && !interruptedForQuestion && !interruptPrompt) {
             const errorText = outcome.lost
                 ? "服务重启后运行进程已丢失，本轮未能完成。"
                 : this.formatStructuredExitError(commandLabel, outcome.exitCode, outcome.signal, {
@@ -923,7 +971,7 @@ export class StructuredSessionManager {
             this.emitStructuredSnapshot(failed, "ended");
             return;
         }
-        const keepRunning = interruptedForQuestion;
+        const keepRunning = interruptedForQuestion || !!interruptPrompt;
         const messages = replayTruncated
             ? this.mergeTruncatedReplayTurn(current, processor, replayView, !keepRunning)
             : this.buildCompletedAssistantMessages(current, processor.state, false);
@@ -936,6 +984,7 @@ export class StructuredSessionManager {
             output: replayTruncated ? current.output || processor.state.result : processor.state.result,
             claudeSessionId: processor.state.sessionId ?? current.claudeSessionId,
             messages,
+            queuedMessages: this.resolveQueuedMessagesAfterInterrupt(sessionId, current, interruptPrompt),
             pendingEscalation: null,
             permissionBlocked: false,
             structuredState: {
@@ -952,7 +1001,16 @@ export class StructuredSessionManager {
         this.emitStructuredSnapshot(finished);
         if (!keepRunning)
             this.emitStructuredSnapshot(finished, "ended");
-        if ((finished.queuedMessages?.length ?? 0) > 0) {
+        if (interruptPrompt) {
+            this.interruptedWith.delete(sessionId);
+            this.preserveQueueOnInterrupt.delete(sessionId);
+            setImmediate(() => {
+                this.sendMessage(sessionId, interruptPrompt).catch((error) => {
+                    console.error("[WAND] recovered interrupt-and-send failed:", error);
+                });
+            });
+        }
+        else if ((finished.queuedMessages?.length ?? 0) > 0) {
             setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
         }
     }
@@ -1067,6 +1125,20 @@ export class StructuredSessionManager {
         this.emitStructuredSnapshot(updated);
         return updated;
     }
+    /** 归档 / 取消归档：只写标记并广播，不中断运行中的 run，也不删历史。 */
+    setSessionArchived(id, archived) {
+        const current = this.requireSession(id);
+        const archivedAt = archived ? new Date().toISOString() : null;
+        const updated = { ...current, archived, archivedAt };
+        this.sessions.set(id, updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
+        this.emit({
+            type: "status",
+            sessionId: id,
+            data: { archived, archivedAt, sessionKind: "structured" },
+        });
+        return updated;
+    }
     setSessionTopicGenerating(id, titleGenerating) {
         const current = this.sessions.get(id);
         if (!current || current.titleGenerating === titleGenerating)
@@ -1256,12 +1328,39 @@ export class StructuredSessionManager {
         this.emitStructuredSnapshot(titled);
         return titled;
     }
+    /** Server-only generation anchor, including a failed unaccepted turn whose activeRequestId is cleared. */
+    teamRequestId(id) {
+        if (this.disposed)
+            return null;
+        const session = this.sessions.get(id);
+        if (!session?.automationId?.startsWith("ai-team:"))
+            return null;
+        const failed = this.unacceptedTeamStarts.get(id);
+        return session.structuredState?.activeRequestId
+            ?? (session.status === "failed" && !session.structuredState?.inFlight ? failed?.requestId ?? null : null);
+    }
+    /** Consume only the exact failed request observed by the team's dispatch, never error-text inference. */
+    consumeUnacceptedTeamStartup(id, requestId) {
+        const fact = this.unacceptedTeamStarts.get(id);
+        if (!fact || fact.requestId !== requestId)
+            return false;
+        this.unacceptedTeamStarts.delete(id);
+        const session = this.sessions.get(id);
+        return !this.disposed && session?.status === "failed"
+            && !session.structuredState?.activeRequestId && !session.structuredState?.inFlight;
+    }
     /** Only an unstarted employee conversation may change CLI after a failed first turn. */
     retryEmployeeCandidate(id, original, prompt, error) {
+        // Team runs own candidate scheduling; keep the snapshot without a second retry loop.
+        if (original.automationId?.startsWith("ai-team:"))
+            return null;
         const candidates = original.employeeCandidates ?? [];
         const nextIndex = (original.employeeCandidateIndex ?? 0) + 1;
         if (!original.employeeId || (original.messages?.length ?? 0) !== 0 || nextIndex >= candidates.length)
             return null;
+        // 手动选择候选链外的工具时，不把明确选择又换回员工的另一条候选。
+        if (original.provider !== candidates[original.employeeCandidateIndex ?? 0]?.provider)
+            return null;
         const current = this.sessions.get(id);
         if (!current || (current.status !== "running" && current.status !== "failed"))
             return null;
@@ -1359,10 +1458,8 @@ export class StructuredSessionManager {
             const runnerExecution = this.pendingRunnerExecutions.get(id);
             // interrupt() only requests cancellation; completion can settle later.
             // Treat runner-map ownership as the authoritative in-flight state.
-            const childActive = Boolean(runnerExecution);
+            const childActive = Boolean(runnerExecution) || this.pendingRecoveryIds.includes(id);
             if (!childActive) {
-                if (runnerExecution)
-                    this.releasePendingRunnerExecution(id, runnerExecution);
                 const recovered = {
                     ...session,
                     status: "idle",
@@ -1378,6 +1475,7 @@ export class StructuredSessionManager {
                 session = recovered;
             }
             else if (opts?.interrupt) {
+                this.requireRecoveryControl(id);
                 this.interruptedWith.set(id, prompt);
                 if (opts.preserveQueue) {
                     this.preserveQueueOnInterrupt.add(id);
@@ -1448,6 +1546,7 @@ export class StructuredSessionManager {
                 content: [{ type: "text", text: prompt }],
             };
         const requestId = randomUUID();
+        this.unacceptedTeamStarts.delete(id);
         if ((session.provider === "pi" && isMissingPiSession(session.structuredState?.lastError, session.claudeSessionId))
             || (session.provider === "gemini" && isMissingGeminiSession(session.structuredState?.lastError))) {
             session = { ...session, claudeSessionId: null };
@@ -1466,6 +1565,8 @@ export class StructuredSessionManager {
             },
         };
         this.sessions.set(id, updated);
+        if (updated.automationId?.startsWith("ai-team:"))
+            opts?.teamRequestStarted?.(id, requestId);
         this.checkpointSessionMessages(updated);
         this.emitStructuredSnapshot(updated);
         this.emit({
@@ -1569,6 +1670,14 @@ export class StructuredSessionManager {
             };
             this.sessions.set(id, failed);
             this.saveAuthoritativeSession(failed);
+            if (!this.disposed && error instanceof UnacceptedStructuredSpawnError
+                && current.automationId?.startsWith("ai-team:")) {
+                // Available before status/ended listeners run. A later turn/stop/delete invalidates this fact.
+                if (this.unacceptedTeamStarts.size >= 1024) {
+                    this.unacceptedTeamStarts.delete(this.unacceptedTeamStarts.keys().next().value);
+                }
+                this.unacceptedTeamStarts.set(id, { requestId });
+            }
             this.emit({
                 type: "status",
                 sessionId: id,
@@ -1654,6 +1763,7 @@ export class StructuredSessionManager {
      */
     async promoteQueuedMessage(sessionId, index, expectedText, idempotencyKey) {
         const session = this.requireSession(sessionId);
+        this.requireRecoveryControl(sessionId);
         if (idempotencyKey && this.seenIdempotencyKeys.has(`${sessionId}:${idempotencyKey}`)) {
             return session;
         }
@@ -1700,6 +1810,56 @@ export class StructuredSessionManager {
         this.emitStructuredSnapshot(updated);
         return updated;
     }
+    /** 新建空白对话可原位换 CLI；接受过输入、恢复会话和自动化不跨 provider 搬历史。 */
+    setSessionProvider(sessionId, provider) {
+        const session = this.requireSession(sessionId);
+        if (!isSessionProvider(provider))
+            throw new Error("请选择有效的 CLI 工具。");
+        if (session.status !== "idle" || session.archived || session.structuredState?.inFlight ||
+            this.pendingRunnerExecutions.has(sessionId) || session.claudeSessionId ||
+            (session.messages?.length ?? 0) > 0 || (session.queuedMessages?.length ?? 0) > 0 ||
+            session.automationId || (session.sessionSource && session.sessionSource !== "interactive") ||
+            this.relayHandlerFor(session)) {
+            throw new Error("只有尚未发送消息的新建空白对话可以更换工具。");
+        }
+        if (session.provider === provider)
+            return session;
+        const candidates = session.employeeCandidates ?? [];
+        const candidateIndex = candidates.findIndex((candidate) => candidate.provider === provider);
+        const candidate = candidateIndex >= 0 ? candidates[candidateIndex] : undefined;
+        const runner = defaultStructuredRunner(provider);
+        const model = candidate && candidate.model !== "default" ? candidate.model
+            : getDefaultModelForProvider(this.config, provider) || null;
+        const effort = normalizeThinkingEffort(candidate?.thinkingEffort ?? this.config.defaultThinkingEffort);
+        const thinkingEffort = effort?.includes(":") && !effort.startsWith(`${provider}:`) ? "off" : effort;
+        const requestedMode = candidate?.mode ?? session.mode;
+        const unsupportedMode = (requestedMode === "native" && provider !== "claude") ||
+            (requestedMode === "auto-edit" && ["opencode", "grok", "pi"].includes(provider));
+        const mode = provider === "codex" ? "full-access"
+            : unsupportedMode ? "default" : requestedMode;
+        const updated = {
+            ...session,
+            provider,
+            runner,
+            command: recoveredCommandLabel(runner),
+            mode,
+            autoApprovePermissions: shouldAutoApproveForMode(mode),
+            selectedModel: model,
+            thinkingEffort,
+            employeeCandidateIndex: candidateIndex >= 0 ? candidateIndex : undefined,
+            structuredState: { ...defaultStructuredState(provider, runner), model: model ?? undefined },
+        };
+        // 身份、知识归属、任务/目录和候选快照不变；只更新本会话的执行参数。
+        this.storage.saveSession(updated);
+        this.sessions.set(sessionId, updated);
+        this.emit({
+            type: "status",
+            sessionId,
+            data: { ...buildStructuredOutputPayload(updated), command: updated.command,
+                mode, autoApprovePermissions: updated.autoApprovePermissions },
+        });
+        return updated;
+    }
     /** Update the selected model for a structured session. Takes effect on the next spawn. */
     setSessionModel(sessionId, model) {
         const session = this.requireSession(sessionId);
@@ -1840,8 +2000,15 @@ export class StructuredSessionManager {
         });
         return updated;
     }
+    requireRecoveryControl(id) {
+        if (this.pendingRecoveryIds.includes(id) && !this.pendingRunnerExecutions.has(id)) {
+            throw new Error("正在恢复运行中的任务，请稍后重试控制操作；新消息仍可排队。");
+        }
+    }
     stop(id) {
+        this.unacceptedTeamStarts.delete(id);
         const session = this.requireSession(id);
+        this.requireRecoveryControl(id);
         this.interruptedWith.delete(id);
         this.preserveQueueOnInterrupt.delete(id);
         // Clearing activeRequestId is the generation barrier: late data/close callbacks
@@ -1874,6 +2041,8 @@ export class StructuredSessionManager {
         return cancelled;
     }
     delete(id) {
+        this.unacceptedTeamStarts.delete(id);
+        this.requireRecoveryControl(id);
         const runnerExecution = this.pendingRunnerExecutions.get(id);
         // Invalidate callback ownership before signalling the runner. Cancellation
         // can synchronously wake listeners in some adapter implementations.
@@ -1908,13 +2077,13 @@ export class StructuredSessionManager {
         return this.sessions.get(sessionId) ?? null;
     }
     /** Delete a handle only if it still belongs to the execution doing cleanup. */
-    releasePendingRunnerExecution(sessionId, execution) {
+    releasePendingRunnerExecution(sessionId, execution, forgetRun = true) {
         if (this.pendingRunnerExecutions.get(sessionId) !== execution)
             return false;
         this.pendingRunnerExecutions.delete(sessionId);
-        // Drop the daemon-side record once the manager has taken over completion;
-        // no-op for the in-process fallback host.
-        this.execHost?.forgetRun(structuredRunId(sessionId));
+        // A failed recovery attach must retain the daemon record for the next retry.
+        if (forgetRun)
+            this.execHost?.forgetRun(structuredRunId(sessionId));
         return true;
     }
     emitStructuredSnapshot(session, eventType = "output") {

package/dist/system-employee.js

@@ -52,6 +52,7 @@ export function systemEmployeeDefinition(agents, now, existing) {
         avatar: "",
         agents: agents.length ? agents : systemEmployeeSeedAgents(),
         systemKey: SYSTEM_EMPLOYEE_KEY,
+        tags: [SYSTEM_EMPLOYEE_TAG],
         createdAt: existing?.createdAt ?? now,
         updatedAt: now,
     };

package/dist/task-types.d.ts

@@ -4,8 +4,8 @@ export declare function isClosedWandTaskStatus(status: WandTaskStatus): boolean;
 export type WandTaskPriority = "none" | "low" | "medium" | "high" | "urgent";
 /** 新建任务的默认优先级：用户没挑就是「低」，不再落成「无优先级」。 */
 export declare const DEFAULT_WAND_TASK_PRIORITY: WandTaskPriority;
-/** 任务派发时选择的 CLI 工具；空串表示尚未指定。 */
-export type WandTaskAgentProvider = "claude" | "codex" | "opencode" | "grok" | "qoder" | "pi" | "gemini";
+/** 任务派发时选择的 CLI 工具；空串表示尚未指定。沿用 provider 的唯一真源。 */
+export type WandTaskAgentProvider = import("./provider-catalog.js").SessionProvider;
 export type WandTaskAgentModel = string;
 /** 与会话思考档位同一套：旧四档，或 `provider:level` 原生档。 */
 export type WandTaskAgentEffort = "off" | "standard" | "deep" | "max" | `${WandTaskAgentProvider}:${string}`;
@@ -147,6 +147,8 @@ export interface WandTask {
     /** 该任务绑定的执行 Agent；null 表示还没指定。 */
     agent: WandTaskAgent | null;
     executionSubject?: TaskExecutionSubject | null;
+    /** 进入归档的时间；未归档为 null。保留期清理按它起算。 */
+    archivedAt: string | null;
     createdAt: string;
     updatedAt: string;
 }

package/dist/tool-preview.d.ts

@@ -0,0 +1,8 @@
+import type { ContentBlock, ToolResultBlock, ToolUseBlock } from "./types.js";
+export declare const TOOL_PREVIEW_LIMIT = 180;
+/** A small, literal excerpt for a collapsed card, never generated by a model. */
+export declare function compactPreviewText(value: string): string;
+export declare function toolInputPreview(use: Pick<ToolUseBlock, "name" | "input" | "description" | "preview">): string;
+export declare function toolResultPreview(result: Pick<ToolResultBlock, "content" | "is_error" | "preview" | "_truncated">): string;
+/** Called at transport boundaries; provider history and full detail remain untouched. */
+export declare function withToolPreview(block: ContentBlock): ContentBlock;

package/dist/tool-preview.js

@@ -0,0 +1,158 @@
+export const TOOL_PREVIEW_LIMIT = 180;
+/** A small, literal excerpt for a collapsed card, never generated by a model. */
+export function compactPreviewText(value) {
+    const text = value.slice(0, 8_192)
+        .replace(/\x1b\[[0-9;]*[A-Za-z]/g, "")
+        .replace(/(?:Bearer\s+)[\w.+/=-]+/gi, "Bearer [隐藏]")
+        .replace(/((?:api[_-]?key|access[_-]?token|token|password|secret)\s*[=:]\s*)[^\s,;]+/gi, "$1[隐藏]")
+        .replace(/\s+/g, " ").trim();
+    return text.length > TOOL_PREVIEW_LIMIT ? text.slice(0, TOOL_PREVIEW_LIMIT - 1) + "…" : text;
+}
+function stringField(input, ...keys) {
+    for (const key of keys) {
+        if (typeof input[key] === "string" && input[key].trim())
+            return input[key];
+    }
+    return "";
+}
+function shortPath(path) {
+    return path.replace(/\\/g, "/").split("/").filter(Boolean).slice(-2).join("/");
+}
+function lineCount(text) {
+    return text ? text.split("\n").length - (text.endsWith("\n") ? 1 : 0) : 0;
+}
+export function toolInputPreview(use) {
+    if (use.preview)
+        return compactPreviewText(use.preview);
+    const input = use.input ?? {};
+    const name = use.name.toLowerCase().split(/\/|__/).pop() ?? "";
+    const path = shortPath(stringField(input, "file_path", "path", "filename", "file", "notebook_path"));
+    const command = stringField(input, "command", "cmd", "script");
+    let parts = [];
+    if (command) {
+        parts = [command];
+    }
+    else if (Array.isArray(input.tool_uses)) {
+        const calls = input.tool_uses.filter((value) => !!value && typeof value === "object");
+        parts = [`并行 ${calls.length} 个工具`, calls.slice(0, 3).map(call => stringField(call, "recipient_name", "name")).filter(Boolean).join("、")];
+    }
+    else if (typeof input.code === "string") {
+        const calls = [...new Set(Array.from(input.code.slice(0, 16_384).matchAll(/tools\.(\w+)\s*\(/g), match => match[1]))];
+        parts = [calls.length ? `脚本调用 ${calls.slice(0, 4).join("、")}` : "执行代码", use.description || ""];
+    }
+    else if (Array.isArray(input.urls)) {
+        const urls = input.urls.filter((value) => typeof value === "string");
+        parts = [`读取 ${urls.length} 个网址`, ...urls.slice(0, 2).map(value => {
+                try {
+                    const url = new URL(value);
+                    return url.hostname + url.pathname;
+                }
+                catch {
+                    return "网址";
+                }
+            })];
+    }
+    else if (/edit|write|replace|patch|file_change/.test(name)) {
+        parts = [path];
+        if (Array.isArray(input.edits))
+            parts.push(`${input.edits.length} 处替换`);
+        else if (typeof input.old_string === "string" && typeof input.new_string === "string") {
+            parts.push(`替换 ${lineCount(input.old_string)} 行 → ${lineCount(input.new_string)} 行`);
+        }
+        else if (typeof input.content === "string")
+            parts.push(`写入 ${lineCount(input.content)} 行`);
+        const patch = stringField(input, "patch", "unified_diff");
+        if (patch) {
+            const paths = Array.from(patch.matchAll(/^(?:\*\*\* (?:Update|Add|Delete) File: |\+\+\+ b\/)(.+)$/gm), match => shortPath(match[1]));
+            if (paths.length)
+                parts.push([...new Set(paths)].slice(0, 3).join("、"));
+        }
+    }
+    else if (/grep|glob|search|find/.test(name)) {
+        const query = stringField(input, "pattern", "query", "search", "regex");
+        const queries = Array.isArray(input.queries) ? input.queries.filter((v) => typeof v === "string") : [];
+        parts = [query || queries.slice(0, 2).join("；"), path ? `范围 ${path}` : "", stringField(input, "glob", "include")];
+    }
+    else if (path) {
+        parts = [path];
+        const offset = input.offset ?? input.start_line;
+        const limit = input.limit ?? input.end_line;
+        if (typeof offset === "number")
+            parts.push(`起始行 ${offset}`);
+        if (typeof limit === "number")
+            parts.push(`${input.end_line !== undefined ? "结束行" : "最多"} ${limit}${input.end_line !== undefined ? "" : " 行"}`);
+    }
+    else if (typeof input.url === "string") {
+        try {
+            const url = new URL(input.url);
+            parts = [url.hostname + url.pathname];
+        }
+        catch {
+            parts = [input.url];
+        }
+    }
+    else if (Array.isArray(input.todos)) {
+        const todos = input.todos.filter((v) => !!v && typeof v === "object");
+        const done = todos.filter(todo => todo.status === "completed").length;
+        const active = todos.find(todo => todo.status === "in_progress");
+        parts = [`${done}/${todos.length} 项完成`, active ? stringField(active, "activeForm", "content", "subject") : ""];
+    }
+    else {
+        parts = [stringField(input, "action", "agent"), stringField(input, "subject", "title", "description", "task", "prompt", "query", "name") || use.description || ""];
+        if (!parts.some(Boolean)) {
+            parts = Object.entries(input).filter(([key, value]) => !/token|password|secret|key|content|body|data|code/i.test(key) && ["string", "number", "boolean"].includes(typeof value))
+                .slice(0, 2).map(([key, value]) => `${key}: ${String(value)}`);
+        }
+    }
+    return compactPreviewText(parts.filter(Boolean).join(" · "));
+}
+export function toolResultPreview(result) {
+    if (result.preview)
+        return compactPreviewText(result.preview);
+    const raw = typeof result.content === "string" ? result.content : result.content
+        .filter(part => part.type === "text" && typeof part.text === "string")
+        .slice(0, 3).map(part => part.text).join("\n");
+    if (!raw.trim())
+        return "";
+    let text = raw;
+    let exit = "";
+    if (raw.length <= 65_536 && /^\s*[{[]/.test(raw)) {
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed))
+                return `返回 ${parsed.length} 项`;
+            if (parsed && typeof parsed === "object") {
+                const code = parsed.exit_code ?? parsed.exitCode;
+                if (typeof code === "number")
+                    exit = `退出码 ${code}`;
+                text = stringField(parsed, "error", "message", "summary", "output", "stdout", "result");
+                if (!text) {
+                    const rows = parsed.results ?? parsed.matches ?? parsed.items;
+                    if (Array.isArray(rows))
+                        text = `返回 ${rows.length} 项`;
+                    else
+                        text = Object.entries(parsed).filter(([key, value]) => /^(?:status|count|total|success|passed|failed|duration|wall_time_seconds)$/.test(key) &&
+                            ["string", "number", "boolean"].includes(typeof value)).map(([key, value]) => `${key}: ${value}`).join(" · ");
+                }
+            }
+        }
+        catch { /* Plain tool output may begin with a bracket. */ }
+    }
+    const sample = text.length > 8_192 ? text.slice(0, 2_048) + "\n…\n" + text.slice(-6_144) : text;
+    const lines = sample.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+    const facts = lines.filter(line => /(?:error|failed|failure|passed|\b(?:pass|fail|tests?)\b|exit(?:ed)?(?: code)?|BUILD (?:SUCCESS|FAIL)|错误|失败|通过|命中|找到)/i.test(line));
+    const selected = (facts.length ? facts.slice(-2) : result.is_error ? lines.slice(-2) : lines.slice(0, 2)).join(" · ");
+    return compactPreviewText([exit, selected].filter(Boolean).join(" · "));
+}
+/** Called at transport boundaries; provider history and full detail remain untouched. */
+export function withToolPreview(block) {
+    if (block.type === "tool_use") {
+        const preview = toolInputPreview(block);
+        return preview ? { ...block, preview } : block;
+    }
+    if (block.type === "tool_result") {
+        const preview = toolResultPreview(block);
+        return preview ? { ...block, preview } : block;
+    }
+    return block;
+}