@tea-agent/loop-agent 0.40.0-next.4 → 0.40.0-next.6

package/dist/worker/console/chat/pi-runtime.js

@@ -29,6 +29,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { access } from "node:fs/promises";
 import path from "node:path";
 import { extractAssistantContentBlocks, extractAssistantText, isAssistantSdkMessage, } from "./assistant-content.js";
+import { parseProviderError, } from "./provider-error.js";
 import { projectCompactSnapshot, } from "./chat-event-store.js";
 import { extractUsageSample } from "./usage.js";
 import { OPERATOR_CHAT_ALLOWED_TOOLS, authorizeOperatorChatTool, assertNoWriteToolInList, } from "./tools.js";
@@ -38,6 +39,7 @@ import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { resolveDefaultChatModel, resolveLowChatModel, } from "./model-resolver.js";
 import { filterActiveInterviewTools } from "../interview/tools.js";
 import { RUNTIME_CONTEXT_TEXT_MAX, redactRuntimeText, } from "./runtime-context.js";
+import { buildTodoContinuationContext, } from "./todos.js";
 /**
  * Base system prompt fragment every General Operator Chat session receives.
  *
@@ -210,6 +212,51 @@ async function bindSessionExtensions(session) {
 function pinOperatorChatTools(session) {
     session.setActiveToolsByName(computeOperatorChatActiveToolNames(session));
 }
+/**
+ * Pi has no hook result that merely appends instructions to its built-in
+ * automatic compactor: session_before_compact must either cancel or replace
+ * the whole compaction result. Keep the SDK algorithm intact and inject the
+ * current Todo as ephemeral context only after a successful compaction. The
+ * next turn resets the marker and TodoListRegistry clears the list.
+ */
+export function createTodoCompactionContextExtension(options) {
+    return {
+        name: "operator-chat-todo-compaction-context",
+        hidden: true,
+        factory: (api) => {
+            let compactedInCurrentTurn = false;
+            api.on("turn_start", () => {
+                compactedInCurrentTurn = false;
+            });
+            api.on("session_compact", () => {
+                compactedInCurrentTurn = true;
+            });
+            api.on("context", (rawEvent) => {
+                if (!compactedInCurrentTurn)
+                    return undefined;
+                const context = buildTodoContinuationContext(options.registry.get(options.sessionId));
+                if (!context)
+                    return undefined;
+                const messages = Array.isArray(rawEvent.messages)
+                    ? rawEvent.messages
+                    : [];
+                return {
+                    messages: [
+                        ...messages,
+                        {
+                            role: "custom",
+                            customType: "operator-chat-todo-context",
+                            content: context,
+                            display: false,
+                            details: { todos: options.registry.get(options.sessionId) },
+                            timestamp: Date.now(),
+                        },
+                    ],
+                };
+            });
+        },
+    };
+}
 /**
  * Build Pi custom ToolDefinition objects for every whitelisted operator action.
  * Each tool's execute() routes into the operator action dispatcher (Gate 3).
@@ -289,6 +336,76 @@ async function buildCustomOperatorTools(options) {
         });
     });
 }
+const ASK_USER_QUESTION_DESCRIPTION = "Ask the user concise questions when a confirmation, choice, or missing detail is required before proceeding. " +
+    "The tool pauses until the user answers. Use it instead of writing questions as ordinary assistant text. " +
+    "Send one or more questions with stable ids; recommended options should be first and end with (Recommended).";
+async function buildAskUserQuestionTool(options) {
+    const [{ Type }, { defineTool }] = await Promise.all([
+        import("typebox"),
+        import("@earendil-works/pi-coding-agent"),
+    ]);
+    return defineTool({
+        name: "ask_user_question",
+        label: "Ask user",
+        description: ASK_USER_QUESTION_DESCRIPTION,
+        promptSnippet: ASK_USER_QUESTION_DESCRIPTION,
+        parameters: Type.Object({
+            questions: Type.Array(Type.Object({
+                id: Type.String({ description: "Stable question id echoed in the answer." }),
+                question: Type.String({ description: "Specific user-facing question." }),
+                header: Type.Optional(Type.String({ description: "Optional short heading." })),
+                detail: Type.Optional(Type.String({ description: "Optional Markdown context shown below the question." })),
+                options: Type.Optional(Type.Array(Type.Object({
+                    label: Type.String({ description: "Short user-facing option label." }),
+                    description: Type.Optional(Type.String({ description: "One sentence explaining impact or tradeoff." })),
+                }, { additionalProperties: false }))),
+                multi_select: Type.Optional(Type.Boolean({ description: "Allow more than one option." })),
+            }, { additionalProperties: false }), { minItems: 1, maxItems: 20 }),
+        }, { additionalProperties: false }),
+        async execute(toolCallId, params, signal) {
+            const answer = await options.registry.ask({
+                sessionId: options.sessionId,
+                toolCallId,
+                questions: params.questions,
+                signal,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(answer) }],
+                details: answer,
+            };
+        },
+    });
+}
+const TODO_WRITE_DESCRIPTION = "Record and update a structured task list for the current work. Send the ENTIRE list every call — it REPLACES the previous list. Use it for multi-step work; skip trivial single-step tasks. Mark tasks pending, in_progress, or completed, and mark completed immediately when done.";
+async function buildTodoWriteTool(options) {
+    const [{ Type }, { defineTool }] = await Promise.all([
+        import("typebox"),
+        import("@earendil-works/pi-coding-agent"),
+    ]);
+    return defineTool({
+        name: "todo_write",
+        label: "Update todo list",
+        description: TODO_WRITE_DESCRIPTION,
+        promptSnippet: TODO_WRITE_DESCRIPTION,
+        parameters: Type.Object({
+            todos: Type.Array(Type.Object({
+                content: Type.String({ description: "Short imperative task description." }),
+                status: Type.Union([
+                    Type.Literal("pending"),
+                    Type.Literal("in_progress"),
+                    Type.Literal("completed"),
+                ]),
+            }, { additionalProperties: false })),
+        }, { additionalProperties: false }),
+        async execute(toolCallId, params) {
+            const result = options.registry.write(options.sessionId, toolCallId, params.todos);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+                details: result,
+            };
+        },
+    });
+}
 /**
  * Build the safe explore custom tools (roadmap M0-A / G16): safe-read,
  * safe-grep, gitStatus, gitDiff. These replace the bare SDK bash/read/grep so
@@ -765,9 +882,26 @@ export class ConsolePiRuntime {
      * after a PATCH sees the latest resource-preferences.json (not create-time
      * closure state).
      */
