@cjhyy/code-shell-server 0.9.43 → 0.9.46

package/dist/panels/model-traces.js

@@ -0,0 +1,222 @@
+import { randomUUID } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { recordExternalModelTrace, } from "@cjhyy/code-shell-core/internal";
+import { PanelBridgeError } from "./bridge-contract.js";
+export const panelModelTraceMethods = ["modelTraces.start", "modelTraces.finish"];
+export const panelModelTraceLimits = Object.freeze({
+    maxParamsBytes: 256 * 1024,
+    maxActivePerOwner: 64,
+    maxActive: 2048,
+    maxCallsPerMinute: 240,
+    maxLifetimeMs: 24 * 60 * 60 * 1000,
+});
+function invalid(message = "Invalid Panel model observation") {
+    throw new PanelBridgeError("INVALID_ARGUMENT", message);
+}
+function object(value, keys) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        invalid();
+    if (Object.keys(value).some((key) => !keys.includes(key)))
+        invalid();
+    return value;
+}
+function label(value, optional = false) {
+    if (optional && value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !value.trim() || value.length > 200 || /[\x00-\x1f]/.test(value))
+        invalid();
+    return value;
+}
+function usage(value) {
+    if (value === undefined)
+        return undefined;
+    const input = object(value, [
+        "promptTokens",
+        "completionTokens",
+        "totalTokens",
+        "cacheReadTokens",
+        "cacheCreationTokens",
+    ]);
+    for (const key of ["promptTokens", "completionTokens", "totalTokens"])
+        if (input[key] === undefined)
+            invalid("Model usage requires token counts");
+    for (const number of Object.values(input))
+        if (!Number.isSafeInteger(number) || Number(number) < 0)
+            invalid("Invalid model usage");
+    return input;
+}
+/** Write-only Panel observations share the Host's policy, sanitization and history store. */
+export class PanelModelTraceService {
+    options;
+    active = new Map();
+    calls = new Map();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    call(owner, method, params) {
+        if (!owner.ownerKey ||
+            !/^[a-z][a-z0-9-]{0,63}$/.test(owner.appId) ||
+            !owner.revision ||
+            !isAbsolute(owner.workspacePath))
+            invalid("Invalid Host model observation owner");
+        if (!panelModelTraceMethods.includes(method))
+            invalid("Unsupported model observation method");
+        const encoded = JSON.stringify(params);
+        if (!encoded || Buffer.byteLength(encoded) > panelModelTraceLimits.maxParamsBytes)
+            throw new PanelBridgeError("PARAMS_TOO_LARGE", "Panel model observation exceeds the limit");
+        const now = this.now();
+        this.prune(now);
+        const calls = (this.calls.get(owner.ownerKey) ?? []).filter((time) => now - time < 60_000);
+        if (calls.length >= panelModelTraceLimits.maxCallsPerMinute)
+            throw new PanelBridgeError("RATE_LIMITED", "Panel model observation rate limit exceeded");
+        calls.push(now);
+        this.calls.set(owner.ownerKey, calls);
+        if (method === "modelTraces.start") {
+            const value = object(params, [
+                "provider",
+                "model",
+                "purpose",
+                "input",
+                "inputState",
+                "stream",
+            ]);
+            const provider = label(value.provider);
+            const model = label(value.model);
+            const purpose = label(value.purpose, true) ?? "model";
+            if (value.stream !== undefined && typeof value.stream !== "boolean")
+                invalid();
+            if (value.inputState !== undefined && value.inputState !== "truncated")
+                invalid();
+            const body = object(value.input, ["systemPrompt", "messages", "tools", "parameters"]);
+            if (body.systemPrompt !== undefined && typeof body.systemPrompt !== "string")
+                invalid();
+            for (const key of ["messages", "tools"])
+                if (body[key] !== undefined && !Array.isArray(body[key]))
+                    invalid();
+            if (body.parameters !== undefined &&
+                (!body.parameters || typeof body.parameters !== "object" || Array.isArray(body.parameters)))
+                invalid();
+            if (this.active.size >= panelModelTraceLimits.maxActive ||
+                [...this.active.values()].filter((item) => item.ownerKey === owner.ownerKey).length >=
+                    panelModelTraceLimits.maxActivePerOwner)
+                throw new PanelBridgeError("RATE_LIMITED", "Too many active Panel model observations");
+            const input = {
+                storageDir: this.options.storageDir,
+                workspacePath: owner.workspacePath,
+                ephemeral: false,
+                sessionId: owner.sessionId,
+                parentSessionId: undefined,
+                runId: owner.traceId,
+                source: `panel:${owner.appId}`,
+                purpose: `panel/${purpose}`,
+                provider,
+                model,
+                startedAt: now,
+                status: "running",
+                stream: value.stream,
+                coverage: "logical-input",
+                inputState: value.inputState,
+                input: {
+                    systemPrompt: body.systemPrompt ?? "",
+                    messages: body.messages ?? [],
+                    tools: body.tools ?? [],
+                    parameters: {
+                        ...body.parameters,
+                        codeshellPanel: {
+                            appId: owner.appId,
+                            revision: owner.revision,
+                            ...(owner.taskId ? { taskId: owner.taskId } : {}),
+                        },
+                    },
+                },
+            };
+            const record = recordExternalModelTrace(input);
+            const id = record?.id ?? randomUUID();
+            // Retain only already-sanitized content. Disabled recording never resumes mid-call.
+            this.active.set(id, {
+                ownerKey: owner.ownerKey,
+                ownerIdentity: JSON.stringify([
+                    owner.appId,
+                    owner.revision,
+                    owner.workspacePath,
+                    owner.sessionId,
+                ]),
+                recordId: record?.id,
+                startedAt: now,
+                input: { ...input, input: undefined },
+            });
+            return { id, recorded: !!record };
+        }
+        const value = object(params, ["id", "status", "output", "outputState", "error", "usage"]);
+        if (typeof value.id !== "string" || !/^[a-f0-9-]{36}$/i.test(value.id))
+            invalid();
+        const observation = this.active.get(value.id);
+        if (!observation ||
+            observation.ownerKey !== owner.ownerKey ||
+            observation.ownerIdentity !==
+                JSON.stringify([owner.appId, owner.revision, owner.workspacePath, owner.sessionId]))
+            throw new PanelBridgeError("REVOKED", "Model observation is unavailable for this Panel owner");
+        if (!["completed", "failed", "cancelled"].includes(String(value.status)))
+            invalid();
+        if (value.outputState !== undefined && value.outputState !== "truncated")
+            invalid();
+        const output = value.output === undefined
+            ? undefined
+            : object(value.output, ["text", "thinking", "toolCalls", "stopReason", "data"]);
+        for (const key of ["text", "thinking", "stopReason"])
+            if (output?.[key] !== undefined && typeof output[key] !== "string")
+                invalid();
+        if (output?.toolCalls !== undefined && !Array.isArray(output.toolCalls))
+            invalid();
+        if (value.error !== undefined && typeof value.error !== "string")
+            invalid();
+        const tokens = usage(value.usage);
+        this.active.delete(value.id);
+        const record = observation.recordId
+            ? recordExternalModelTrace({
+                ...observation.input,
+                id: observation.recordId,
+                endedAt: now,
+                status: value.status,
+                output,
+                outputState: value.outputState,
+                error: value.error,
+                usage: tokens,
+            })
+            : null;
+        return { recorded: !!record };
+    }
+    cancelOwner(ownerKey, status = "cancelled") {
+        for (const [id, observation] of this.active)
+            if (observation.ownerKey === ownerKey)
+                this.close(id, observation, status);
+        this.calls.delete(ownerKey);
+    }
+    closeAll() {
+        for (const [id, observation] of this.active)
+            this.close(id, observation, "cancelled");
+        this.calls.clear();
+    }
+    close(id, observation, status) {
+        this.active.delete(id);
+        if (observation.recordId)
+            recordExternalModelTrace({
+                ...observation.input,
+                id: observation.recordId,
+                endedAt: this.now(),
+                status,
+                error: status === "failed" ? "Panel process exited before the model call finished" : undefined,
+            });
+    }
+    now() {
+        return (this.options.now ?? Date.now)();
+    }
+    prune(now) {
+        for (const [id, observation] of this.active)
+            if (now - observation.startedAt > panelModelTraceLimits.maxLifetimeMs)
+                this.close(id, observation, "cancelled");
+        for (const [owner, calls] of this.calls)
+            if (calls.every((time) => now - time >= 60_000))
+                this.calls.delete(owner);
+    }
+}

