@aexol/spectral 0.9.221 → 0.9.222

package/dist/server/agent-bridge/headless-ui.js

@@ -0,0 +1,85 @@
+// ---------------------------------------------------------------------------
+// Headless UI context
+// ---------------------------------------------------------------------------
+import { createBridgeConfirm, createStdinConfirmIO, } from "../ui/terminal-confirm.js";
+/**
+ * Detect the memory subsystem from a notification message text.
+ * The memory extension prefixes all messages with "Observational memory:".
+ */
+function detectMemorySystem(message) {
+    if (!message.startsWith("Observational memory:"))
+        return undefined;
+    const lower = message.toLowerCase();
+    if (lower.includes("observer"))
+        return "memory_observer";
+    if (lower.includes("compaction") || lower.includes("compact"))
+        return "memory_compaction";
+    if (lower.includes("reflection") || lower.includes("reflect"))
+        return "memory_reflection";
+    if (lower.includes("pruner") || lower.includes("prune"))
+        return "memory_pruner";
+    // Keep generic observational-memory messages visible in the landing badge.
+    return "memory_observer";
+}
+/**
+ * Detect subsystem from notification messages by known prefix.
+ * Returns undefined for generic extension messages without a matching prefix.
+ */
+function detectNotifSystem(message) {
+    if (message.startsWith("[spectral-vision]"))
+        return "vision";
+    return detectMemorySystem(message);
+}
+/**
+ * Create a minimal ExtensionUIContext that forwards `notify()` calls as
+ * `agent_notification` wire events, and renders `confirm()` as a terminal-
+ * native permission prompt on serve's stdout (the terminal `spectral serve`
+ * runs in) so extensions like desktop-control can request real user approval
+ * while the user chats via the web UI. A prompt also emits an
+ * `agent_notification` ("Approval required in terminal: …") so web users know
+ * to look at the terminal. Confirmations are serialized across sessions and
+ * auto-deny on timeout (SPECTRAL_CONFIRM_TIMEOUT_MS, default 5 min) or when
+ * stdin is not a TTY. All other interactive UI methods (select/input/custom/
+ * editor) remain no-ops resolving `undefined`.
+ */
+export function createHeadlessUIContext(emit) {
+    const terminalIO = createStdinConfirmIO();
+    // Defer to a Proxy so we don't need to stub every method.
+    // `notify` and `confirm` are the methods called by extensions in serve mode
+    // (observational memory, MCP status bar updates, spectral-vision,
+    // desktop-control).
+    const handler = {
+        get(_target, prop) {
+            if (prop === "notify") {
+                return (message, type, metadata) => {
+                    const level = type ?? "info";
+                    const system = detectNotifSystem(message);
+                    if (system?.startsWith("memory_")) {
+                        console.info(`[AgentBridge][memory][${level}] ${message}`);
+                    }
+                    else if (system === "vision") {
+                        console.info(`[AgentBridge][vision][${level}] ${message}`);
+                    }
+                    emit({
+                        type: "agent_notification",
+                        message,
+                        level,
+                        system,
+                        dcpLiteTelemetry: metadata?.dcpLiteTelemetry,
+                    });
+                };
+            }
+            // All other methods: return a no-op function or undefined.
+            // Methods that return Promises (select, confirm, input, custom, editor)
+            if (prop === "confirm") {
+                return createBridgeConfirm(emit, terminalIO);
+            }
+            // resolve to `undefined`. `confirm` above is the one interactive method
+            // with a real terminal-native implementation.
+            // Methods that set state (setStatus, setWorkingMessage, setWidget, etc.)
+            // are safe to no-op.
+            return () => undefined;
+        },
+    };
+    return new Proxy({}, handler);
+}