-    async buildResourceLoaderOptions(base = {}) {
+    async buildResourceLoaderOptions(base = {}, sessionId) {
+        const inheritedFactories = Array.isArray(base.extensionFactories)
+            ? base.extensionFactories
+            : [];
+        const todoContextExtension = sessionId && this.options.todoRegistry
+            ? createTodoCompactionContextExtension({
+                sessionId,
+                registry: this.options.todoRegistry,
+            })
+            : undefined;
         return {
             ...base,
+            ...(todoContextExtension
+                ? {
+                    extensionFactories: [
+                        ...inheritedFactories,
+                        todoContextExtension,
+                    ],
+                }
+                : {}),
             skillsOverride: (current) => {
                 // Synchronous override surface: use last-known prefs via a sync
                 // fail-closed path. Prefer async cache filled by ensurePrefs.
@@ -969,9 +1103,7 @@ export class ConsolePiRuntime {
         const { services } = await this.bindings.createServices({
             cwd: this.options.cwd,
             agentDir,
-            resourceLoaderOptions: await this.buildResourceLoaderOptions({
-                appendSystemPrompt,
-            }),
+            resourceLoaderOptions: await this.buildResourceLoaderOptions({ appendSystemPrompt }, sessionId),
         });
         if (this.disposedSessions.has(sessionId))
             return;
@@ -988,7 +1120,7 @@ export class ConsolePiRuntime {
             }) ?? undefined)
             : undefined;
         assertNoWriteToolInList(OPERATOR_CHAT_ALLOWED_TOOLS);
-        const customTools = await this.loadCustomTools();
+        const customTools = await this.loadCustomTools(sessionId);
         if (this.disposedSessions.has(sessionId))
             return;
         // pi-web parity: do NOT pass `tools`. A closed allowlist becomes
@@ -1045,12 +1177,26 @@ export class ConsolePiRuntime {
         }
     }
     /** Cached session-less custom tool definitions (operator + explore). */
-    async loadCustomTools() {
+    async loadCustomTools(sessionId) {
         const [operatorCustomTools, exploreCustomTools] = await Promise.all([
             this.loadOperatorCustomTools(),
             this.loadExploreCustomTools(),
         ]);
-        return [...operatorCustomTools, ...exploreCustomTools];
+        const questionTool = this.options.questionRegistry
+            ? await buildAskUserQuestionTool({
+                sessionId,
+                registry: this.options.questionRegistry,
+            })
+            : undefined;
+        const todoTool = this.options.todoRegistry
+            ? await buildTodoWriteTool({ sessionId, registry: this.options.todoRegistry })
+            : undefined;
+        return [
+            ...operatorCustomTools,
+            ...exploreCustomTools,
+            ...(questionTool ? [questionTool] : []),
+            ...(todoTool ? [todoTool] : []),
+        ];
     }
     loadOperatorCustomTools() {
         if (!this.options.actionContext)
@@ -1090,6 +1236,7 @@ export class ConsolePiRuntime {
             targetSessionId: sessionId,
         });
         const built = await this.buildSessionWithServices({
+            sessionId,
             sessionManager,
             model: init.model,
         });
@@ -1817,6 +1964,7 @@ export class ConsolePiRuntime {
         }
         try {
             const built = await this.buildSessionWithServices({
+                sessionId,
                 sessionManager,
                 model: init.model,
                 systemPromptSuffix: init.systemPromptSuffix,
@@ -1907,9 +2055,7 @@ export class ConsolePiRuntime {
         const { services } = await this.bindings.createServices({
             cwd: this.options.cwd,
             agentDir,
-            resourceLoaderOptions: await this.buildResourceLoaderOptions({
-                appendSystemPrompt,
-            }),
+            resourceLoaderOptions: await this.buildResourceLoaderOptions({ appendSystemPrompt }, init.sessionId),
         });
         const modelRuntime = services.modelRuntime;
         const resolvedModel = init.model
@@ -1920,7 +2066,7 @@ export class ConsolePiRuntime {
             }) ?? undefined)
             : undefined;
         assertNoWriteToolInList(OPERATOR_CHAT_ALLOWED_TOOLS);
-        const customTools = await this.loadCustomTools();
+        const customTools = await this.loadCustomTools(init.sessionId);
         const { session } = await this.bindings.createSessionFromServices({
             services,
             sessionManager: init.sessionManager,
@@ -1943,6 +2089,16 @@ export class ConsolePiRuntime {
     open(sessionId) {
         return this.sessions.get(sessionId);
     }
+    /** Inject one queued message into the currently running Pi turn. */
+    async steer(sessionId, text, images) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !this.promptOwners.has(sessionId) || session.isStreaming === false) {
+            throw new Error("CHAT_TURN_NOT_ACTIVE");
+        }
+        if (typeof session.steer !== "function")
+            throw new Error("CHAT_STEER_UNAVAILABLE");
+        await session.steer(text, images);
+    }
     hasSession(sessionId) {
         return this.sessions.has(sessionId);
     }
@@ -1997,6 +2153,12 @@ export class ConsolePiRuntime {
             }
         };
         try {
+            if (options?.turnId && this.options.questionRegistry) {
+                this.options.questionRegistry.setTurn(sessionId, options.turnId);
+            }
+            if (options?.turnId && this.options.todoRegistry) {
+                this.options.todoRegistry.startTurn(sessionId, options.turnId);
+            }
             // AC-FIX-002: if Stop already fired before readiness, never start model work.
             if (options?.signal?.aborted) {
                 return;
@@ -2050,19 +2212,77 @@ export class ConsolePiRuntime {
                 }
             };
             emitContextUsage();
+            let stepStartedAt;
+            let firstTokenAt;
+            let pendingProviderError;
+            let providerErrorEmitted = false;
+            const emitPendingProviderError = () => {
+                if (!pendingProviderError)
+                    return;
+                onEvent(pendingProviderError);
+                pendingProviderError = undefined;
+                providerErrorEmitted = true;
+            };
             unsub = session.subscribe((event) => {
+                const observedAt = Date.now();
                 const mapped = mapSdkEvent(sessionId, event);
-                if (mapped)
-                    onEvent(mapped);
+                if (mapped?.type === "error") {
+                    // Pi represents provider failures as an assistant message_end and may
+                    // retry internally. Hold the candidate until the SDK says the attempt
+                    // is terminal; a later successful message_end supersedes it.
+                    pendingProviderError = mapped;
+                    stepStartedAt = undefined;
+                    firstTokenAt = undefined;
+                    return;
+                }
+                if (mapped?.type === "message_end")
+                    pendingProviderError = undefined;
+                if ((mapped?.type === "agent_end" && !mapped.willRetry) ||
+                    mapped?.type === "agent_settled") {
+                    emitPendingProviderError();
+                }
+                if (mapped?.type === "agent_start") {
+                    stepStartedAt = observedAt;
+                    firstTokenAt = undefined;
+                }
+                if (mapped?.type === "message_update" && firstTokenAt === undefined) {
+                    firstTokenAt = observedAt;
+                }
                 // Pi puts per-assistant-message usage on `message.usage` ({ input, output,
                 // cacheRead, cacheWrite, totalTokens, cost }). Emit on message_end so
                 // multi-step tool turns accumulate like pi-web SessionInfoBar; turn_end
                 // repeats the final message and must not double-count.
-                if (event.type === "message_end") {
+                if (mapped?.type === "message_end") {
                     const usage = extractUsageSample(event);
+                    const timing = stepStartedAt === undefined
+                        ? undefined
+                        : {
+                            llmMs: Math.max(0, observedAt - stepStartedAt),
+                            ...(firstTokenAt === undefined
+                                ? {}
+                                : {
+                                    ttftMs: Math.max(0, firstTokenAt - stepStartedAt),
+                                    decodeMs: Math.max(0, observedAt - firstTokenAt),
+                                }),
+                            ...(usage?.outputTokens === undefined
+                                ? {}
+                                : { outputTokens: usage.outputTokens }),
+                        };
+                    onEvent({ ...mapped, ...(timing ? { timing } : {}) });
                     if (usage)
                         onEvent({ type: "usage", sessionId, usage });
                     emitContextUsage();
+                    stepStartedAt = undefined;
+                    firstTokenAt = undefined;
+                }
+                else if (mapped) {
+                    onEvent(mapped);
+                    if (mapped.type === "tool_result") {
+                        // The next model request starts after the final completed tool. If
+                        // tools run concurrently, the last result naturally wins.
+                        stepStartedAt = observedAt;
+                        firstTokenAt = undefined;
+                    }
                 }
                 // Keep the context fill bar live through the turn (pi-web SessionInfoBar).
                 if (event.type === "agent_start" ||
@@ -2094,6 +2314,7 @@ export class ConsolePiRuntime {
                 // User abort is closed out as Turn state `aborted`; do not publish a
                 // red ordinary error event for intentional Stop.
                 if (!options?.signal?.aborted) {
+                    emitPendingProviderError();
                     onEvent({ type: "agent_settled", sessionId });
                 }
             }
@@ -2104,8 +2325,16 @@ export class ConsolePiRuntime {
                     // User abort: swallow ordinary error publication (AC-FIX-003).
                     return;
                 }
-                const message = error instanceof Error ? error.message : String(error);
-                onEvent({ type: "error", sessionId, message });
+                emitPendingProviderError();
+                if (!providerErrorEmitted) {
+                    const providerError = parseProviderError(error);
+                    onEvent({
+                        type: "error",
+                        sessionId,
+                        message: providerError.message,
+                        providerError,
+                    });
+                }
                 throw error;
             }
             finally {
@@ -2114,6 +2343,8 @@ export class ConsolePiRuntime {
             }
         }
         finally {
+            if (this.options.questionRegistry)
+                this.options.questionRegistry.clearTurn(sessionId);
             this.promptOwners.delete(sessionId);
         }
     }
@@ -2243,6 +2474,23 @@ export class ConsolePiRuntime {
     }
 }
 function mapAssistantMessageEvent(type, sessionId, message) {
+    const record = message !== null && typeof message === "object"
+        ? message
+        : undefined;
+    if (type === "message_end" &&
+        record?.stopReason === "error") {
+        const content = extractAssistantContentBlocks(message);
+        const providerError = parseProviderError(typeof record.errorMessage === "string"
+            ? record.errorMessage
+            : "Provider request failed");
+        return {
+            type: "error",
+            sessionId,
+            message: providerError.message,
+            providerError,
+            ...(content.length > 0 ? { content } : {}),
+        };
+    }
     const content = extractAssistantContentBlocks(message);
     return {
         type,

package/dist/worker/console/chat/provider-error.js

@@ -0,0 +1,98 @@
+const MAX_RAW_CHARS = 8_000;
+const MAX_MESSAGE_CHARS = 1_000;
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function bounded(value, limit) {
+    return value.length <= limit ? value : `${value.slice(0, limit - 1)}…`;
+}
+function scrub(value) {
+    return value
+        .replace(/((?:authorization|api[-_]?key|access[-_]?token|refresh[-_]?token|secret)["']?\s*[:=]\s*["']?)([^"'\s,}]+)/gi, "$1[REDACTED]")
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [REDACTED]");
+}
+function parseEnvelope(raw) {
+    const candidates = [raw];
+    const start = raw.indexOf("{");
+    const end = raw.lastIndexOf("}");
+    if (start >= 0 && end > start)
+        candidates.push(raw.slice(start, end + 1));
+    for (const candidate of candidates) {
+        try {
+            const record = asRecord(JSON.parse(candidate));
+            if (record)
+                return record;
+        }
+        catch {
+            // Plain text and HTTP-prefixed provider errors are expected here.
+        }
+    }
+    return undefined;
+}
+function stringField(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function codeField(record) {
+    const value = record?.code ?? record?.status ?? record?.statusCode;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const trimmed = value.trim();
+        return /^\d{3}$/.test(trimmed) ? Number(trimmed) : trimmed;
+    }
+    return undefined;
+}
+function classify(input) {
+    const haystack = `${input.message}\n${input.raw}`.toLowerCase();
+    const status = typeof input.code === "number" ? input.code : undefined;
+    if (status === 401 ||
+        status === 403 ||
+        /认证|鉴权|unauthori[sz]ed|forbidden|authentication|invalid api[-_ ]?key/.test(haystack))
+        return "authentication";
+    if (/请求上下文过大|上下文.{0,12}(?:过大|太大|过长|超限)|context_length_exceeded|maximum context|context.{0,24}(?:length|window|limit|large|long)|too many tokens/.test(haystack))
+        return "context-overflow";
+    if (status === 429 ||
+        /rate.?limit|too many requests|请求.{0,8}(?:频繁|过多)|限流/.test(haystack))
+        return "rate-limit";
+    return "provider";
+}
+/** Convert an SDK/provider error into a bounded durable timeline projection. */
+export function parseProviderError(value) {
+    const source = typeof value === "string"
+        ? value
+        : value instanceof Error
+            ? value.message
+            : String(value ?? "Provider request failed");
+    const raw = bounded(scrub(source.trim()), MAX_RAW_CHARS);
+    const envelope = parseEnvelope(raw);
+    const nested = asRecord(envelope?.error);
+    const firstLine = raw.split(/\r?\n/, 1)[0]?.trim();
+    const message = bounded(stringField(nested, "message") ??
+        stringField(envelope, "message") ??
+        (firstLine || undefined) ??
+        "Provider request failed", MAX_MESSAGE_CHARS);
+    const code = codeField(nested) ?? codeField(envelope);
+    const type = stringField(nested, "type") ?? stringField(envelope, "type");
+    return {
+        message,
+        raw,
+        ...(code === undefined ? {} : { code }),
+        ...(type ? { type } : {}),
+        category: classify({ message, raw, code }),
+    };
+}
+export function providerErrorTitle(category) {
+    switch (category) {
+        case "authentication":
+            return "认证失败";
+        case "context-overflow":
+            return "上下文过大";
+        case "rate-limit":
+            return "请求过于频繁";
+        default:
+            return "Provider 请求失败";
+    }
+}