package/dist/panels/process-service.d.ts

@@ -1,3 +1,4 @@
+import type { PanelModelTraceService, PanelModelTraceOwner } from "./model-traces.js";
 export { processLimits } from "./process-state.js";
 export interface PanelProcessApprovalScope {
     appId: string;
@@ -13,6 +14,9 @@ export interface PanelProcessOwner {
     send(event: "process.output" | "process.exit", payload: Record<string, unknown>): void;
 }
 export interface PanelAppProcessServiceOptions {
+    /** Dedicated descriptor only for a verified installed package entry. */
+    modelTraces?: PanelModelTraceService;
+    modelTraceOwner?(owner: PanelProcessOwner): Omit<PanelModelTraceOwner, "ownerKey"> | undefined;
     /** Host lease from before async preparation until the actual process group has exited. */
     acquireExecution?(owner: PanelProcessOwner): () => void;
     env?: NodeJS.ProcessEnv;
@@ -159,7 +163,13 @@ export declare class PanelAppProcessService {
     }>;
     private sendInput;
     revokeGuest(guestId: number): void;
-    /** Permanently shut down all guests, including operations awaiting approval. */
-    close(): void;
+    /**
+     * Permanently shut down all guests, including operations awaiting approval.
+     * Resolves once every native process group has exited or been force-killed:
+     * escalation runs on a Host timer, so a Host that exits earlier would leave
+     * a process ignoring SIGTERM running.
+     */
+    close(): Promise<void>;
+    private shutDown;
     private terminate;
 }

package/dist/panels/process-service.js

@@ -4,6 +4,7 @@ import { constants, lstatSync, realpathSync } from "node:fs";
 import { access, realpath, stat } from "node:fs/promises";
 import { basename, delimiter, extname, join } from "node:path";
 import { killProcessGroup } from "@cjhyy/code-shell-core/extension";
+import { PanelModelTraceChannel } from "./model-trace-channel.js";
 import { verifyProcessEntry } from "./process-entry.js";
 import { appendProcessEvent, ProcessReceipts, processLimits, sameProcessOwner, } from "./process-state.js";
 export { processLimits } from "./process-state.js";
@@ -231,7 +232,7 @@ export class PanelAppProcessService {
         options.assertCurrent?.();
         await this.authorize(owner, epoch);
         options.assertCurrent?.();
-        const info = await stat(resolved);
+        const info = await stat(resolved, { bigint: true });
         options.assertCurrent?.();
         await this.authorize(owner, epoch);
         options.assertCurrent?.();
@@ -327,7 +328,7 @@ export class PanelAppProcessService {
         }
         // Final synchronous identity check preserves the existing handle API and avoids
         // an await between validating a cwd and spawning the child into that directory.
-        const current = lstatSync(grant.path);
+        const current = lstatSync(grant.path, { bigint: true });
         if (!current.isDirectory() ||
             current.isSymbolicLink() ||
             current.dev !== grant.dev ||
@@ -518,12 +519,22 @@ export class PanelAppProcessService {
             if (!this.options.allowAuthorizedProcessWithoutPrompt)
                 this.approvedExecutables.add(approvalKey);
             const processId = randomUUID();
+            const modelTraceOwner = entry && this.options.modelTraces ? this.options.modelTraceOwner?.(owner) : undefined;
+            // Never inherit a caller's descriptor claim for an ordinary executable.
+            delete env.CODESHELL_MODEL_TRACE_FD;
+            if (modelTraceOwner)
+                env.CODESHELL_MODEL_TRACE_FD = "3";
             const child = spawn(executable.path, args, {
                 cwd,
                 detached: process.platform !== "win32",
                 env,
                 shell: false,
-                stdio: [input.stdin === "pipe" ? "pipe" : "ignore", "pipe", "pipe"],
+                stdio: [
+                    input.stdin === "pipe" ? "pipe" : "ignore",
+                    "pipe",
+                    "pipe",
+                    ...(modelTraceOwner ? ["pipe"] : []),
+                ],
                 windowsHide: true,
             });
             const record = {
@@ -607,6 +618,28 @@ export class PanelAppProcessService {
                 }),
             };
             this.processes.set(processId, running);
+            if (modelTraceOwner && this.options.modelTraces) {
+                const channel = new PanelModelTraceChannel({
+                    service: this.options.modelTraces,
+                    owner: {
+                        ...modelTraceOwner,
+                        ownerKey: `process:${processId}`,
+                        traceId: modelTraceOwner.traceId ?? processId,
+                    },
+                    isAuthorized: async () => {
+                        try {
+                            await this.authorize(owner, epoch);
+                            return this.processes.get(processId) === running && !running.termination;
+                        }
+                        catch {
+                            return false;
+                        }
+                    },
+                });
+                running.modelTraceChannel = channel;
+                child.stdio[3]?.on("data", (chunk) => channel.write(chunk));
+                child.stdio[3]?.on("error", () => channel.abort("failed"));
+            }
             let checkingInputs = false;
             const inputChecks = fileArgumentHandles.some((handle) => this.fileArguments.get(handle)?.validate)
                 ? setInterval(() => {
@@ -651,6 +684,7 @@ export class PanelAppProcessService {
                             });
                         }
                     }
+                    await running.modelTraceChannel?.finish(record.cancelRequested ? "cancelled" : "failed");
                     finishExit({ code: finalCode, signal });
                     this.retiring.delete(processId);
                     if (this.processes.get(processId)?.child !== child)
@@ -879,10 +913,18 @@ export class PanelAppProcessService {
             }
         }
     }