package/dist/server/agent-bridge/pricing.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Model pricing and credit calculation helpers for the agent bridge.
+ *
+ * Extracted verbatim from `agent-bridge.ts`: the hardcoded per-model pricing
+ * table (USD per 1M tokens), vendor-prefix stripping, backend-credit-rate
+ * resolution and credit computation. Pure functions — no bridge state.
+ */
+import type { AllowedModel } from "../../relay/models-fetch.js";
+/**
+ * Strip vendor prefix to extract the bare model name.
+ * e.g. "openai/gpt-5.3-codex" → "gpt-5.3-codex".
+ * Returns the original string when no separator is present.
+ */
+export declare function bareModelId(modelId: string): string;
+/** Get model cost from backend credit rates, falling back to hardcoded pricing table. */
+export declare function getModelCost(m: AllowedModel): {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+};
+/** Look up pricing for a modelId. Returns null when unknown. */
+export declare function lookupPricing(modelId: string): {
+    input: number;
+    output: number;
+    cacheWrite: number;
+    cacheRead: number;
+} | null;
+/**
+ * Calculate credits from token usage using per-model credit rates.
+ *
+ * NOTE: We intentionally keep higher precision here (no 2-decimal rounding)
+ * so small turns don't collapse to 0.00 in live UI aggregation. Rendering
+ * layers decide final display precision.
+ */
+export declare function calculateCredits(inputTokens: number, outputTokens: number, cacheReadTokens?: number, cacheWriteTokens?: number, creditInputPer1M?: number | null, creditOutputPer1M?: number | null, creditCachedInputPer1M?: number | null, creditCacheReadPer1M?: number | null, creditCacheWritePer1M?: number | null): number;
+//# sourceMappingURL=pricing.d.ts.map

package/dist/server/agent-bridge/pricing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../../src/server/agent-bridge/pricing.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AA6HhE;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGnD;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,CAAC,EAAE,YAAY,GAAG;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CA2BA;AAED,gEAAgE;AAChE,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,IAAI,CAaP;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,eAAe,GAAE,MAAU,EAC3B,gBAAgB,GAAE,MAAU,EAC5B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,EAChC,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,EACjC,sBAAsB,CAAC,EAAE,MAAM,GAAG,IAAI,EACtC,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,EACpC,qBAAqB,CAAC,EAAE,MAAM,GAAG,IAAI,GACpC,MAAM,CA6BR"}

package/dist/server/agent-bridge/pricing.js

