@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.10

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

@@ -13,10 +13,11 @@
  * Read routes (GET capabilities / sessions) are open to loopback.
  */
 import { randomUUID } from "node:crypto";
+import { access } from "node:fs/promises";
 import { parseAssistantContent } from "./assistant-content.js";
 import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS, } from "./tools.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
-import { cleanChatTitle, acceptedOperationIdFromResult } from "./session-store.js";
+import { cleanChatTitle, acceptedOperationIdFromResult, isBlankChatSession } from "./session-store.js";
 import { hashChatTurnPayload, projectChatToolEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
 import { projectDeferredTurnSummary, projectDeferredTurnSummaries, } from "./deferred-turn.js";
 import { THINKING_LEVELS, RuntimeSnapshotUnavailableError, } from "./pi-runtime.js";
@@ -42,6 +43,12 @@ import { buildTodoCompactionInstructions, projectCurrentTodos } from "./todos.js
 import { buildGoalCompactionInstructions, buildGoalContinuationContext, } from "./goals.js";
 import { classifyGoalRoundAdmission, } from "./goal-round-driver.js";
 import { isTerminalOperationState } from "../../../infrastructure/console/operation-store.js";
+import { SddDataAlignmentError, } from "./sdd-data-alignment.js";
+function projectBrowserChatSession(record) {
+    const { telemetrySessionId, ...projected } = record;
+    void telemetrySessionId;
+    return projected;
+}
 /**
  * Reattach the durable event-ring order to session-store rows. The session
  * store remains the content authority; the ring only supplies chronology.
@@ -468,7 +475,7 @@ function sendRuntimeUnavailable(res, error) {
  * handled here — only reopen/init readiness failures.
  */
 function mapReopenSessionFailure(reopen) {
-    if (reopen.code === "NO_SESSION_FILE") {
+    if (reopen.code === "NO_SESSION_FILE" || reopen.code === "SESSION_FILE_MISSING") {
         return {
             status: 404,
             code: "PI_SESSION_NOT_FOUND",
@@ -488,6 +495,19 @@ function mapReopenSessionFailure(reopen) {
         message: reopen.message,
     };
 }
+/** Drop an orphan catalog record whose promised Pi JSONL is gone. */
+async function healMissingSessionFile(deps, sessionId, reopen) {
+    if (reopen && reopen.code !== "NO_SESSION_FILE" && reopen.code !== "SESSION_FILE_MISSING") {
+        return;
+    }
+    if (typeof deps.store.remove !== "function")
+        return;
+    await deps.store.remove(sessionId).catch(() => undefined);
+}
+async function mapFailedReopen(deps, sessionId, reopen) {
+    await healMissingSessionFile(deps, sessionId, reopen);
+    return mapReopenSessionFailure(reopen);
+}
 export async function handleChatCapabilities(_req, res, deps) {
     const toolSchemas = buildModelCallableToolSchemas();
     sendJson(res, 200, {
@@ -555,9 +575,15 @@ workspaceId) {
         });
         return;
     }
+    let createdSessionId;
+    let persisted = false;
     try {
         const snapshot = snapshotInput === undefined ? undefined : projectCompactSnapshot(snapshotInput);
-        // Fast path: durable shell + Console record before full AgentSession ready.
+        // A Console record promises that its Pi JSONL can be reopened after a
+        // Console restart. Do not make that promise until Pi has finished
+        // materializing the session: the old fast path wrote a record for a
+        // future JSONL path, leaving an unrecoverable orphan when init failed or
+        // the process restarted in that window.
         const handle = await deps.runtime.createSession({
             ...(provider && modelId ? { model: { provider, modelId } } : {}),
             ...(snapshot
@@ -577,56 +603,51 @@ workspaceId) {
             });
             return;
         }
+        createdSessionId = handle.sessionId;
+        await deps.runtime.ensureSessionReady(handle.sessionId);
+        const selection = deps.runtime.getRuntimeSelection(handle.sessionId);
         const session = await deps.store.create({
             sessionId: handle.sessionId,
             sessionFile: handle.sessionFile,
-            modelProvider: handle.model?.provider,
-            modelId: handle.model?.modelId,
+            modelProvider: selection.model?.provider ?? handle.model?.provider,
+            modelId: selection.model?.modelId ?? handle.model?.modelId,
             // AC-R7-002: explicit parameter from the dispatcher — the runtime
             // store.create wrapper is gone; body workspaceId (if any) only acts as
             // a fallback for direct (non-dispatcher) handler tests.
             workspaceId: workspaceId ?? (typeof body.workspaceId === "string" && body.workspaceId ? body.workspaceId : undefined),
         });
+        persisted = true;
         await deps.attachSession?.(handle.sessionId).catch(() => undefined);
         if (snapshot)
             deps.events.append(handle.sessionId, `${handle.sessionId}:snapshot`, {
                 kind: "compact",
                 data: snapshot,
             });
-        // Best-effort: after materialization, patch resolved default model onto the
-        // durable record. Failures stay on the init fence (PI_SESSION_INIT_FAILED).
-        if (typeof deps.runtime.ensureSessionReady === "function") {
-            void deps.runtime
-                .ensureSessionReady(handle.sessionId)
-                .then(async () => {
-                if (typeof deps.runtime.getRuntimeSelection !== "function")
-                    return;
-                const selection = deps.runtime.getRuntimeSelection(handle.sessionId);
-                if (!selection?.model)
-                    return;
-                await deps.store.setRuntimeSelection(handle.sessionId, {
-                    modelProvider: selection.model.provider,
-                    modelId: selection.model.modelId,
-                });
-            })
-                .catch(() => undefined);
-        }
         sendJson(res, 201, {
             ok: true,
             sessionId: handle.sessionId,
             sessionFile: handle.sessionFile,
             model: handle.model,
-            session,
+            session: { ...session, isBlank: isBlankChatSession(session) },
             activeTools: handle.activeTools,
             hasBash: true,
-            ...(handle.initializing ? { initializing: true } : {}),
         });
     }
     catch (error) {
+        // Before store.create succeeds, this handle has no durable owner. Dispose
+        // it so a failed create cannot survive in-memory until the next restart.
+        if (createdSessionId && !persisted)
+            deps.runtime.dispose(createdSessionId);
         const message = error instanceof Error ? error.message : String(error);
-        sendJson(res, 500, {
+        const code = error && typeof error === "object" && "code" in error
+            ? String(error.code ?? "")
+            : "";
+        sendJson(res, code === "PI_SESSION_INIT_FAILED" ? 503 : 500, {
             ok: false,
-            error: { code: "CHAT_SESSION_CREATE_FAILED", message },
+            error: {
+                code: code === "PI_SESSION_INIT_FAILED" ? code : "CHAT_SESSION_CREATE_FAILED",
+                message,
+            },
         });
     }
 }
@@ -731,10 +752,7 @@ export async function handleBranchChatSession(req, res, deps, sessionId) {
                 sessionFile: record.sessionFile,
             });
             if (!reopened.ok) {
-                const mapped = mapReopenSessionFailure({
-                    code: reopened.code,
-                    message: reopened.message,
-                });
+                const mapped = await mapFailedReopen(deps, sessionId, reopened);
                 sendJson(res, mapped.status, {
                     ok: false,
                     error: { code: mapped.code, message: mapped.message },
@@ -809,7 +827,31 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
         });
         return;
     }
+    if (record.sessionFile) {
+        try {
+            await access(record.sessionFile);
+        }
+        catch (error) {
+            const code = error && typeof error === "object" && "code" in error
+                ? String(error.code ?? "")
+                : "";
+            if (code === "ENOENT") {
+                await healMissingSessionFile(deps, sessionId, {
+                    code: "NO_SESSION_FILE",
+                });
+                sendJson(res, 404, {
+                    ok: false,
+                    error: {
+                        code: "PI_SESSION_NOT_FOUND",
+                        message: `Pi session file missing or not openable: ${record.sessionFile}`,
+                    },
+                });
+                return;
+            }
+        }
+    }
     await deps.operationLinker.recoverSession(sessionId);
+    const messagePage = await deps.store.listMessages(sessionId, { limit: 50 });
     const composerDraft = await new ComposerDraftStore(deps.appData).get(sessionId);
     const snapshot = deps.events.snapshot(sessionId);
     const telemetry = deriveChatSessionTelemetry(snapshot);
@@ -820,8 +862,8 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
         ok: true,
         eventEpoch: deps.events.epoch(sessionId),
         session: {
-            ...record,
-            messages: projectStoredMessagesWithEventOrder(record.messages, snapshot),
+            ...projectBrowserChatSession(record),
+            messages: projectStoredMessagesWithEventOrder(messagePage.messages, snapshot),
             composerDraft,
             activeTurnId: activeTurn?.turnId,
             turnPhase: activeTurn
@@ -833,6 +875,10 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
             todos: projectCurrentTodos(snapshot) ?? [],
             goal: deps.goalRegistry?.get(sessionId) ?? null,
         },
+        history: {
+            hasMore: messagePage.hasMore,
+            ...(messagePage.nextCursor ? { nextCursor: messagePage.nextCursor } : {}),
+        },
         hasBash: true,
         sessionStats: telemetry.stats,
         usage: telemetry.usage,
@@ -1065,20 +1111,10 @@ export async function handleSteerDeferredTurn(req, res, deps, sessionId, clientR
     }
     const item = claim.deferredTurn;
     try {
-        await deps.runtime.steer(sessionId, item.text, item.images);
-        const userMessage = await deps.store.appendMessage(sessionId, {
-            role: "user",
-            text: item.text,
-        });
-        deps.events.append(sessionId, active.turnId, {
-            kind: "user_message",
-            data: {
-                clientRequestId: item.clientRequestId,
-                message: { id: userMessage.id, text: userMessage.text, at: userMessage.at },
-            },
-        });
-        await deps.store.clearDeferredTurnForRequest(sessionId, item.clientRequestId);
-        await emitDeferredTurnUpdate(deps, sessionId, active.turnId, undefined, item.revision + 2);
+        await deps.runtime.steer(sessionId, item.clientRequestId, item.text, item.images);
+        // session.steer() only acknowledges queueing. Keep the durable item in
+        // dispatching until Pi emits the corresponding user message_start.
+        await emitDeferredTurnUpdate(deps, sessionId, active.turnId, item, item.revision);
         sendJson(res, 200, {
             ok: true,
             accepted: true,
@@ -1102,6 +1138,21 @@ export async function handleSteerDeferredTurn(req, res, deps, sessionId, clientR
         });
     }
 }
+async function persistAcceptedSteering(deps, sessionId, turnId, userMessage, clientRequestId) {
+    deps.events.append(sessionId, turnId, {
+        kind: "user_message",
+        data: {
+            clientRequestId,
+            steering: true,
+            message: {
+                id: userMessage.id,
+                text: userMessage.text,
+                at: userMessage.at,
+            },
+        },
+    });
+    await emitDeferredTurnUpdate(deps, sessionId, turnId, undefined, 0);
+}
 /** Lightweight busy-truth endpoint for the client reconcile loop (pi-web
  *  get_state equivalent): exposes the active turn + the latest turn's durable
  *  outcome WITHOUT the full message payload, so the UI can poll it on an
@@ -1401,6 +1452,7 @@ export async function listChatSessionSummaries(deps, ownerWorkspaceId) {
                     : "idle",
             deferredTurn: projectDeferredTurnSummary(session.deferredTurns?.[0]),
             deferredTurns: projectDeferredTurnSummaries(session.deferredTurns ?? []),
+            isBlank: isBlankChatSession(session) && !active,
         };
     });
 }
@@ -1431,7 +1483,7 @@ export async function handlePatchChatSession(req, res, deps, sessionId) {
             });
             return;
         }
-        sendJson(res, 200, { ok: true, session: record });
+        sendJson(res, 200, { ok: true, session: projectBrowserChatSession(record) });
     }
     catch (error) {
         sendJson(res, 404, {
@@ -1481,10 +1533,7 @@ export async function handleReopenChatSession(req, res, deps, sessionId) {
             : {}),
     });
     if (!result.ok) {
-        const mapped = mapReopenSessionFailure({
-            code: result.code,
-            message: result.message,
-        });
+        const mapped = await mapFailedReopen(deps, sessionId, result);
         sendJson(res, mapped.status, {
             ok: false,
             error: { code: mapped.code, message: mapped.message },
@@ -1570,10 +1619,7 @@ export async function handleChatPrompt(req, res, deps, sessionId) {
                 : {}),
         });
         if (!reopen.ok) {
-            const mapped = mapReopenSessionFailure({
-                code: reopen.code,
-                message: reopen.message,
-            });
+            const mapped = await mapFailedReopen(deps, sessionId, reopen);
             sendJson(res, mapped.status, {
                 ok: false,
                 error: { code: mapped.code, message: mapped.message },
@@ -1661,6 +1707,9 @@ export async function handleChatPrompt(req, res, deps, sessionId) {
                 if (!res.writableEnded)
                     writeChatSse(res, persisted);
             },
+            onSteeringMessagePersisted: async (_record, userMessage, accepted) => {
+                await persistAcceptedSteering(deps, sessionId, turnId, userMessage, accepted.clientRequestId);
+            },
             onOperationAccepted: (accepted) => deps.operationLinker.link({
                 sessionId,
                 turnId,
@@ -1839,10 +1888,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId, trustedPay
                 : {}),
         });
         if (!reopen.ok) {
-            const mapped = mapReopenSessionFailure({
-                code: reopen.code,
-                message: reopen.message,
-            });
+            const mapped = await mapFailedReopen(deps, sessionId, reopen);
             sendJson(res, mapped.status, {
                 ok: false,
                 accepted: false,
@@ -1971,6 +2017,9 @@ export async function handleCreateChatTurn(req, res, deps, sessionId, trustedPay
                     if (placeholder)
                         emitSessionTitle(deps, sessionId, turn.turnId, placeholder);
                 },
+                onSteeringMessagePersisted: async (_record, userMessage, accepted) => {
+                    await persistAcceptedSteering(deps, sessionId, turn.turnId, userMessage, accepted.clientRequestId);
+                },
                 persistUserMessage: trustedPayload?.persistUserMessage,
                 onOperationAccepted: (accepted) => deps.operationLinker.link({
                     sessionId,
@@ -2646,13 +2695,13 @@ async function handleRepoHtmlPreview(res, deps, rawPath) {
             "Cache-Control": "no-store",
             "X-Content-Type-Options": "nosniff",
             "Referrer-Policy": "no-referrer",
-            // The iframe also has an empty sandbox attribute. This response-level
-            // sandbox keeps direct/popup loads isolated, while explicit local-origin
-            // style/image/font/media sources let relative project assets render.
+            // Project scripts may drive tabs and other local interactions, but the
+            // opaque sandbox still withholds same-origin access, forms, popups and
+            // top-level navigation. Network requests remain disabled below.
             "Content-Security-Policy": [
-                "sandbox",
+                "sandbox allow-scripts",
                 "default-src 'none'",
-                "script-src 'none'",
+                `script-src 'unsafe-inline' ${origin}`,
                 "object-src 'none'",
                 "frame-src 'none'",
                 "form-action 'none'",
@@ -2765,6 +2814,9 @@ export async function handleChatCommands(res, deps, sessionId) {
         res.end(JSON.stringify({
             ok: true,
             commands,
+            capabilities: {
+                sddBingo: Boolean(await deps.sddDataAlignment?.isEligible()),
+            },
             ...(warning ? { warning } : {}),
         }));
     }
@@ -2775,10 +2827,46 @@ export async function handleChatCommands(res, deps, sessionId) {
         res.end(JSON.stringify({
             ok: true,
             commands: [],
+            capabilities: { sddBingo: false },
             warning: error instanceof Error ? error.message : "commands unavailable",
         }));
     }
 }
+async function handleSddBingo(req, res, deps, sessionId) {
+    const gate = gateMutation(req, deps);
+    if (!gate.ok) {
+        sendJson(res, gate.status, { ok: false, error: { code: gate.code, message: gate.message } });
+        return;
+    }
+    if (!deps.sddDataAlignment) {
+        sendJson(res, 403, {
+            ok: false,
+            error: { code: "SDD_NOT_ELIGIBLE", message: "当前用户不可使用 SDD 数据对齐" },
+        });
+        return;
+    }
+    try {
+        const body = await readJsonBody(req);
+        if (Object.keys(body).some((key) => key !== "skillName")) {
+            throw new SddDataAlignmentError("SDD_INVALID_SKILL_NAME", "请求体只允许 skillName 字段", 400);
+        }
+        await deps.sddDataAlignment.report(sessionId, body.skillName);
+        sendJson(res, 200, { ok: true });
+    }
+    catch (error) {
+        if (error instanceof SddDataAlignmentError) {
+            sendJson(res, error.status, {
+                ok: false,
+                error: { code: error.code, message: error.message },
+            });
+            return;
+        }
+        sendJson(res, 502, {
+            ok: false,
+            error: { code: "SDD_UPSTREAM_FAILED", message: "SDD 数据对齐上报失败" },
+        });
+    }
+}
 export async function handleRuntimeContext(res, deps, sessionId) {
     const ensured = await ensureActiveSession(deps, sessionId);
     if (!ensured.ok) {
@@ -2910,7 +2998,11 @@ export async function handleModels(req, res, deps, sessionId) {
         // folded into a 409 MODEL_SWITCH_FAILED (the frontend refresh path
         // re-reads the snapshot to converge on the applied selection).
         const snapshot = await deps.runtime.getRuntimeSnapshot(sessionId);
-        sendJson(res, 200, { ok: true, session: updated, snapshot });
+        sendJson(res, 200, {
+            ok: true,
+            session: projectBrowserChatSession(updated),
+            snapshot,
+        });
     }
     catch (error) {
         if (error instanceof RuntimeSnapshotUnavailableError) {
@@ -2988,7 +3080,7 @@ export async function ensureActiveSession(deps, sessionId) {
             : {}),
     });
     if (!reopened.ok) {
-        return { ok: false, ...mapReopenSessionFailure(reopened) };
+        return { ok: false, ...(await mapFailedReopen(deps, sessionId, reopened)) };
     }
     return { ok: true };
 }
@@ -3935,10 +4027,7 @@ export async function handleChatCompact(req, res, deps, sessionId) {
                 : {}),
         });
         if (!reopened.ok) {
-            const mapped = mapReopenSessionFailure({
-                code: reopened.code,
-                message: reopened.message,
-            });
+            const mapped = await mapFailedReopen(deps, sessionId, reopened);
             sendJson(res, mapped.status, {
                 ok: false,
                 error: { code: mapped.code, message: mapped.message },
@@ -4177,6 +4266,11 @@ export async function handleChatRequest(req, res, deps, pathname, workspaceScope
         await handleSkillAutoInvocation(req, res, deps, decodeURIComponent(skillAutoInvocation[1]), decodeURIComponent(skillAutoInvocation[2]));
         return true;
     }
+    const sddBingo = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/sdd-bingo$/);
+    if (method === "POST" && sddBingo) {
+        await handleSddBingo(req, res, deps, decodeURIComponent(sddBingo[1]));
+        return true;
+    }
     const m4Route = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/(draft|files|runtime-context|runtime-snapshot|models|model|reload|commands)$/);
     if (m4Route) {
         const id = decodeURIComponent(m4Route[1]);

package/dist/worker/console/chat/sdd-data-alignment.js

@@ -0,0 +1,222 @@
+import { randomBytes } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export const SDD_DEFAULT_SKILL_NAME = "SDD-implementation-test-review";
+export const SDD_TELEMETRY_URL = "https://wizard-ai.paic.com.cn/code_pilot/api/skill-usage-log";
+export const SDD_TELEMETRY_SIGN = "52aad0c09e6b46818a11ee702d6fe0ba";
+export const WIZARD_LOCAL_DEFAULT_USER_AGENT = "Builder/OpenCode ai-sdk/provider-utils/4.0.21 runtime/bun/1.3.11";
+function sameAuthFileVersion(left, right) {
+    if (!left.exists || !right.exists)
+        return left.exists === right.exists;
+    return left.dev === right.dev && left.ino === right.ino && left.size === right.size &&
+        left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
+}
+/** Reads ~/.aima-go/auth.json with metadata-based parse caching and fail-closed semantics. */
+export class AimaxAuthReader {
+    authFile;
+    cached;
+    constructor(authFile = path.join(os.homedir(), ".aima-go", "auth.json")) {
+        this.authFile = authFile;
+    }
+    async getToken() {
+        let version;
+        try {
+            const info = await stat(this.authFile, { bigint: true });
+            version = { exists: true, dev: info.dev, ino: info.ino, size: info.size,
+                mtimeNs: info.mtimeNs, ctimeNs: info.ctimeNs };
+        }
+        catch {
+            this.cached = { version: { exists: false } };
+            return undefined;
+        }
+        if (this.cached && sameAuthFileVersion(this.cached.version, version))
+            return this.cached.token;
+        let token;
+        try {
+            const parsed = JSON.parse(await readFile(this.authFile, "utf8"));
+            const candidate = parsed["aimax-auth-token"];
+            if (typeof candidate === "string" && candidate.trim())
+                token = candidate;
+        }
+        catch {
+            // Malformed or unreadable files are intentionally ineligible.
+        }
+        this.cached = { version, ...(token ? { token } : {}) };
+        return token;
+    }
+    async isEligible() {
+        return Boolean(await this.getToken());
+    }
+}
+const OPENCODE_RANDOM_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const OPENCODE_TIME_MASK = (1n << 48n) - 1n;
+let lastOpenCodeMillisecond = -1;
+let openCodeMillisecondCounter = 0;
+/** Generate the OpenCode-compatible `ses_` identifier without an OpenCode dependency. */
+export function createOpenCodeSessionId(options = {}) {
+    const now = Math.floor((options.now ?? Date.now)());
+    if (now === lastOpenCodeMillisecond)
+        openCodeMillisecondCounter = (openCodeMillisecondCounter + 1) & 0xfff;
+    else {
+        lastOpenCodeMillisecond = now;
+        openCodeMillisecondCounter = 0;
+    }
+    const ordered = BigInt(now) * 0x1000n + BigInt(openCodeMillisecondCounter);
+    const timePart = ((~ordered) & OPENCODE_TIME_MASK).toString(16).padStart(12, "0");
+    const bytes = (options.random ?? randomBytes)(14);
+    let randomPart = "";
+    for (const byte of bytes)
+        randomPart += OPENCODE_RANDOM_ALPHABET[byte % OPENCODE_RANDOM_ALPHABET.length];
+    return `ses_${timePart}${randomPart}`;
+}
+export class SddDataAlignmentError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = "SddDataAlignmentError";
+    }
+}
+export function normalizeSddSkillName(value) {
+    if (value !== undefined && typeof value !== "string") {
+        throw new SddDataAlignmentError("SDD_INVALID_SKILL_NAME", "skillName 必须是字符串", 400);
+    }
+    const raw = value ?? "";
+    const normalized = raw.trim() || SDD_DEFAULT_SKILL_NAME;
+    if ([...normalized].length > 256 || /[\u0000-\u001f\u007f]/u.test(raw)) {
+        throw new SddDataAlignmentError("SDD_INVALID_SKILL_NAME", "skillName 不能超过 256 个字符或包含控制字符", 400);
+    }
+    return normalized;
+}
+export class SddDataAlignmentService {
+    store;
+    auth;
+    fetchImpl;
+    constructor(store, auth = new AimaxAuthReader(), fetchImpl = fetch) {
+        this.store = store;
+        this.auth = auth;
+        this.fetchImpl = fetchImpl;
+    }
+    async isEligible() {
+        return this.auth.isEligible();
+    }
+    async ensureTelemetrySessionId(sessionId) {
+        const value = await this.store.ensureTelemetrySessionId(sessionId, createOpenCodeSessionId);
+        if (!value)
+            throw new SddDataAlignmentError("SDD_SESSION_NOT_FOUND", "当前对话不存在", 404);
+        return value;
+    }
+    async report(sessionId, rawSkillName) {
+        const token = await this.auth.getToken();
+        if (!token) {
+            throw new SddDataAlignmentError("SDD_NOT_ELIGIBLE", "当前用户不可使用 SDD 数据对齐", 403);
+        }
+        const skillName = normalizeSddSkillName(rawSkillName);
+        const telemetrySessionId = await this.ensureTelemetrySessionId(sessionId);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 30_000);
+        let response;
+        try {
+            response = await this.fetchImpl(SDD_TELEMETRY_URL, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "ws-auth": token,
+                    "ws-sign": SDD_TELEMETRY_SIGN,
+                    Connection: "keep-alive",
+                    "User-Agent": "opencode/1.3.6",
+                    Accept: "*/*",
+                    Host: "wizard-ai.paic.com.cn",
+                    "Accept-Encoding": "gzip, deflate, br, zstd",
+                },
+                body: JSON.stringify({ sessionId: telemetrySessionId, builderId: "opencode", skillName }),
+                signal: controller.signal,
+            });
+        }
+        catch {
+            if (controller.signal.aborted) {
+                throw new SddDataAlignmentError("SDD_UPSTREAM_TIMEOUT", "SDD 数据对齐上报超时", 504);
+            }
+            throw new SddDataAlignmentError("SDD_UPSTREAM_FAILED", "SDD 数据对齐上报失败", 502);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        const body = await readBoundedTelemetryJson(response);
+        if (!response.ok || body?.ret !== 0 || body.succ !== true) {
+            throw new SddDataAlignmentError("SDD_UPSTREAM_FAILED", "SDD 数据对齐上报失败", 502);
+        }
+    }
+}
+async function readBoundedTelemetryJson(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return undefined;
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const item = await reader.read();
+            if (item.done)
+                break;
+            total += item.value.byteLength;
+            if (total > 64 * 1024) {
+                await reader.cancel();
+                return undefined;
+            }
+            chunks.push(item.value);
+        }
+        const merged = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            merged.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return JSON.parse(new TextDecoder().decode(merged));
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function deleteHeaderCaseInsensitive(headers, name) {
+    for (const key of Object.keys(headers))
+        if (key.toLowerCase() === name.toLowerCase())
+            delete headers[key];
+}
+function configuredHeader(headers, name) {
+    const key = Object.keys(headers ?? {}).find((entry) => entry.toLowerCase() === name.toLowerCase());
+    return key ? headers?.[key] : undefined;
+}
+function setStaticHeader(headers, configured, name, defaultValue) {
+    deleteHeaderCaseInsensitive(headers, name);
+    headers[name] = configuredHeader(configured, name) ?? defaultValue;
+}
+export async function injectWizardLocalHeaders(options) {
+    const model = options.context.model;
+    if (model?.provider !== "wizard-local" || !model.id)
+        return;
+    if (!(await options.service.isEligible()))
+        return;
+    const modelRegistry = options.context.modelRegistry;
+    if (!modelRegistry?.getApiKeyAndHeaders)
+        return;
+    // Keep the method call attached to ModelRegistry. Its implementation reads
+    // the private runtime through `this`; extracting the function would make the
+    // SDK path fail closed and silently drop all custom headers.
+    const auth = await modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok || typeof auth.apiKey !== "string" || !auth.apiKey)
+        return;
+    setStaticHeader(options.headers, auth.headers, "client-code", "OpenCode");
+    setStaticHeader(options.headers, auth.headers, "User-Agent", WIZARD_LOCAL_DEFAULT_USER_AGENT);
+    for (const name of ["x-api-key", "X-Session-Id", "X-Model-Id"])
+        deleteHeaderCaseInsensitive(options.headers, name);
+    options.headers["x-api-key"] = auth.apiKey;
+    options.headers["X-Session-Id"] = await options.service.ensureTelemetrySessionId(options.sessionId);
+    options.headers["X-Model-Id"] = model.id;
+}

package/dist/worker/console/chat/session-catalog.js

@@ -1,3 +1,4 @@
+import { isBlankChatSession } from "./session-store.js";
 import { projectDeferredTurnSummaries, projectDeferredTurnSummary, } from "./deferred-turn.js";
 /**
  * Process-wide Session baseline, mirroring DSH's independent session.list.
@@ -33,6 +34,7 @@ export class ChatSessionCatalog {
                 : {}),
             deferredTurn: projectDeferredTurnSummary(record.deferredTurns?.[0]),
             deferredTurns: projectDeferredTurnSummaries(record.deferredTurns ?? []),
+            isBlank: isBlankChatSession(record),
             ...(workspaceId ? { workspaceId } : {}),
         });
     }