-    /** Permanently shut down all guests, including operations awaiting approval. */
+    /**
+     * Permanently shut down all guests, including operations awaiting approval.
+     * Resolves once every native process group has exited or been force-killed:
+     * escalation runs on a Host timer, so a Host that exits earlier would leave
+     * a process ignoring SIGTERM running.
+     */
     close() {
-        if (this.closed)
-            return;
+        if (!this.closed)
+            this.shutDown();
+        return Promise.all([...this.retiring.values()].map((running) => running.termination ?? Promise.resolve())).then(() => undefined);
+    }
+    shutDown() {
         this.closed = true;
         const guests = new Set([
             ...this.guestEpochs.keys(),
@@ -901,6 +943,7 @@ export class PanelAppProcessService {
     terminate(running) {
         if (running.termination)
             return;
+        running.modelTraceChannel?.abort();
         running.record.cancelRequested = true;
         running.record.status = "stopping";
         const pid = running.child.pid;

package/dist/panels/runtime.d.ts

@@ -34,6 +34,7 @@ export interface PanelRuntimeOptions {
     bindingCwd?: string;
     projectPackages?: boolean;
     dataDir: string;
+    traceStorageDir?: string;
     host: "hub" | "desktop";
     /** Host authority only, never a field accepted from Panel HTTP requests. */
     projectScope?: () => Promise<PanelProjectScopeBinding | undefined>;

package/dist/panels/runtime.js

@@ -10,6 +10,7 @@ import { panelRuntimeApiVersion, panelProcessMethods, panelResourceMethods, pane
 import { PanelResourceService } from "./resources/service.js";
 import { servePanelResource } from "./resources/http.js";
 import { panelConnections, panelConnectionIds, materializePanelConnections, } from "./connections.js";
+import { PanelModelTraceService, panelModelTraceMethods, panelModelTraceLimits, } from "./model-traces.js";
 import { PanelRuntimeServices } from "./runtime-services.js";
 import { PanelToolJobService, toolJobLimits, } from "./tool-jobs.js";
 import { createPanelToolExecutor } from "./tool-executor.js";
@@ -26,6 +27,7 @@ const MAX_FILE = 16 * 1024 * 1024;
 const GRANT_TTL = 30 * 60_000;
 const METHODS = [
     "context.get",
+    ...panelModelTraceMethods,
     "storage.get",
     "storage.getSnapshot",
     "storage.compareAndSet",
@@ -80,6 +82,7 @@ const MIME = {
     ".html": "text/html; charset=utf-8",
     ".js": "text/javascript; charset=utf-8",
     ".mjs": "text/javascript; charset=utf-8",
+    ".wasm": "application/wasm",
     ".css": "text/css; charset=utf-8",
     ".json": "application/json",
     ".md": "text/markdown; charset=utf-8",
@@ -420,6 +423,10 @@ export function createPanelRuntime(options) {
     const assets = new Map();
     const now = options.now ?? Date.now;
     const services = new PanelRuntimeServices({ dataDir: options.dataDir });
+    const modelTraces = new PanelModelTraceService({
+        storageDir: options.traceStorageDir,
+        now: options.now,
+    });
     const installed = options.listInstalled ??
         (options.projectPackages
             ? async (appId) => (await inspectProjectPanelApps(options.bindingCwd ?? options.cwd, appId)).apps
@@ -522,6 +529,27 @@ export function createPanelRuntime(options) {
         return app;
     }
     const processes = new PanelAppProcessService({
+        modelTraces,
+        modelTraceOwner: (owner) => {
+            const task = toolOwners.get(owner.guestId);
+            if (task)
+                return {
+                    appId: owner.appId,
+                    revision: owner.revision,
+                    workspacePath: options.cwd,
+                    traceId: task.taskId,
+                    taskId: task.taskId,
+                };
+            const grant = byGuest.get(owner.guestId);
+            if (!grant || grant.revision !== owner.revision)
+                return undefined;
+            return {
+                appId: owner.appId,
+                revision: owner.revision,
+                workspacePath: options.cwd,
+                sessionId: typeof grant.context.sessionId === "string" ? grant.context.sessionId : undefined,
+            };
+        },
         acquireExecution: (owner) => panelExecutionGate.enter({
             appId: owner.appId,
             projectPath: options.bindingCwd ?? options.cwd,
@@ -751,7 +779,7 @@ export function createPanelRuntime(options) {
             resources,
             owner: (job, send) => {
                 const guestId = nextToolOwner--;
-                toolOwners.set(guestId, job.scope);
+                toolOwners.set(guestId, { ...job.scope, taskId: job.id });
                 return {
                     guestId,
                     appId: job.scope.appId,
@@ -826,6 +854,7 @@ export function createPanelRuntime(options) {
         assets.delete(grant.asset);
         byGuest.delete(grant.guestId);
         processes.revokeGuest(grant.guestId);
+        modelTraces.cancelOwner(`grant:${grant.id}`);
         agentTasks?.revokeInstance(grant.id);
         for (const item of grant.confirmations.values())
             item.finish(false);
@@ -1089,6 +1118,8 @@ export function createPanelRuntime(options) {
                 locale: typeof input.locale === "string" ? input.locale.slice(0, 32) : "zh-CN",
                 apiVersion: panelRuntimeApiVersion,
                 capabilities: {
+                    packageAssets: { wasm: true, fetch: "package" },
+                    modelTraces: { writeOnly: true, coverage: "logical-input", ...panelModelTraceLimits },
                     ...panelRuntimeCapabilities({
                         process: app.permissions.includes("process"),
                         cookieProcess: app.permissions.includes("process") &&
@@ -1189,7 +1220,9 @@ export function createPanelRuntime(options) {
                         return false;
                     if (method.startsWith("tools."))
                         return !!app.agent?.tools.length;
-                    return (method === "context.get" || app.permissions.includes(methodPermission(method)));
+                    return (method === "context.get" ||
+                        method.startsWith("modelTraces.") ||
+                        app.permissions.includes(methodPermission(method)));
                 }),
                 limitations: panel.compatibility.reasons,
             };
@@ -1302,6 +1335,14 @@ export function createPanelRuntime(options) {
             grant.calls = history;
         if (method === "context.get")
             return grant.context;
+        if (method.startsWith("modelTraces."))
+            return modelTraces.call({
+                ownerKey: `grant:${grant.id}`,
+                appId: grant.app.id,
+                revision: grant.revision,
+                workspacePath: options.cwd,
+                sessionId: typeof grant.context.sessionId === "string" ? grant.context.sessionId : undefined,
+            }, method, params);
         if (method.startsWith("tasks."))
             return dispatchToolJobs(grant, method, params);
         if (method.startsWith("tools.")) {
@@ -1600,6 +1641,7 @@ export function createPanelRuntime(options) {
                 return {
                     effect: method,
                     prompt: value.prompt,
+                    modelTraceSource: `panel:${grant.app.id}`,
                     sessionId: grant.context.sessionId,
                     ...(value.displayText ? { displayText: value.displayText } : {}),
                 };
@@ -1692,6 +1734,7 @@ export function createPanelRuntime(options) {
         },
         async close() {
             closed = true;
+            modelTraces.closeAll();
             for (const preparation of preparingTools)
                 preparation.controller.abort();
             clearInterval(reaper);
@@ -1705,8 +1748,11 @@ export function createPanelRuntime(options) {
                 await taskCookies?.shutdown();
             }
             finally {
-                processes.close();
-                await Promise.all([resources.shutdown(), Promise.resolve(agentTasks?.close())]);
+                await Promise.all([
+                    processes.close(),
+                    resources.shutdown(),
+                    Promise.resolve(agentTasks?.close()),
+                ]);
             }
         },
         async handle(request, response) {
@@ -1936,7 +1982,7 @@ export function createPanelRuntime(options) {
                     // The embedding iframe must enable the same permission.
                     response.setHeader("Content-Security-Policy", "default-src 'none'; script-src " +
                         assetSource +
-                        "; style-src " +
+                        " 'wasm-unsafe-eval'; style-src " +
                         assetSource +
                         " 'unsafe-inline'; img-src " +
                         assetSource +
@@ -1944,7 +1990,9 @@ export function createPanelRuntime(options) {
                         assetSource +
                         " blob:; font-src " +
                         assetSource +
-                        " data:; connect-src 'none'; object-src 'none'; frame-src 'none'; base-uri 'none'; form-action 'none'; sandbox allow-scripts allow-downloads; frame-ancestors " +
+                        " data:; connect-src " +
+                        assetSource +
+                        "; object-src 'none'; frame-src 'none'; base-uri 'none'; form-action 'none'; sandbox allow-scripts allow-downloads; frame-ancestors " +
                         resourceOrigin);
                     response.setHeader("Permissions-Policy", "camera=(), microphone=(), geolocation=(), display-capture=()");
                 }

package/dist/panels/tool-jobs.d.ts

@@ -120,6 +120,8 @@ export declare class PanelToolJobService {
     initialize(): Promise<void>;
     private load;
     private commit;
+    /** Make a job state visible to readers and subscribers. */
+    private publish;
     private lookup;
     /** Scoped existence check for transports merging read-only legacy history. */
     has(rawScope: ToolJobScope, id: string): Promise<boolean>;

package/dist/panels/tool-jobs.js

@@ -283,6 +283,10 @@ export class PanelToolJobService {
         job.updatedAt = this.now();
         job.sequence++;
         await this.storage.write(job.id, job, toolJobLimits.maxRecordBytes);
+        this.publish(job);
+    }
+    /** Make a job state visible to readers and subscribers. */
+    publish(job) {
         this.jobs.set(job.id, job);
         try {
             this.options.onEvent?.(publicJob(job));
@@ -670,7 +674,23 @@ export class PanelToolJobService {
                 next.result = result;
                 next.progress = { ...next.progress, fraction: 1 };
             }
-            await this.commit(next);
+            try {
+                await this.commit(next);
+            }
+            catch (error) {
+                // The executor has exited; a job that stays "running" in memory would
+                // count as active forever and hide the outcome. Publish an explicit
+                // failure for this Host session instead (keeping any result), while
+                // the stale disk record is recovered as interrupted by a later Host.
+                const outcome = next.error ? `${next.status} (${next.error.message})` : next.status;
+                next.status = "failed";
+                next.error = {
+                    code: "TOOL_JOB_STORAGE_FAILED",
+                    message: `Task ${outcome} but its final state could not be saved: ${error instanceof Error ? error.message : String(error)}`.slice(0, 2000),
+                    retryable: next.recovery === "retry",
+                };
+                this.publish(next);
+            }
         });
     }
     async cancel(rawScope, id) {

package/dist/serve/cli.js

@@ -10,6 +10,7 @@ import { join, resolve } from "node:path";
 import { existsSync } from "node:fs";
 import { startHeadlessServer } from "./headless-server.js";
 import { startProjectControlServer } from "../project-runtime/control-server.js";
+import { configureModelTracing } from "@cjhyy/code-shell-core/internal";
 const SERVE_HELP = `Usage: code-shell-serve [options]
 
 Run the CodeShell headless Web host for a workspace.
@@ -127,7 +128,7 @@ export function resolveWorkerEntry() {
  * wrapper registered it; arena/pet stay desktop-only).
  */
 export function resolveWorkerCapabilityModules() {
-    return `${import.meta.resolve("@cjhyy/code-shell-capability-coding")}#createCodingModule`;
+    return `${import.meta.resolve("@cjhyy/code-shell-capability-coding")}#createCodingModule,${import.meta.resolve("@cjhyy/code-shell-server/links")}#createLinkProviderModule`;
 }
 /** Locate the built browser app (packages/web `app` build), when present. */
 export function resolveWebAppRoot() {
@@ -150,6 +151,12 @@ export async function runServeCli(argv = process.argv.slice(2)) {
         return;
     }
     const parsed = parseServeArgs(argv);
+    if (parsed.runtime === "local") {
+        configureModelTracing({
+            storageDir: join(parsed.dataDir, "worker", "sessions", ".model-traces"),
+            source: "server",
+        });
+    }
     const staticRootDir = parsed.staticRootDir ?? resolveWebAppRoot();
     const server = parsed.runtime === "docker"
         ? await startProjectControlServer({