@tea-agent/loop-agent 0.43.0-next.1 → 0.43.0-next.11

package/dist/task/source-prepare/source-fidelity-pi.js

@@ -1,3 +1,6 @@
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { observeFrontendSession } from "../../workflows/dag/frontend-session-budget.js";
 /**
  * 生产 Source Fidelity Pi 适配器（AC-PROD-001..006 / AC-001..006）
  *
@@ -22,7 +25,7 @@ import { resolveDagPiModelConfig } from "../../executors/dag-pi-executor.js";
 import { resolveExecutorModelMatrices } from "../../executors/model-routing.js";
 import { listPiSdkAvailableModels } from "../../executors/pi-sdk-executor.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
-import { loadTaskConfig } from "../runtime.js";
+import { getTaskPaths, loadTaskConfig } from "../runtime.js";
 import { buildSemanticIntakeModelQueue, extractJsonObject, } from "./semantic-intake.js";
 import { LEDGER_RECONCILIATION_DEFAULT_BUDGET_CHARS, LedgerReconciliationError, } from "./ledger-reconciliation.js";
 import { LedgerReviewError, } from "./ledger-review.js";
@@ -66,7 +69,7 @@ const reviewResponseSchema = z.object({
         disposition: z.enum(FRAGMENT_DISPOSITIONS).optional(),
         reason: z.string().min(1).optional(),
     })
-        .optional(),
+        .nullish(),
 });
 /**
  * 模型队列构建镜像 semantic-intake.ts：MED→HIGH→LOW（harness executors.pi）+
@@ -112,7 +115,7 @@ function buildReconciliationPrompt(request) {
         `fragment path: ${request.fragment.path}`,
         `fragment headingPath: ${request.fragment.headingPath}`,
         `fragment lineRange: ${JSON.stringify(request.fragment.lineRange)}`,
-        `budgetChars: ${request.budgetChars}`,
+        `packing hint: ${request.budgetChars} chars; the fragment below is complete and must not be truncated or summarized before deciding`,
         "fragment text:",
         "```markdown",
         request.fragment.text,
@@ -131,7 +134,7 @@ function buildReviewPrompt(request) {
         "- approved: true only when the exclusion/conflict handling is justified.",
         "- fragmentId: MUST equal the requested fragment id exactly (echo the `fragment id:` line verbatim); identity mismatch is rejected.",
         "- reason: recommended; explain the verdict.",
-        "- revision: optional single bounded revision {disposition, reason}; never invent requirements or human resolutions.",
+        "- revision: omit or use null when no revision is proposed; otherwise one bounded revision {disposition, reason}. Never invent requirements or human resolutions.",
         JSON.stringify({
             fragmentId: "REQ-SRC-AB12CD34EF56",
             approved: true,
@@ -247,7 +250,11 @@ export async function runProductionLedgerReconciliation(request, options) {
     let lastFailure = "";
     for (const modelRef of queue) {
         try {
-            const result = await execute({
+            const result = await observeFrontendSession({
+                phase: "source-reconciliation", userMessage: "Reconcile the source fragment into the required JSON only.", sourceDigest: createHash("sha256").update(JSON.stringify(request)).digest("hex"), scopeIds: [request.fragment.id], prompt, model: modelRef, taskId: options.taskId, sink: options.observationSink,
+                artifactPath: options.taskId ? path.join(getTaskPaths(options.repoRoot, options.taskId).taskDir, "artifacts", "session-budget", `${randomUUID()}.json`) : undefined,
+            }, observer => execute({
+                onAttemptObservation: observer,
                 attachedFiles: [],
                 modelConfig: resolveDagPiModelConfig(modelRef),
                 prompt,
@@ -266,10 +273,14 @@ export async function runProductionLedgerReconciliation(request, options) {
                         return [error instanceof Error ? error.message : String(error)];
                     }
                 },
-            });
+            }));
             if (!result.ok) {
                 lastFailure =
                     `${result.failureCategory}: ${(result.stderr || result.assistantText).slice(0, 2000)}`;
+                if (result.stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(result.failureCategory)) {
+                    lastFailure = `SOURCE_FIDELITY_CAPACITY_EXHAUSTED: refine this complete source fragment without losing conditions; ${lastFailure}`;
+                    break;
+                }
                 continue;
             }
             try {
@@ -306,7 +317,11 @@ export async function runProductionLedgerReview(request, options) {
     let lastFailure = "";
     for (const modelRef of queue) {
         try {
-            const result = await execute({
+            const result = await observeFrontendSession({
+                phase: "source-review", userMessage: "Review the fragment disposition into the required JSON only.", sourceDigest: createHash("sha256").update(JSON.stringify(request)).digest("hex"), scopeIds: [request.fragment.id], prompt, model: modelRef, taskId: options.taskId, sink: options.observationSink,
+                artifactPath: options.taskId ? path.join(getTaskPaths(options.repoRoot, options.taskId).taskDir, "artifacts", "session-budget", `${randomUUID()}.json`) : undefined,
+            }, observer => execute({
+                onAttemptObservation: observer,
                 attachedFiles: [],
                 modelConfig: resolveDagPiModelConfig(modelRef),
                 prompt,
@@ -325,10 +340,14 @@ export async function runProductionLedgerReview(request, options) {
                         return [error instanceof Error ? error.message : String(error)];
                     }
                 },
-            });
+            }));
             if (!result.ok) {
                 lastFailure =
                     `${result.failureCategory}: ${(result.stderr || result.assistantText).slice(0, 2000)}`;
+                if (result.stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(result.failureCategory)) {
+                    lastFailure = `SOURCE_FIDELITY_CAPACITY_EXHAUSTED: refine this complete source fragment without losing conditions; ${lastFailure}`;
+                    break;
+                }
                 continue;
             }
             try {
@@ -380,5 +399,5 @@ export async function resolveProductionSourceFidelityPi(input) {
     }
     if (effectiveTaskKind !== SOURCE_FIDELITY_TASK_KIND)
         return undefined;
-    return createProductionSourceFidelityPi({ repoRoot: input.repoRoot });
+    return createProductionSourceFidelityPi({ repoRoot: input.repoRoot, taskId: input.taskId });
 }

package/dist/task/source-references.js

@@ -5,7 +5,7 @@
  * source/references/, separate from the derived source/需求.md contract.
  */
 import { createHash } from "node:crypto";
