@co0ontty/wand 4.83.1 → 4.84.0

package/dist/conversation-session-preview.d.ts

@@ -0,0 +1,9 @@
+import type { ConversationSessionPreview, SessionSnapshot } from "./types.js";
+export declare const CONVERSATION_SESSION_PREFIX = "conversation-message:";
+export declare const CONVERSATION_PREVIEW_LIMIT = 4000;
+export declare const conversationSessionPreviewLabels: Record<ConversationSessionPreview["status"], string>;
+/** The session owns the transcript. IM only reads a bounded tail; never copies it into message history. */
+export declare function conversationSessionPreview(session: SessionSnapshot | null, startup?: {
+    startup?: "pending" | "started" | "failed";
+    error?: string;
+}): ConversationSessionPreview;

package/dist/conversation-session-preview.js

@@ -0,0 +1,47 @@
+export const CONVERSATION_SESSION_PREFIX = "conversation-message:";
+export const CONVERSATION_PREVIEW_LIMIT = 4000;
+export const conversationSessionPreviewLabels = {
+    starting: "正在启动", running: "正在回复", waiting_user: "等待你确认", done: "已完成",
+    failed: "执行失败", stopped: "已停止", unavailable: "会话不可用",
+};
+/** The session owns the transcript. IM only reads a bounded tail; never copies it into message history. */
+export function conversationSessionPreview(session, startup) {
+    if (!session)
+        return { status: "unavailable", text: "会话已不可用，原消息保留。" };
+    const state = session.structuredState;
+    const turns = session.messages ?? [];
+    const last = turns.at(-1);
+    const question = last?.role === "assistant" && last.content.some(block => block.type === "tool_use"
+        && (block.semantic?.kind === "question_request" || block.name === "AskUserQuestion")
+        && !last.content.some(result => result.type === "tool_result" && result.tool_use_id === block.id));
+    const active = state?.inFlight || session.status === "running";
+    let userInputs = 0;
+    const continued = startup?.startup === "failed" && turns.some(turn => turn.role === "user" && turn.content.some(block => block.type === "text" && block.text.trim()) && ++userInputs > 1);
+    // A failed initial delivery receipt remains immutable evidence, but must not mask an explicit later turn.
+    const startupFailed = startup?.startup === "failed" && !active && !continued && !last?.completedAt;
+    const status = session.status === "stopped" ? "stopped"
+        : session.status === "failed" || !!state?.lastError || startupFailed ? "failed"
+            : session.pendingEscalation || question ? "waiting_user"
+                : active ? "running" : startup?.startup === "pending" ? "starting" : "done";
+    // Walk backwards and stop as soon as the viewport budget is filled. Large sessions stay bounded.
+    let text = "";
+    for (let index = turns.length - 1; index >= 0 && text.length < CONVERSATION_PREVIEW_LIMIT; index--) {
+        const turn = turns[index];
+        if (turn.role === "user")
+            break; // Explicit follow-ups belong to the same session, not the next IM message.
+        for (let blockIndex = turn.content.length - 1; blockIndex >= 0 && text.length < CONVERSATION_PREVIEW_LIMIT; blockIndex--) {
+            const block = turn.content[blockIndex];
+            if (block.type === "text" && block.text.trim())
+                text = `${block.text.slice(-CONVERSATION_PREVIEW_LIMIT)}${text ? `\n\n${text}` : ""}`;
+        }
+    }
+    if (status === "failed")
+        text = [text, state?.lastError || (startupFailed ? startup?.error : undefined) || "执行失败，请打开会话核对；不会自动重发。"].filter(Boolean).join("\n\n");
+    if (!text) {
+        const tool = last?.content.slice().reverse().find(block => block.type === "tool_use");
+        text = session.pendingEscalation?.reason || (active && tool?.type === "tool_use" ? `正在调用 ${tool.name}` : "")
+            || (status === "starting" ? "消息已接收，正在启动独立会话。" : status === "running" ? "正在思考…"
+                : status === "stopped" ? "本轮已停止。" : "本轮已结束，打开会话查看完整过程。");
+    }
+    return { status, text: text.slice(-CONVERSATION_PREVIEW_LIMIT) };
+}