@@ -0,0 +1,202 @@
+/**
+ * Model pricing and credit calculation helpers for the agent bridge.
+ *
+ * Extracted verbatim from `agent-bridge.ts`: the hardcoded per-model pricing
+ * table (USD per 1M tokens), vendor-prefix stripping, backend-credit-rate
+ * resolution and credit computation. Pure functions — no bridge state.
+ */
+/**
+ * Token pricing per model (USD per 1M tokens). Matches provider list
+ * prices as of May 2026. Used to compute token cost server-side when
+ * spectral's own cost field is unavailable (synthetic proxy models are
+ * registered with zero cost to avoid agent-side billing).
+ *
+ * Keys are matched as prefix substrings against modelId, so
+ * `"gpt-5"` covers both `gpt-5` and any
+ * future point-release.
+ */
+const MODEL_PRICING = [
+    // OpenAI models
+    {
+        prefix: "gpt-5.5",
+        input: 1.75,
+        output: 14,
+        cacheWrite: 14,
+        cacheRead: 0.35,
+    },
+    {
+        prefix: "gpt-5.4",
+        input: 1.75,
+        output: 14,
+        cacheWrite: 14,
+        cacheRead: 0.35,
+    },
+    {
+        prefix: "gpt-5.3",
+        input: 1.75,
+        output: 14,
+        cacheWrite: 14,
+        cacheRead: 0.35,
+    },
+    {
+        prefix: "gpt-5.2",
+        input: 1.75,
+        output: 14,
+        cacheWrite: 14,
+        cacheRead: 0.35,
+    },
+    { prefix: "gpt-5.1", input: 2, output: 8, cacheWrite: 8, cacheRead: 0.5 },
+    { prefix: "gpt-5", input: 1.25, output: 10, cacheWrite: 10, cacheRead: 0.25 },
+    { prefix: "gpt-4.1", input: 2, output: 8, cacheWrite: 8, cacheRead: 0.5 },
+    { prefix: "gpt-4o", input: 2.5, output: 10, cacheWrite: 10, cacheRead: 1.25 },
+    { prefix: "gpt-4-turbo", input: 10, output: 30, cacheWrite: 0, cacheRead: 0 },
+    { prefix: "gpt-4", input: 30, output: 60, cacheWrite: 0, cacheRead: 0 },
+    {
+        prefix: "gpt-3.5-turbo",
+        input: 0.5,
+        output: 1.5,
+        cacheWrite: 0,
+        cacheRead: 0,
+    },
+    { prefix: "o1", input: 15, output: 60, cacheWrite: 0, cacheRead: 0 },
+    { prefix: "o3-mini", input: 1.1, output: 4.4, cacheWrite: 0, cacheRead: 0 },
+    { prefix: "o4-mini", input: 1.1, output: 4.4, cacheWrite: 0, cacheRead: 0 },
+    // Google Gemini models
+    {
+        prefix: "gemini-2.5-pro",
+        input: 1.25,
+        output: 10,
+        cacheWrite: 0,
+        cacheRead: 0,
+    },
+    {
+        prefix: "gemini-2.5-flash",
+        input: 0.15,
+        output: 0.6,
+        cacheWrite: 0,
+        cacheRead: 0,
+    },
+    // DeepSeek models
+    {
+        prefix: "deepseek-v3",
+        input: 0.27,
+        output: 1.1,
+        cacheWrite: 0,
+        cacheRead: 0,
+    },
+    {
+        prefix: "deepseek-r1",
+        input: 0.55,
+        output: 2.19,
+        cacheWrite: 0,
+        cacheRead: 0,
+    },
+    {
+        prefix: "deepseek/deepseek-v3",
+        input: 0.27,
+        output: 1.1,
+        cacheWrite: 0,
+        cacheRead: 0,
+    },
+    {
+        prefix: "deepseek/deepseek-r1",
+        input: 0.55,
+        output: 2.19,
+        cacheWrite: 0,
+        cacheRead: 0,
+    },
+    // Meta Llama models (common via OpenRouter-compatible endpoints)
+    {
+        prefix: "meta-llama/llama-4",
+        input: 0.2,
+        output: 0.8,
+        cacheWrite: 0,
+        cacheRead: 0,
+    },
+    {
+        prefix: "meta-llama/llama-3.3",
+        input: 0.2,
+        output: 0.5,
+        cacheWrite: 0,
+        cacheRead: 0,
+    },
+];
+/**
+ * Strip vendor prefix to extract the bare model name.
+ * e.g. "openai/gpt-5.3-codex" → "gpt-5.3-codex".
+ * Returns the original string when no separator is present.
+ */
+export function bareModelId(modelId) {
+    const idx = modelId.lastIndexOf("/");
+    return idx === -1 ? modelId : modelId.slice(idx + 1);
+}
+/** Get model cost from backend credit rates, falling back to hardcoded pricing table. */
+export function getModelCost(m) {
+    // Prefer backend credit rates when configured
+    const hasCredits = m.creditInputPer1M != null ||
+        m.creditOutputPer1M != null ||
+        m.creditCacheReadPer1M != null ||
+        m.creditCacheWritePer1M != null;
+    if (hasCredits) {
+        return {
+            input: m.creditInputPer1M ?? 0,
+            output: m.creditOutputPer1M ?? 0,
+            cacheRead: m.creditCacheReadPer1M ?? 0,
+            cacheWrite: m.creditCacheWritePer1M ?? 0,
+        };
+    }
+    // Fall back to hardcoded pricing table when credits aren't configured
+    const pricing = lookupPricing(m.modelId);
+    return pricing
+        ? {
+            input: pricing.input,
+            output: pricing.output,
+            cacheRead: pricing.cacheRead,
+            cacheWrite: pricing.cacheWrite,
+        }
+        : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+}
+/** Look up pricing for a modelId. Returns null when unknown. */
+export function lookupPricing(modelId) {
+    const bare = bareModelId(modelId);
+    for (const entry of MODEL_PRICING) {
+        if (modelId.startsWith(entry.prefix) || bare.startsWith(entry.prefix)) {
+            return {
+                input: entry.input,
+                output: entry.output,
+                cacheWrite: entry.cacheWrite,
+                cacheRead: entry.cacheRead,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Calculate credits from token usage using per-model credit rates.
+ *
+ * NOTE: We intentionally keep higher precision here (no 2-decimal rounding)
+ * so small turns don't collapse to 0.00 in live UI aggregation. Rendering
+ * layers decide final display precision.
+ */
+export function calculateCredits(inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0, creditInputPer1M, creditOutputPer1M, creditCachedInputPer1M, creditCacheReadPer1M, creditCacheWritePer1M) {
+    const inputRate = creditInputPer1M ?? 0;
+    const outputRate = creditOutputPer1M ?? 0;
+    const cachedInputRate = creditCachedInputPer1M ?? 0;
+    const cacheReadRate = creditCacheReadPer1M ?? 0;
+    const cacheWriteRate = creditCacheWritePer1M ?? 0;
+    const credits = (inputTokens / 1_000_000) * inputRate +
+        (outputTokens / 1_000_000) * outputRate +
+        (cacheReadTokens / 1_000_000) * cacheReadRate +
+        (cacheWriteTokens / 1_000_000) * cacheWriteRate;
+    if (inputRate === 0 &&
+        outputRate === 0 &&
+        cacheReadRate === 0 &&
+        cacheWriteRate === 0) {
+        if (cachedInputRate > 0) {
+            return (((inputTokens + cacheReadTokens + cacheWriteTokens) / 1_000_000) *
+                cachedInputRate);
+        }
+        return 0;
+    }
+    return credits;
+}

package/dist/server/agent-bridge/rehydrate.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Wire-event parsing and content sanitization for session history
+ * rehydration. Extracted verbatim from `agent-bridge.ts`. Pure helpers —
+ * no bridge state.
+ */
+import type { ImageContent, TextContent } from "../../sdk/ai/types.js";
+import type { RestoredMemorySnapshot } from "../../memory/types.js";
+import type { SessionMemorySnapshot } from "../storage.js";
+interface ParsedWireToolEvents {
+    toolCalls: Array<{
+        id: string;
+        name: string;
+        arguments: Record<string, unknown> | undefined;
+    }>;
+    toolResults: Array<{
+        id: string;
+        result: unknown;
+        isError: boolean;
+    }>;
+}
+/**
+ * Parse the newline-delimited JSON of wire events persisted alongside an
+ * assistant message and extract all tool_call / tool_result events.
+ *
+ * These are used during session rehydration to reconstruct the full tool
+ * interaction history (call → result) so the LLM context is complete —
+ * without this, reconnected sessions would see only the assistant text
+ * and never the tool results, causing the model to get confused about
+ * the conversation state.
+ */
+export declare function parseWireToolEvents(eventsJsonl: string): ParsedWireToolEvents;
+export declare function sanitizeRehydratedBlock(block: TextContent | ImageContent): TextContent | ImageContent;
+export declare function toRestoredMemorySnapshot(snapshot: SessionMemorySnapshot): RestoredMemorySnapshot;
+export {};
+//# sourceMappingURL=rehydrate.d.ts.map

package/dist/server/agent-bridge/rehydrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rehydrate.d.ts","sourceRoot":"","sources":["../../../src/server/agent-bridge/rehydrate.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EACV,sBAAsB,EAEvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAE3D,UAAU,oBAAoB;IAC5B,SAAS,EAAE,KAAK,CAAC;QACf,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;KAChD,CAAC,CAAC;IACH,WAAW,EAAE,KAAK,CAAC;QACjB,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,EAAE,OAAO,CAAC;QAChB,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC,CAAC;CACJ;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,oBAAoB,CA8B7E;AAmBD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,WAAW,GAAG,YAAY,GAChC,WAAW,GAAG,YAAY,CA2C5B;AAcD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,qBAAqB,GAC9B,sBAAsB,CAQxB"}

package/dist/server/agent-bridge/rehydrate.js

@@ -0,0 +1,122 @@
+// ---------------------------------------------------------------------------
+// Wire event parsing for history rehydration
+// ---------------------------------------------------------------------------
+/**
+ * Parse the newline-delimited JSON of wire events persisted alongside an
+ * assistant message and extract all tool_call / tool_result events.
+ *
+ * These are used during session rehydration to reconstruct the full tool
+ * interaction history (call → result) so the LLM context is complete —
+ * without this, reconnected sessions would see only the assistant text
+ * and never the tool results, causing the model to get confused about
+ * the conversation state.
+ */
+export function parseWireToolEvents(eventsJsonl) {
+    const toolCalls = [];
+    const toolResults = [];
+    if (!eventsJsonl)
+        return { toolCalls, toolResults };
+    for (const line of eventsJsonl.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const ev = JSON.parse(trimmed);
+            if (ev.type === "tool_call") {
+                toolCalls.push({
+                    id: ev.id,
+                    name: ev.name,
+                    arguments: ev.args,
+                });
+            }
+            else if (ev.type === "tool_result") {
+                toolResults.push({
+                    id: ev.id,
+                    result: ev.result,
+                    isError: ev.isError ?? false,
+                });
+            }
+        }
+        catch {
+            // Skip malformed JSON lines — they won't be meaningful for
+            // rehydration and we'd rather keep the session alive than fail.
+        }
+    }
+    return { toolCalls, toolResults };
+}
+/**
+ * Safety clean-up for content blocks rehydrated from persisted wire events.
+ *
+ * Rehydrated tool-result content is bounded for the model-facing context,
+ * while the original wire event remains available to the UI for rendering
+ * images and other rich results.
+ */
+const MAX_REHYDRATED_TEXT = 100_000;
+/**
+ * Ceiling for blocks that already carry an offload footer (`Full output:`).
+ * These blocks are a bounded preview + a re-readable path, so cutting them
+ * with the generic limit would destroy the footer. Keep them whole up to
+ * this size; larger ones lose their middle but keep head + footer.
+ */
+const MAX_REHYDRATED_OFFLOAD_TEXT = 200_000;
+export function sanitizeRehydratedBlock(block) {
+    // Tool-result image blocks are not accepted by every provider; the raw
+    // result remains in events_jsonl for the UI, while the model gets a compact reference.
+    if (block.type === "image") {
+        // Hosted images carry a url instead of inline bytes — print that rather
+        // than a meaningless "0 bytes base64".
+        const hostedUrl = typeof block.url === "string" && block.url ? block.url : undefined;
+        const descriptor = hostedUrl
+            ? `[Image: ${block.mimeType ?? "image/png"}, url: ${hostedUrl}]`
+            : `[Image: ${block.mimeType ?? "image/png"}, ${(typeof block.data === "string" ? block.data.length : 0).toLocaleString()} bytes base64]`;
+        return {
+            type: "text",
+            text: descriptor +
+                `\n(Image data is available in the raw MCP result.)`,
+        };
+    }
+    // Truncate oversized text blocks to prevent context overflow.
+    if (block.type !== "text")
+        return block;
+    if (block.text.includes("Full output:")) {
+        if (block.text.length <= MAX_REHYDRATED_OFFLOAD_TEXT)
+            return block;
+        // Keep the head (preview) and the tail (offload footer), drop the middle.
+        const keepHead = Math.floor(MAX_REHYDRATED_OFFLOAD_TEXT * 0.7);
+        const keepTail = MAX_REHYDRATED_OFFLOAD_TEXT - keepHead;
+        const omitted = block.text.length - keepHead - keepTail;
+        return {
+            ...block,
+            text: block.text.slice(0, keepHead) +
+                `\n\n[... ${omitted.toLocaleString()} bytes omitted from rehydrated offload preview ...]\n\n` +
+                block.text.slice(block.text.length - keepTail),
+        };
+    }
+    if (block.text.length <= MAX_REHYDRATED_TEXT)
+        return block;
+    const omitted = block.text.length - MAX_REHYDRATED_TEXT;
+    return {
+        ...block,
+        text: block.text.slice(0, MAX_REHYDRATED_TEXT) +
+            `\n\n[truncated — ${omitted.toLocaleString()} bytes omitted]`,
+    };
+}
+function normalizeSnapshotDetails(details) {
+    if (details.version === 4)
+        return details;
+    return {
+        type: "observational-memory",
+        version: 4,
+        observations: details.observations,
+        reflections: details.reflections,
+    };
+}
+export function toRestoredMemorySnapshot(snapshot) {
+    return {
+        type: "observational-memory-snapshot",
+        version: 1,
+        coveredSourceCount: snapshot.coveredSourceCount,
+        summary: snapshot.summary,
+        details: normalizeSnapshotDetails(snapshot.details),
+    };
+}

package/dist/server/agent-bridge/synthetic-model.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Synthetic (backend-proxied) model capability inference for the agent bridge.
+ *
+ * Extracted verbatim from `agent-bridge.ts`: given a backend `AllowedModel`,
+ * infer the spectral `Model` fields (context window, thinking-level map,
+ * OpenAI-completions compat flags) used when registering the synthetic proxy
+ * providers with spectral's `ModelRegistry`. Pure functions — no bridge state.
+ */
+import type { Api, Model } from "../../sdk/ai/types.js";
+import type { AllowedModel } from "../../relay/models-fetch.js";
+/**
+ * Synthetic provider names registered with spectral's `ModelRegistry`. They route
+ * 100% of inference traffic through the backend (`${backendUrl}/v1`), which
+ * authenticates with the machine JWT and forwards to the upstream provider
+ * with centrally-managed API keys.
+ *
+ * Two providers (rather than one): `spectral-proxy-openai` for upstream catalog
+ * models (OpenRouter, DeepSeek, OpenAI, etc.), and
+ * `spectral-proxy-user-model` for team-registered built-in UserModel entries.
+ * Both use the OpenAI-compatible `/chat/completions` request shape.
+ */
+export declare const SPECTRAL_PROXY_OPENAI = "spectral-proxy-openai";
+export declare const SPECTRAL_PROXY_USER_MODEL = "spectral-proxy-user-model";
+export declare function inferSyntheticContextWindow(model: AllowedModel): number;
+export declare function inferSyntheticThinkingLevelMap(model: AllowedModel): Model<Api>["thinkingLevelMap"] | undefined;
+export declare function inferSyntheticOpenAICompat(model: AllowedModel): Model<"openai-completions">["compat"] | undefined;
+//# sourceMappingURL=synthetic-model.d.ts.map

package/dist/server/agent-bridge/synthetic-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthetic-model.d.ts","sourceRoot":"","sources":["../../../src/server/agent-bridge/synthetic-model.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,0BAA0B,CAAC;AAC7D,eAAO,MAAM,yBAAyB,8BAA8B,CAAC;AAGrE,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAmBvE;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,YAAY,GAClB,KAAK,CAAC,GAAG,CAAC,CAAC,kBAAkB,CAAC,GAAG,SAAS,CAkB5C;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,YAAY,GAClB,KAAK,CAAC,oBAAoB,CAAC,CAAC,QAAQ,CAAC,GAAG,SAAS,CA0CnD"}

package/dist/server/agent-bridge/synthetic-model.js

@@ -0,0 +1,92 @@
+/**
+ * Synthetic (backend-proxied) model capability inference for the agent bridge.
+ *
+ * Extracted verbatim from `agent-bridge.ts`: given a backend `AllowedModel`,
+ * infer the spectral `Model` fields (context window, thinking-level map,
+ * OpenAI-completions compat flags) used when registering the synthetic proxy
+ * providers with spectral's `ModelRegistry`. Pure functions — no bridge state.
+ */
+import { bareModelId } from "./pricing.js";
+/**
+ * Synthetic provider names registered with spectral's `ModelRegistry`. They route
+ * 100% of inference traffic through the backend (`${backendUrl}/v1`), which
+ * authenticates with the machine JWT and forwards to the upstream provider
+ * with centrally-managed API keys.
+ *
+ * Two providers (rather than one): `spectral-proxy-openai` for upstream catalog
+ * models (OpenRouter, DeepSeek, OpenAI, etc.), and
+ * `spectral-proxy-user-model` for team-registered built-in UserModel entries.
+ * Both use the OpenAI-compatible `/chat/completions` request shape.
+ */
+export const SPECTRAL_PROXY_OPENAI = "spectral-proxy-openai";
+export const SPECTRAL_PROXY_USER_MODEL = "spectral-proxy-user-model";
+const KIMI_K2_7_CODE_CONTEXT_WINDOW = 262_144;
+export function inferSyntheticContextWindow(model) {
+    if (typeof model.contextWindow === "number" &&
+        Number.isFinite(model.contextWindow)) {
+        return model.contextWindow;
+    }
+    const modelId = model.modelId.toLowerCase();
+    const bare = bareModelId(modelId);
+    if (modelId === "moonshotai/kimi-k2.7-code" ||
+        bare === "kimi-k2.7-code" ||
+        bare === "local-openrouter-kimi") {
+        return KIMI_K2_7_CODE_CONTEXT_WINDOW;
+    }
+    return 0;
+}
+export function inferSyntheticThinkingLevelMap(model) {
+    if (!model.supportsReasoning)
+        return undefined;
+    const modelId = model.modelId.toLowerCase();
+    const bare = bareModelId(modelId);
+    if (model.provider === "built-in" &&
+        (modelId.includes("gpt-5") || bare.includes("gpt-5"))) {
+        return {
+            off: "none",
+            minimal: "minimal",
+            low: "low",
+            medium: "medium",
+            high: "high",
+            xhigh: "xhigh",
+        };
+    }
+    return undefined;
+}
+export function inferSyntheticOpenAICompat(model) {
+    const bare = bareModelId(model.modelId);
+    const isDeepSeek = model.provider === "deepseek" ||
+        model.modelId.startsWith("deepseek/") ||
+        bare.startsWith("deepseek");
+    if (isDeepSeek) {
+        return {
+            thinkingFormat: "deepseek",
+            requiresReasoningContentOnAssistantMessages: true,
+            supportsDeveloperRole: false,
+        };
+    }
+    if (model.provider === "built-in") {
+        const compat = {
+            // Built-in models are proxied through the backend, which forwards a
+            // session-affinity key to OpenRouter for prompt-cache sticky routing.
+            // Sending the real per-session id from the CLI lets the backend use it
+            // instead of a coarser machine/team fallback, maximizing cache hits on
+            // large multi-turn agentic prompts.
+            sendSessionAffinityHeaders: true,
+        };
+        if (model.modelId.toLowerCase().includes("gpt-5") ||
+            bare.toLowerCase().includes("gpt-5")) {
+            compat.thinkingFormat = "openai";
+            compat.supportsReasoningEffort = true;
+            compat.supportsStore = false;
+        }
+        return compat;
+    }
+    if (model.provider === "openrouter") {
+        const compat = {
+            thinkingFormat: "openrouter",
+        };
+        return compat;
+    }
+    return undefined;
+}

package/dist/server/agent-bridge.d.ts

@@ -54,6 +54,10 @@ import { fetchAllowedModels as defaultFetchAllowedModels } from "../relay/models
 import type { SessionMemorySnapshot } from "./storage.js";
 import type { ImageAttachment, ServerEvent, WireMessage } from "./wire.js";
 import type { DevProcessRegistry } from "./dev-process-registry.js";
+export { bareModelId, calculateCredits, getModelCost, lookupPricing, } from "./agent-bridge/pricing.js";
+export { SPECTRAL_PROXY_OPENAI, SPECTRAL_PROXY_USER_MODEL, inferSyntheticContextWindow, inferSyntheticOpenAICompat, inferSyntheticThinkingLevelMap, } from "./agent-bridge/synthetic-model.js";
+export { parseWireToolEvents, sanitizeRehydratedBlock, toRestoredMemorySnapshot, } from "./agent-bridge/rehydrate.js";
+export { createHeadlessUIContext } from "./agent-bridge/headless-ui.js";
 interface AgentBridgeCompactionOptions {
     customInstructions?: string;
     phaseBoundary?: boolean;
@@ -218,6 +222,13 @@ export declare class AgentBridge {
      * timer flushes it once the minimum interval has elapsed.
      */
     private subagentProgressThrottle;
+    /**
+     * toolCallId → startedAt captured at `tool_execution_start` so the
+     * terminal `tool_result` can carry the real start time (durations
+     * end-to-end). Entries with no end event are bounded: more than 2000
+     * orphans means ids are never resolving, so the oldest are cleared.
+     */
+    private toolStartedAt;
     constructor(opts: AgentBridgeOptions);
     /**
      * Create the spectral session, wire up subscription, and return.
@@ -501,5 +512,4 @@ export declare class AgentBridge {
      */
     handleEvent(ev: AgentSessionEvent): void;
 }
-export {};
 //# sourceMappingURL=agent-bridge.d.ts.map