-import { access, copyFile, mkdir, readdir, readFile, writeFile, } from "node:fs/promises";
+import { access, copyFile, lstat, mkdir, readdir, readFile, writeFile, } from "node:fs/promises";
 import path from "node:path";
 import { getTaskPaths, loadTaskConfig } from "./runtime.js";
 import { writeTaskConfig } from "../infrastructure/harness/task-store.js";
@@ -87,6 +87,7 @@ export async function materializeTaskReferenceDocs(input) {
     const referenceDir = path.join(paths.sourceDir, SOURCE_REFERENCE_DIRECTORY);
     await mkdir(referenceDir, { recursive: true });
     const materialized = [];
+    const manifest = await readSourceManifest(paths.sourceDir);
     for (const doc of docs) {
         const absoluteSource = path.isAbsolute(doc.path)
             ? doc.path
@@ -94,7 +95,10 @@ export async function materializeTaskReferenceDocs(input) {
         await assertReadableFile(absoluteSource, `referenceDocs entry "${doc.name ?? doc.path}"`);
         const extension = path.extname(absoluteSource) || ".md";
         const baseName = slugifyName(doc.name ?? path.basename(absoluteSource, extension));
-        const targetName = `${baseName}${extension}`;
+        const imported = manifest?.documents.find((entry) => path.basename(entry.materializedPath, path.extname(entry.materializedPath)) === baseName);
+        const targetName = imported
+            ? path.basename(imported.materializedPath)
+            : `${baseName}${extension}`;
         const targetPath = path.join(referenceDir, targetName);
         try {
             await access(targetPath);
@@ -132,14 +136,23 @@ export async function importPrdDocument(input) {
     catch {
         // directory may be empty / just created
     }
-    // Prefer stable name "requirement.md" when free; otherwise suffix.
-    const preferredName = `${requestedName}${extension}`;
-    const targetFileName = existingNames.has(preferredName)
-        ? // If the same content is already there, reuse; else unique name.
-            (await sameHashIfExists(path.join(referenceDir, preferredName), hash.sha256))
-                ? preferredName
-                : ensureUniqueReferenceName(existingNames, requestedName, extension)
-        : preferredName;
+    // Search every immutable reference, including suffixed and renamed imports.
+    // Roles remain distinct: identical bytes must not erase a constraint/AC role.
+    const matching = existingManifest?.documents.find((doc) => doc.role === role && doc.sha256 === hash.sha256 && doc.bytes === hash.bytes);
+    if (matching) {
+        const candidate = path.resolve(paths.sourceDir, matching.materializedPath);
+        if (path.dirname(candidate) !== path.resolve(referenceDir)) {
+            throw new Error(`REFERENCE_PATH_UNSAFE: ${matching.materializedPath}`);
+        }
+        const stats = await lstat(candidate);
+        if (!stats.isFile() || stats.isSymbolicLink() ||
+            !(await sameHashIfExists(candidate, hash.sha256))) {
+            throw new Error(`REFERENCE_HASH_MISMATCH: ${matching.materializedPath}`);
+        }
+    }
+    const targetFileName = matching
+        ? path.basename(matching.materializedPath)
+        : ensureUniqueReferenceName(existingNames, requestedName, extension);
     const targetPath = path.join(referenceDir, targetFileName);
     if (!(await fileExists(targetPath))) {
         await writeFile(targetPath, hash.content);
@@ -149,7 +162,7 @@ export async function importPrdDocument(input) {
         ? toPosixRelative(input.repoRoot, absoluteSource)
         : input.filePath.split(path.sep).join("/");
     const materializedRelativePath = `${SOURCE_REFERENCE_DIRECTORY}/${targetFileName}`;
-    const document = {
+    const document = matching ?? {
         role,
         name: requestedName,
         sourcePath: sourcePathForRecord,
@@ -176,20 +189,28 @@ export async function importPrdDocument(input) {
             : (existingManifest?.updatedAt ?? importedAt),
         documents,
     };
-    await writeSourceManifest(paths.sourceDir, manifest);
+    if (documentSetChanged)
+        await writeSourceManifest(paths.sourceDir, manifest);
     const taskConfig = await loadTaskConfig(input.repoRoot, input.taskId);
     const referenceDocs = [...(taskConfig.referenceDocs ?? [])];
-    const alreadyListed = referenceDocs.some((doc) => {
+    const listedIndex = referenceDocs.findIndex((doc) => {
         const absolute = path.isAbsolute(doc.path)
             ? doc.path
             : path.resolve(input.repoRoot, doc.path);
         return absolute === absoluteSource;
     });
-    if (!alreadyListed) {
-        referenceDocs.push({
-            name: requestedName,
-            path: sourcePathForRecord,
-        });
+    // Keep original source paths as provenance, but point materialization at
+    // the chosen immutable filename so DAG generation cannot recreate duplicates.
+    const reference = {
+        name: path.basename(targetFileName, path.extname(targetFileName)),
+        path: sourcePathForRecord,
+    };
+    const configChanged = listedIndex < 0 || referenceDocs[listedIndex]?.name !== reference.name;
+    if (configChanged) {
+        if (listedIndex < 0)
+            referenceDocs.push(reference);
+        else
+            referenceDocs[listedIndex] = { ...referenceDocs[listedIndex], ...reference };
         await writeTaskConfig(input.repoRoot, input.taskId, {
             ...taskConfig,
             referenceDocs,
@@ -198,11 +219,15 @@ export async function importPrdDocument(input) {
     // Managed contracts must bump revision after import-prd mutates manifest/task config.
     // Lazy import avoids circular init with contract/observe.
     const { refreshManagedContractAfterImport } = await import("./contract/import-revision.js");
-    await refreshManagedContractAfterImport({
-        repoRoot: input.repoRoot,
-        taskId: input.taskId,
-    });
+    const changed = documentSetChanged || configChanged;
+    if (changed) {
+        await refreshManagedContractAfterImport({
+            repoRoot: input.repoRoot,
+            taskId: input.taskId,
+        });
+    }
     return {
+        changed,
         taskId: input.taskId,
         sourcePath: sourcePathForRecord,
         materializedAbsolutePath: targetPath,
@@ -210,7 +235,7 @@ export async function importPrdDocument(input) {
         sha256: hash.sha256,
         bytes: hash.bytes,
         manifestPath: getSourceManifestPath(paths.sourceDir),
-        referenceDocs: alreadyListed ? referenceDocs : [...referenceDocs],
+        referenceDocs,
     };
 }
 async function sameHashIfExists(filePath, sha256) {

package/dist/worker/console/chat/assistant-content.js

@@ -115,9 +115,30 @@ export function splitFinalAssistantBlocks(blocks, options = {}) {
     if (lastProcessIndex === -1) {
         return { answerBlocks: displayable, processBlocks: [] };
     }
+    const trailing = displayable.slice(lastProcessIndex + 1);
+    if (trailing.length > 0) {
+        return {
+            answerBlocks: trailing,
+            processBlocks: displayable.slice(0, lastProcessIndex + 1),
+        };
+    }
+    // The stage ends on a non-text block (a tool call after the prose, or a final
+    // thinking block). Returning an empty answer here hid the whole reply inside
+    // the collapsed process subtree; keep the last prose block as the visible
+    // answer instead (2026-09-08).
+    let lastTextIndex = -1;
+    for (let i = displayable.length - 1; i >= 0; i--) {
+        if (isFinalAnswerBlock(displayable[i])) {
+            lastTextIndex = i;
+            break;
+        }
+    }
+    if (lastTextIndex === -1) {
+        return { answerBlocks: [], processBlocks: displayable };
+    }
     return {
-        answerBlocks: displayable.slice(lastProcessIndex + 1),
-        processBlocks: displayable.slice(0, lastProcessIndex + 1),
+        answerBlocks: [displayable[lastTextIndex]],
+        processBlocks: displayable.filter((_block, index) => index !== lastTextIndex),
     };
 }
 export function joinAssistantText(blocks) {

package/dist/worker/console/chat/browser-policy.js

@@ -0,0 +1,113 @@
+/**
+ * Pure URL policy for the Operator Chat browser panel: normalize user input
+ * into an http(s) URL. Dependency-free so it is unit-testable.
+ *
+ * Only the scheme is gated: javascript:, data:, file: and friends must never
+ * reach the iframe. Local addresses (localhost / 127.0.0.1 / ::1 / LAN
+ * hosts) are deliberately allowed — the panel is a development console and
+ * its users routinely browse local dev servers.
+ */
+/**
+ * Extract the `frame-ancestors` source list of a Content-Security-Policy
+ * header, or undefined when the directive is absent (or empty).
+ */
+export function extractFrameAncestors(csp) {
+    if (csp === null)
+        return undefined;
+    for (const directive of csp.split(";")) {
+        const parts = directive.trim().split(/\s+/);
+        if (parts[0] === "frame-ancestors") {
+            const sources = parts.slice(1).filter((source) => source !== "");
+            return sources.length === 0 ? undefined : sources;
+        }
+    }
+    return undefined;
+}
+/**
+ * Decide whether a site can render inside the panel iframe. The signals are
+ * exactly the ones the browser enforces when it refuses an iframe load:
+ * X-Frame-Options DENY/SAMEORIGIN, or a frame-ancestors directive that does
+ * not allow `*` ('self' means the SITE's own origin — never ours, so it also
+ * blocks the panel). A site we could not reach yields 'unknown' and the
+ * plain iframe stays.
+ */
+export function embeddabilityOf(probe) {
+    if (probe.reachable !== true)
+        return "unknown";
+    const xfo = probe.xFrameOptions?.trim().toUpperCase();
+    if (xfo === "DENY" || xfo === "SAMEORIGIN")
+        return "blocked";
+    if (probe.frameAncestors !== undefined &&
+        !probe.frameAncestors.some((source) => source === "*")) {
+        return "blocked";
+    }
+    return "embeddable";
+}
+/**
+ * Schemes that must never reach the iframe even without `//` (javascript:,
+ * data:, file:, ...). Host:port lookalikes (example.com:8080) are NOT here —
+ * they parse as hosts below.
+ */
+const FORBIDDEN_SCHEMES = new Set([
+    "javascript",
+    "data",
+    "file",
+    "about",
+    "vbscript",
+    "blob",
+    "mailto",
+    "tel",
+    "ftp",
+    "ftps",
+    "ws",
+    "wss",
+    "sftp",
+    "ssh",
+    "chrome",
+    "chrome-extension",
+    "moz-extension",
+    "edge",
+    "opera",
+    "resource",
+    "view-source",
+]);
+/**
+ * Normalize one address-bar input against the navigation policy.
+ * @param input raw user text.
+ */
+export function normalizeBrowserUrl(input) {
+    const trimmed = input.trim();
+    if (trimmed === "")
+        return { kind: "invalid" };
+    // Distinguish an explicit scheme from a bare host:port. "example.com:8080"
+    // would match a naive scheme regex (dots are legal in schemes), so a
+    // scheme prefix is only honored when it is http(s) or a known-forbidden
+    // scheme; anything else is treated as a host and gets https://.
+    const schemeMatch = /^([a-zA-Z][a-zA-Z0-9+.-]*):/.exec(trimmed);
+    let withScheme;
+    if (schemeMatch === null) {
+        withScheme = `https://${trimmed}`;
+    }
+    else {
+        const scheme = schemeMatch[1]?.toLowerCase() ?? "";
+        if (scheme === "http" || scheme === "https")
+            withScheme = trimmed;
+        else if (FORBIDDEN_SCHEMES.has(scheme))
+            return { kind: "blocked", reason: "scheme" };
+        else
+            withScheme = `https://${trimmed}`;
+    }
+    let url;
+    try {
+        url = new URL(withScheme);
+    }
+    catch {
+        return { kind: "invalid" };
+    }
+    // Protocol backstop: any URL that still parses to a non-http(s) scheme
+    // (ftp://, ws:// — which carry `//` and skip the list) is refused here.
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        return { kind: "blocked", reason: "scheme" };
+    }
+    return { kind: "ok", url: url.href };
+}

package/dist/worker/console/chat/browser-routes.js

@@ -0,0 +1,140 @@
+/**
+ * HTTP routes for the Operator Chat browser panel: one read-only probe
+ * endpoint the panel uses to explain an iframe refusal (X-Frame-Options /
+ * CSP frame-ancestors are exactly the signals the browser enforces when it
+ * refuses to embed a site). The probe is display-only (headers back to the
+ * caller), restricted to http(s) URLs, with a hard timeout. Local addresses
+ * are allowed — the panel routinely browses local dev servers.
+ */
+import { embeddabilityOf, extractFrameAncestors, } from "./browser-policy.js";
+function workspaceIdOf(req) {
+    try {
+        return new URL(req.url ?? "/", "http://localhost").searchParams.get("workspaceId") ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sendJson(res, status, body) {
+    res.writeHead(status, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store",
+    });
+    res.end(JSON.stringify(body));
+}
+/** Route dispatcher; returns true when the request was handled. */
+export async function handleBrowserRequest(req, res, deps, pathname) {
+    if (!pathname.startsWith("/api/operator/v1/chat/browser"))
+        return false;
+    const method = (req.method ?? "GET").toUpperCase();
+    const rest = pathname.slice("/api/operator/v1/chat/browser".length);
+    const parts = rest.split("/").filter(Boolean);
+    const sub = parts[0] ?? "";
+    try {
+        if (method === "GET" && sub === "probe" && parts.length === 1) {
+            // Fail-closed: the probe needs a workspaceId like every chat API.
+            if (deps.requireWorkspace) {
+                const ws = deps.requireWorkspace(req);
+                if (!ws.ok) {
+                    sendJson(res, 400, {
+                        ok: false,
+                        error: { code: "WORKSPACE_REQUIRED", message: "workspaceId is required" },
+                    });
+                    return true;
+                }
+            }
+            else if (!workspaceIdOf(req)) {
+                sendJson(res, 400, {
+                    ok: false,
+                    error: { code: "WORKSPACE_REQUIRED", message: "workspaceId is required" },
+                });
+                return true;
+            }
+            const url = new URL(req.url ?? "/", "http://localhost");
+            const raw = url.searchParams.get("url") ?? "";
+            let parsed;
+            try {
+                parsed = new URL(raw);
+            }
+            catch {
+                sendJson(res, 400, {
+                    ok: false,
+                    error: { code: "INVALID_URL", message: "invalid url" },
+                });
+                return true;
+            }
+            if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+                sendJson(res, 400, {
+                    ok: false,
+                    error: { code: "BAD_SCHEME", message: "only http/https urls can be probed" },
+                });
+                return true;
+            }
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 8000);
+            try {
+                let response = await fetch(parsed, {
+                    method: "HEAD",
+                    redirect: "follow",
+                    signal: controller.signal,
+                });
+                // Some servers answer HEAD with 405/501; retry once as GET
+                // (the body is discarded — only the headers matter).
+                if (response.status === 405 || response.status === 501) {
+                    response = await fetch(parsed, {
+                        method: "GET",
+                        redirect: "follow",
+                        signal: controller.signal,
+                    });
+                }
+                const csp = response.headers.get("content-security-policy");
+                const frameAncestors = extractFrameAncestors(csp);
+                const xFrameOptions = response.headers.get("x-frame-options");
+                const probe = {
+                    reachable: true,
+                    url: response.url,
+                    status: response.status,
+                    ...(xFrameOptions !== null ? { xFrameOptions } : {}),
+                    ...(frameAncestors !== undefined ? { frameAncestors } : {}),
+                };
+                sendJson(res, 200, {
+                    ok: true,
+                    data: { probe, verdict: embeddabilityOf(probe) },
+                });
+                return true;
+            }
+            catch {
+                // DNS / TLS / connection / timeout: nothing to judge — the
+                // client keeps the plain iframe.
+                sendJson(res, 200, {
+                    ok: true,
+                    data: { probe: { reachable: false }, verdict: "unknown" },
+                });
+                return true;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }
+        sendJson(res, 404, {
+            ok: false,
+            error: { code: "NOT_FOUND", message: `unknown browser route: ${method} ${pathname}` },
+        });
+        return true;
+    }
+    catch (error) {
+        if (!res.headersSent) {
+            sendJson(res, 500, {
+                ok: false,
+                error: {
+                    code: "BROWSER_INTERNAL",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+        else {
+            res.end();
+        }
+        return true;
+    }
+}

package/dist/worker/console/chat/explore-tools.js

@@ -71,6 +71,10 @@ export const SECRET_SCRUB_PATTERNS = [
         name: "private-key-block",
         re: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |)PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA |)PRIVATE KEY-----/g,
     },
+    {
+        name: "aimax-auth-token",
+        re: /\bAIMAX_AUTH_TOKEN=["']?[^\s"']+/g,
+    },
 ];
 /** Throw a typed explore error (kept as a value object so callers can read .code). */
 export class ExploreDeniedError extends Error {
@@ -89,6 +93,10 @@ export class ExploreDeniedError extends Error {
  */
 export function scrubSecrets(input) {
     let out = input;
+    const liveToken = process.env.AIMAX_AUTH_TOKEN;
+    if (liveToken && liveToken.length >= 8 && out.includes(liveToken)) {
+        out = out.split(liveToken).join("[REDACTED:aimax-auth-token]");
+    }
     const redactions = [];
     for (const { name, re } of SECRET_SCRUB_PATTERNS) {
         re.lastIndex = 0;
@@ -98,6 +106,11 @@ export function scrubSecrets(input) {
             redactions.push({ name, count: matches.length });
         }
     }
+    if (liveToken && liveToken.length >= 8 && input.includes(liveToken)) {
+        const existing = redactions.find((entry) => entry.name === "aimax-auth-token");
+        if (!existing)
+            redactions.push({ name: "aimax-auth-token", count: 1 });
+    }
     return { scrubbed: out, redactions };
 }
 /** True if a repo-relative path matches a sensitive-file denylist pattern. */

package/dist/worker/console/chat/pi-runtime/custom-tools/ask-user-question.js

@@ -0,0 +1,44 @@
+/**
+ * Session-bound ask_user_question custom tool.
+ * ConsolePiRuntime supplies the sessionId and UserQuestionRegistry.
+ */
+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).";
+export 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,
+            };
+        },
+    });
+}