package/dist/conversation-task-preview.d.ts

@@ -0,0 +1,5 @@
+import type { AiTeamLiveStep } from "./ai-team-types.js";
+import type { ConversationTurn } from "./types.js";
+export declare const conversationTaskPreviewLabels: Record<NonNullable<ConversationTurn["taskPreview"]>["status"], string>;
+/** Shared by the HTTP snapshot and WS projection; only this run’s real output, bounded at the tail. */
+export declare function conversationTaskLiveText(steps: readonly AiTeamLiveStep[]): string;

package/dist/conversation-task-preview.js

@@ -0,0 +1,8 @@
+export const conversationTaskPreviewLabels = {
+    starting: "正在启动", running: "处理中", awaiting_approval: "等你批准计划", waiting_user: "等你回复",
+    done: "已完成", failed: "执行失败", stopped: "已停止", unavailable: "任务不可用",
+};
+/** Shared by the HTTP snapshot and WS projection; only this run’s real output, bounded at the tail. */
+export function conversationTaskLiveText(steps) {
+    return steps.filter(step => step.text.trim()).map(step => `${step.memberName}：\n${step.text.slice(-4000)}`).join("\n\n").slice(-4000);
+}

package/dist/conversation-types.d.ts

@@ -0,0 +1,80 @@
+import type { AiTeam, AiTeamRun, AiTeamRunDetail } from "./ai-team-types.js";
+import type { WandTask } from "./task-types.js";
+import type { ConversationSessionPreview, ConversationTurn } from "./types.js";
+/** This Wand service has one authenticated owner; connection principals are capabilities, not new users. */
+export declare const CONVERSATION_OWNER = "local-owner";
+export declare const CONVERSATION_RELAY_PREFIX = "conversation:";
+export declare const CONVERSATION_MIN_MEMBERS = 1;
+export type ConversationTarget = {
+    taskId: string;
+    runId: string;
+} | null;
+/** Instance configuration is independent of both presets and frozen run.team. */
+export interface ConversationInstance {
+    id: string;
+    owner: string;
+    kind: "dm" | "group";
+    peerEmployeeId: string | null;
+    name: string;
+    nameSource: "auto" | "custom";
+    sourceTemplateId: string | null;
+    team: AiTeam | null;
+    memberVersion: number;
+    joinedVersions: Record<string, number>;
+    /** Group relay or preserved legacy DM channel, never the most recent direct-message execution. */
+    sessionId: string | null;
+    /** Group talk/legacy DM channel; new DM executions belong to each reply's sessionLink. */
+    communicationSessionId: string | null;
+    historySessionIds?: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ConversationTaskSummary {
+    task: WandTask;
+    linkedAt: string;
+    runs: AiTeamRun[];
+    startup?: {
+        state: "pending" | "started" | "failed";
+        error?: string;
+    };
+}
+export interface ConversationSummary extends ConversationInstance {
+    pinnedAt?: string | null;
+    dissolvedAt?: string | null;
+    dissolvedBy?: string | null;
+    deleting?: boolean;
+    title: string;
+    unavailableReason: string | null;
+    memberUnavailableReasons: Record<string, string>;
+    tasks: ConversationTaskSummary[];
+    preview: string;
+    messageAt: string;
+}
+export interface ConversationDetail extends ConversationSummary {
+    messages: ConversationTurn[];
+    runDetails: AiTeamRunDetail[];
+}
+export interface ConversationReceipt {
+    requestId: string;
+    state: "pending" | "accepted" | "rejected";
+    conversationId: string;
+    taskId?: string;
+    runId?: string;
+    sessionId?: string;
+    messageId?: string;
+    /** Session or task/group acceptance is durable before execution startup. Not a delivery rejection. */
+    startup?: "pending" | "started" | "failed";
+    error?: string;
+}
+export interface ConversationSessionUpdate {
+    conversationId: string;
+    sessionId: string;
+    preview: ConversationSessionPreview;
+}
+export interface ConversationRequest {
+    id: string;
+    fingerprint: string;
+    receipt: ConversationReceipt;
+    updatedAt: string;
+}
+export declare function employeeConversationId(employeeId: string): string;

package/dist/conversation-types.js

@@ -0,0 +1,7 @@
+/** This Wand service has one authenticated owner; connection principals are capabilities, not new users. */
+export const CONVERSATION_OWNER = "local-owner";
+export const CONVERSATION_RELAY_PREFIX = "conversation:";
+export const CONVERSATION_MIN_MEMBERS = 1;
+export function employeeConversationId(employeeId) {
+    return `dm_${employeeId}`;
+}

package/dist/core-extension-host.d.ts

@@ -0,0 +1,27 @@
+import { type PiSessionSettings } from "./pi-session-settings.js";
+import type { HarnessExtensionState, SessionSnapshot, WandConfig } from "./types.js";
+import type { loadPiAi, loadPiCodingAgent } from "./harness-engine.js";
+import type { Agent, AgentMessage, AgentTool } from "@earendil-works/pi-agent-core";
+import type { AgentSession, ModelRuntime } from "@earendil-works/pi-coding-agent";
+export declare function parseHarnessExtensionState(raw: unknown): HarnessExtensionState | undefined;
+export interface CoreExtensionHost {
+    session: AgentSession;
+    capture(): HarnessExtensionState;
+    interrupt(): void;
+    close(): Promise<void>;
+}
+export declare function createCoreExtensionHost(options: {
+    pi: Awaited<ReturnType<typeof loadPiCodingAgent>>;
+    ai: Awaited<ReturnType<typeof loadPiAi>>;
+    config: WandConfig;
+    target: SessionSnapshot;
+    settings: PiSessionSettings;
+    systemPrompt: string;
+    agent: Agent;
+    messages: AgentMessage[];
+    tools: AgentTool[];
+    runtime: ModelRuntime | null;
+    /** Stream authentication is already owned by the injected stream / zero-price model allocator. */
+    externalStreamAuth: boolean;
+    onNotice(text: string): void;
+}): Promise<CoreExtensionHost>;

package/dist/core-extension-host.js

@@ -0,0 +1,138 @@
+import { createPiExtensionResources } from "./pi-extension-resources.js";
+import { PI_BUILTIN_TOOLS } from "./pi-session-settings.js";
+const MAX_EXTENSION_STATE_BYTES = 128 * 1024;
+const MAX_EXTENSION_ENTRIES = 128;
+export function parseHarnessExtensionState(raw) {
+    if (!raw || typeof raw !== "object" || !Array.isArray(raw.entries))
+        return undefined;
+    const entries = raw.entries;
+    if (entries.length > MAX_EXTENSION_ENTRIES || Buffer.byteLength(JSON.stringify(entries)) > MAX_EXTENSION_STATE_BYTES)
+        return undefined;
+    if (!entries.every((entry) => entry && typeof entry.customType === "string" && entry.customType.length <= 200
+        && (entry.type === "custom" || (entry.type === "custom_message" && typeof entry.content === "string" && typeof entry.display === "boolean"))))
+        return undefined;
+    return { entries };
+}
+/** Keep native snapshots/store data bounded, without another copy of Wand's ordinary messages. */
+function captureExtensionState(manager, prior) {
+    const entries = [];
+    const store = Object.create(null);
+    for (const entry of manager.getBranch()) {
+        if (entry.type === "custom") {
+            if (entry.customType === "codemode-store") {
+                const data = entry.data;
+                Object.assign(store, data?.set ?? {});
+                for (const key of data?.delete ?? [])
+                    delete store[key];
+                continue;
+            }
+            if (entry.customType === "pi-goal") {
+                const index = entries.findIndex((item) => item.type === "custom" && item.customType === entry.customType);
+                if (index >= 0)
+                    entries.splice(index, 1);
+            }
+            entries.push({ type: "custom", customType: entry.customType, data: entry.data });
+        }
+        else if (entry.type === "custom_message") {
+            // Goal events are snapshots: only the newest directive should survive into the next turn.
+            if (entry.customType === "pi-goal-event") {
+                const index = entries.findIndex((item) => item.type === "custom_message" && item.customType === entry.customType);
+                if (index >= 0)
+                    entries.splice(index, 1);
+            }
+            const content = typeof entry.content === "string" ? entry.content : entry.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+            entries.push({ type: "custom_message", customType: entry.customType, content, display: entry.display, details: entry.details });
+        }
+    }
+    if (Object.keys(store).length)
+        entries.push({ type: "custom", customType: "codemode-store", data: { set: store, delete: [] } });
+    // Disabled custom messages were intentionally not exposed to the agent, but are not deleted.
+    for (const entry of prior?.entries ?? []) {
+        if (entry.type === "custom_message" && !entries.some((item) => item.customType === entry.customType))
+            entries.push(entry);
+    }
+    const state = parseHarnessExtensionState({ entries });
+    if (!state)
+        throw new Error("Pi 扩展状态超出保存上限（128 条 / 128 KiB）；没有截断或伪造已保存状态。");
+    return state;
+}
+export async function createCoreExtensionHost(options) {
+    const { pi, target, settings, agent } = options;
+    const resources = await createPiExtensionResources(pi, options.config, target.cwd, settings, options.systemPrompt);
+    const manager = pi.SessionManager.inMemory(target.cwd);
+    for (const entry of target.harnessExtensionState?.entries ?? []) {
+        if (entry.type === "custom")
+            manager.appendCustomEntry(entry.customType, entry.data);
+        else if (entry.customType.startsWith("pi-goal") ? settings.goalMode : settings.globalTools) {
+            manager.appendCustomMessageEntry(entry.customType, entry.content, entry.display, entry.details);
+        }
+    }
+    for (const message of options.messages)
+        manager.appendMessage(message);
+    let runtime = options.runtime ?? await pi.ModelRuntime.create({
+        credentials: new options.ai.InMemoryCredentialStore(), modelsStore: new options.ai.InMemoryModelsStore(),
+        modelsPath: null, refreshOnCreate: false,
+    });
+    if (options.externalStreamAuth) {
+        // Per-session facade, never mutate the shared auth runtime or write synthetic credentials.
+        const provider = agent.state.model.provider;
+        runtime = new Proxy(runtime, { get(base, key) {
+                if (key === "hasConfiguredAuth")
+                    return (id) => id === provider || base.hasConfiguredAuth(id);
+                const value = Reflect.get(base, key);
+                return typeof value === "function" ? value.bind(base) : value;
+            } });
+    }
+    const runnerRef = {};
+    const session = new pi.AgentSession({
+        agent, cwd: target.cwd, sessionManager: manager, modelRuntime: runtime, resourceLoader: resources,
+        // Wand owns compaction, queues, model choice and history; the SDK owns only this round's extensions.
+        settingsManager: pi.SettingsManager.inMemory({ compaction: { enabled: false }, retry: { enabled: false }, cacheWarming: "off" }),
+        baseToolsOverride: Object.fromEntries(options.tools.map((tool) => [tool.name, tool])),
+        initialActiveToolNames: [...options.tools.map((tool) => tool.name), ...(settings.codemode !== "off" ? ["codemode"] : [])],
+        excludedToolNames: [...PI_BUILTIN_TOOLS.filter((name) => !settings.tools.includes(name)),
+            ...(!settings.localDecision ? ["decision_evaluate"] : []),
+            ...(settings.codemode === "off" ? ["codemode"] : []),
+            ...(!settings.goalMode ? ["create_goal", "get_goal", "update_goal"] : [])],
+        extensionRunnerRef: runnerRef,
+    });
+    try {
+        // Keep headless dialogs conservative. Notifications still reach the caller instead of disappearing.
+        const ui = runnerRef.current.getUIContext();
+        await session.bindExtensions({ mode: "print", uiContext: { ...ui, notify: options.onNotice },
+            onError: (error) => { options.onNotice(`Pi 扩展错误：${error.error}`); },
+            abortHandler: () => agent.abort(), shutdownHandler: () => agent.abort() });
+    }
+    catch (error) {
+        session.dispose();
+        throw error;
+    }
+    return { session,
+        capture: () => captureExtensionState(manager, target.harnessExtensionState),
+        interrupt: () => {
+            // pi-goal continues on agent_end, even after abort. Pause its native state BEFORE aborting,
+            // through the real command handler (never dispatch an unknown command to the model).
+            if (settings.goalMode) {
+                const runner = runnerRef.current;
+                const goal = runner?.getCommand("goal");
+                if (goal && runner) {
+                    void Promise.resolve(goal.handler("pause", runner.createCommandContext())).catch((error) => {
+                        options.onNotice(error instanceof Error ? error.message : "暂停目标失败。");
+                    });
+                }
+            }
+            session.clearQueue();
+            // The SDK's abort flag also prevents agent_end/before_settle hooks from restarting the loop.
+            void session.abort().catch((error) => {
+                options.onNotice(error instanceof Error ? error.message : "停止 Pi 扩展失败。");
+            });
+        },
+        close: async () => {
+            try {
+                await runnerRef.current?.emit({ type: "session_shutdown", reason: "quit" });
+            }
+            finally {
+                session.dispose();
+            }
+        }, };
+}

package/dist/core-runner.d.ts

@@ -0,0 +1,86 @@
+import { type OpenRouterFreeModelsService } from "./openrouter-free-models.js";
+import type { ResolvedCoreModel } from "./harness-engine.js";
+import type { DecisionRuntimeAccess } from "./decision-runner.js";
+import type { ConversationTurn, SessionSnapshot, WandConfig } from "./types.js";
+import type { StructuredRunnerAdapter, StructuredRunnerContext, StructuredRunnerExecution, StructuredRunnerObserver, StructuredRunnerTurnState } from "./structured-runner.js";
+import type { AgentMessage, AgentTool, StreamFn } from "@earendil-works/pi-agent-core";
+import type { Model, Api, ModelThinkingLevel } from "@earendil-works/pi-ai";
+/** 压缩摘要作为上下文导入时的头部：明确它不是新的用户要求。 */
+export declare const CORE_SUMMARY_HEADER = "[\u66F4\u65E9\u7684\u5BF9\u8BDD\u5DF2\u88AB\u538B\u7F29\u4E3A\u4E0B\u9762\u7684\u6458\u8981\u3002\u5B83\u662F\u672C\u4F1A\u8BDD\u7684\u5DF2\u6709\u4E0A\u4E0B\u6587\uFF0C\u4E0D\u662F\u65B0\u7684\u7528\u6237\u8981\u6C42\u3002]\n\n";
+/**
+ * Wand 历史 → core transcript。
+ * Wand 库是唯一事实源：每个回合都从存储的历史重建，不依赖上游 session 文件。
+ * Wand 允许 tool_result 落在 tool_use 之后的另一个 turn（服务端把结果并进下一个 user turn），
+ * 这里按 toolCallId 重新配对成标准的 assistant / toolResult 消息。
+ *
+ * `from` 之后的 turn 才进入 transcript；更早的历史由 `summary` 代表（上下文压缩后）。
+ */
+export declare function coreMessagesFromTurns(session: SessionSnapshot, options?: {
+    from?: number;
+    until?: number;
+    summary?: string;
+}): AgentMessage[];
+/**
+ * core agent 事件 → Wand 回合状态。与 pi CLI 适配器共用同一套 blocks 语义，
+ * 但参数与结果是上游真值（不再从 provider 文本里反推）。返回本轮的 primaryError。
+ */
+export declare function applyCoreAgentEvent(state: StructuredRunnerTurnState, event: Record<string, unknown>): string | null;
+export interface CoreRunnerOptions {
+    openRouter?: OpenRouterFreeModelsService;
+    config: WandConfig;
+    /** 进程内决策能力（与 CLI 的 env token 路径二选一，core 用这个）。 */
+    decisionAccess?: () => DecisionRuntimeAccess | null;
+    /** 测试/宿主注入：替换模型流式实现（生产用 ModelRuntime.streamSimple）。 */
+    streamFn?: StreamFn;
+    /** 测试/宿主注入：替换模型解析（生产走 Pi 认证目录）。 */
+    modelResolver?: (session: SessionSnapshot) => Promise<ResolvedCoreModel | null>;
+}
+/**
+ * 进程内 core runner：用 Pi 的 agent loop 跑结构化会话。
+ * 与 CLI runner 的契约完全相同（同一个 StructuredRunnerAdapter），
+ * 差别是 loop 与工具都在 Wand 进程内，系统提示由 Wand 拥有、上下文由 Wand 拥有。
+ */
+export declare class CoreRunner implements StructuredRunnerAdapter {
+    private readonly options;
+    constructor(options: CoreRunnerOptions);
+    start(context: StructuredRunnerContext, observer: StructuredRunnerObserver): StructuredRunnerExecution;
+    /** 返回本轮的 primaryError；null 表示成功。 */
+    private runTurn;
+    private buildTools;
+}
+type ClampThinkingLevel = (model: Model<Api>, level: ModelThinkingLevel) => ModelThinkingLevel;
+/**
+ * Wand 自有工具：本地决策（进程内）。
+ * 同进程直接调决策服务，不经过 env token / HTTP 回环；
+ * `questions` 用 JSON 字符串传递，避开各家 provider 对嵌套 schema 的差异，
+ * 也把校验交给服务端的有界校验器（1–8 题、每题 2–8 项、总请求≤32KiB）。
+ */
+export declare function buildDecisionTool(decision: DecisionRuntimeAccess, type: typeof import("@earendil-works/pi-ai").Type, sessionId: string): AgentTool; /**
+ * Wand 的思考档 → 当前模型真正支持的档位。
+ * Wand 的 off/standard/deep/max 是历史四档，`provider:level` 是原生档；
+ * 最终一律交给上游 clamp，避免把不支持的档位发给 provider。
+ */
+export declare function thinkingLevelFor(clamp: ClampThinkingLevel, model: Model<Api>, effort: SessionSnapshot["thinkingEffort"]): ModelThinkingLevel;
+/** 压缩预算：config.harness.compaction 覆盖上游默认值。 */
+export declare function compactionSettings(config: WandConfig, defaults: {
+    enabled: boolean;
+    reserveTokens: number;
+    keepRecentTokens: number;
+}): {
+    enabled: boolean;
+    reserveTokens: number;
+    keepRecentTokens: number;
+};
+/**
+ * 在 turn 空间里找切点：保留预算内最最早的真实用户输入作为切点。
+ * 预算内找不到时至少向前推一格（否则超限会话会永远压不下去）；再没办法就返回原切点。
+ */
+export declare function findCompactionCut(turns: readonly ConversationTurn[], from: number, keepRecentTokens: number, turnTokens: (index: number) => number, isUserText?: (turn: ConversationTurn) => boolean): number;
+/**
+ * core 会话的基础系统提示。 * Wand 拥有它：不再依赖外部 CLI 的默认提示词，也不再往别人的提示词后面追加。
+ * 会话级 systemPrompt / 员工角色 / 本轮知识由 buildCoreSystemPrompt 接在后面。
+ */
+export declare const CORE_BASE_SYSTEM_PROMPT: string;
+/** 基础提示 + 会话级系统提示（角色/规则/本轮知识）。 */
+export declare function buildCoreSystemPrompt(session: Pick<SessionSnapshot, "systemPrompt" | "runtimeSystemPrompt">): string;
+export {};