dsh-lcx-codex 0.4.2 → 0.4.3-pre.13

package/lib/search-accounting.js

@@ -0,0 +1,86 @@
+export const object = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const count = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+export const zeroBuckets = () => ({ uncachedInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 });
+export const isSearchTool = (name) => name === 'web_search' || name === 'websearch_gpt_advanced';
+export function auxiliaryUsageOf(event, toolName) {
+    if (!object(event) || event.type !== 'tool/result' || !object(event.data?.meta))
+        return [];
+    // Only our owned search results may contribute auxiliary billing.
+    // Official ToolMessageSource carries only callId; resolve its name from tool/call.
+    if (!isSearchTool(toolName))
+        return [];
+    const raw = event.data.meta.auxiliaryUsage;
+    if (!Array.isArray(raw))
+        return [];
+    const ids = new Set(), result = [];
+    for (const item of raw) {
+        if (!object(item) || typeof item.requestId !== 'string' || !item.requestId
+            || typeof item.provider !== 'string' || !item.provider || typeof item.model !== 'string' || !item.model
+            || !object(item.usage) || ids.has(item.requestId))
+            continue;
+        const u = item.usage;
+        if (![u.inputTokens, u.outputTokens, u.totalTokens, u.cacheReadTokens, u.cacheWriteTokens].every(count)
+            || u.inputTokens + u.outputTokens + u.cacheReadTokens + u.cacheWriteTokens !== u.totalTokens)
+            continue;
+        ids.add(item.requestId);
+        result.push(item);
+    }
+    return result;
+}
+export function addUsage(base, records) {
+    if (!records.length)
+        return base;
+    const next = { ...base };
+    for (const { usage: u } of records) {
+        next.uncachedInputTokens += u.inputTokens;
+        next.outputTokens += u.outputTokens;
+        next.cacheReadTokens += u.cacheReadTokens;
+        next.cacheWriteTokens += u.cacheWriteTokens;
+    }
+    if (!Object.values(next).every(count))
+        throw new Error('LCX search usage exceeds safe counters');
+    return next;
+}
+export function mergeBuckets(base, extra) {
+    if (!object(base) || Object.values(extra).every(n => n === 0))
+        return base;
+    const next = { ...base };
+    for (const key of Object.keys(extra)) {
+        // Keep unavailable host buckets unavailable rather than inventing zero.
+        if (count(base[key]))
+            next[key] = base[key] + extra[key];
+    }
+    return next;
+}
+export function addTurnUsage(base, records) {
+    if (!object(base) || !records.length || !count(base.totalTokens))
+        return base;
+    const next = mergeBuckets(base, addUsage(zeroBuckets(), records));
+    next.totalTokens = base.totalTokens + records.reduce((n, r) => n + r.usage.totalTokens, 0);
+    // Auxiliary responses do not always disclose a reasoning subset.
+    delete next.reasoningTokens;
+    if (Array.isArray(base.routes)) {
+        const routes = new Map();
+        for (const r of [...base.routes, ...records])
+            routes.set(`${r.provider}\0${r.model}`, { provider: r.provider, model: r.model });
+        next.routes = [...routes.values()];
+    }
+    return next;
+}
+/** The metadata is presentation/accounting state; it never changes request messages. */
+export function aggregateContextOf(event) {
+    if (!object(event) || !['assistant/message', 'assistant/attempt'].includes(event.type) || !object(event.data))
+        return;
+    const chunks = Array.isArray(event.data.stream) ? event.data.stream.filter((e) => e.type === 'chunk').map((e) => e.chunk) : [];
+    const sample = event.data.usage ?? chunks.findLast((c) => c?.type === 'usage')?.usage;
+    if (!object(sample))
+        return;
+    const replay = chunks.findLast((c) => c?.type === 'finish')?.replayState;
+    const mark = replay?.response?.lcxUsage;
+    if (mark?.version === 1 && ['request', 'aggregate'].includes(mark.inputTokenScope))
+        return mark.inputTokenScope === 'aggregate';
+    // Read the already-installed local candidate without rewriting its logs.
+    if (sample.inputTokenScope === 'aggregate' || sample.inputTokenScope === 'request')
+        return sample.inputTokenScope === 'aggregate';
+    return replay?.grokNative?.kind === 'xai-responses-native-search' && replay.grokNative.version === 3;
+}

package/lib/search-usage.js

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { SessionSeq } from '@deepseek-ai/dsh-session';
+import { addUsage, aggregateContextOf, auxiliaryUsageOf, isSearchTool, zeroBuckets } from './search-accounting.js';
+const n = z.number().int().nonnegative();
+const schema = z.object({ auxiliary: z.object({ uncachedInputTokens: n, outputTokens: n, cacheReadTokens: n, cacheWriteTokens: n }).strict(), aggregateContext: z.boolean() }).strict();
+/** Separate, durable extension: the host's own usage projection remains primary-call billing. */
+export const searchUsageProjection = {
+    key: 'lcxSearchUsage', stateVersion: 2, stateSchema: schema.extend({ pending: z.record(z.string(), z.string()) }),
+    init: () => ({ auxiliary: zeroBuckets(), aggregateContext: false, pending: {} }),
+    apply(state, event) {
+        if (event.type === 'tool/call' && isSearchTool(event.data.name))
+            return { ...state, pending: { ...state.pending, [event.data.callId]: event.data.name } };
+        const callId = event.type === 'tool/result' ? event.data.message.source.callId : undefined;
+        const auxiliary = addUsage(state.auxiliary, auxiliaryUsageOf(event, callId ? state.pending[callId] : undefined));
+        const aggregateContext = aggregateContextOf(event) ?? state.aggregateContext;
+        if (callId && Object.hasOwn(state.pending, callId)) {
+            const pending = { ...state.pending };
+            delete pending[callId];
+            return { auxiliary, aggregateContext, pending };
+        }
+        if (event.type === 'turn/end' && Object.keys(state.pending).length)
+            return { auxiliary, aggregateContext, pending: {} };
+        return auxiliary === state.auxiliary && aggregateContext === state.aggregateContext ? state : { ...state, auxiliary, aggregateContext };
+    },
+    wire: { viewSchema: schema, view: ({ auxiliary, aggregateContext }) => ({ auxiliary, aggregateContext }) },
+};
+const installed = new WeakMap();
+/** Own a reversible adapter on the public measure method, never a DSH file or private fold. */
+export function installSearchMeasurement(meter) {
+    const existing = installed.get(meter);
+    if (existing) {
+        existing.refs++;
+        let active = true;
+        return () => { if (active) {
+            active = false;
+            release(meter);
+        } };
+    }
+    const original = meter.measure, descriptor = Object.getOwnPropertyDescriptor(meter, 'measure');
+    const cursors = new WeakMap();
+    function measure(session, header) {
+        const value = original.call(this, session, header);
+        let state = cursors.get(session) ?? { seq: 0, aggregate: false };
+        while (state.seq < session.seq) {
+            const e = session.eventAt(SessionSeq(state.seq++));
+            if (e?.type === 'assistant/message')
+                state.aggregate = aggregateContextOf(e) ?? false;
+        }
+        cursors.set(session, state);
+        if (!state.aggregate || value.baseline.kind !== 'usage')
+            return value;
+        // The official measure already prices retained images/files and surface replacements.
+        // Only discard its unsuitable aggregate anchor; keep its current surface and node prices.
+        const tools = (header ?? session.requestHeader())?.tools;
+        const toolTokens = !tools?.length ? 0 : Math.ceil(JSON.stringify(tools).length / 4) + 4;
+        const tokens = value.surfaceTokens + toolTokens;
+        return Object.freeze({ ...value, baseline: Object.freeze({ kind: 'estimated', tokens }), surfaceDeltaTokens: 0, totalTokens: tokens });
+    }
+    Object.defineProperty(meter, 'measure', { configurable: true, writable: true, value: measure });
+    installed.set(meter, { refs: 1, release() {
+            if (Object.getOwnPropertyDescriptor(meter, 'measure')?.value !== measure)
+                return;
+            if (descriptor)
+                Object.defineProperty(meter, 'measure', descriptor);
+            else
+                delete meter.measure;
+        } });
+    let active = true;
+    return () => { if (active) {
+        active = false;
+        release(meter);
+    } };
+}
+function release(meter) {
+    const record = installed.get(meter);
+    if (record && --record.refs === 0) {
+        record.release();
+        installed.delete(meter);
+    }
+}
+export function installSearchUsage(ctx) {
+    ctx.inject(['sessionProjections'], c => { c.sessionProjections.register(searchUsageProjection); });
+    ctx.inject(['tokenMeter'], c => {
+        c.effect(() => installSearchMeasurement(c.tokenMeter), 'lcx search context measurement');
+    });
+}

package/lib/service-mutex.js

@@ -1,72 +1,81 @@
 function abortReason(signal) {
-  if (signal?.reason instanceof Error) return signal.reason
-  return new DOMException('The operation was aborted', 'AbortError')
+    if (signal?.reason instanceof Error)
+        return signal.reason;
+    return new DOMException("The operation was aborted", "AbortError");
 }
-
 export class ServiceMutex {
-  constructor() {
-    this.locked = false
-    this.closed = false
-    this.closeReason = undefined
-    this.queue = []
-    this.idleWaiters = []
-  }
-
-  acquire(signal) {
-    if (this.closed) return Promise.reject(this.closeReason ?? new Error('service mutex closed'))
-    if (signal?.aborted) return Promise.reject(abortReason(signal))
-    if (!this.locked) {
-      this.locked = true
-      return Promise.resolve(() => this.release())
+    locked = false;
+    closed = false;
+    closeReason;
+    queue = [];
+    idleWaiters = [];
+    constructor() { }
+    acquire(signal) {
+        if (this.closed)
+            return Promise.reject(this.closeReason ?? new Error("service mutex closed"));
+        if (signal?.aborted)
+            return Promise.reject(abortReason(signal));
+        if (!this.locked) {
+            this.locked = true;
+            return Promise.resolve(() => this.release());
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = { resolve, reject, signal };
+            if (signal) {
+                const onAbort = () => {
+                    const index = this.queue.indexOf(waiter);
+                    if (index >= 0)
+                        this.queue.splice(index, 1);
+                    signal.removeEventListener("abort", onAbort);
+                    reject(abortReason(signal));
+                };
+                waiter.onAbort = onAbort;
+                signal.addEventListener("abort", onAbort, { once: true });
+            }
+            this.queue.push(waiter);
+        });
     }
-    return new Promise((resolve, reject) => {
-      const waiter = { resolve, reject, signal, onAbort: undefined }
-      if (signal) {
-        waiter.onAbort = () => {
-          const index = this.queue.indexOf(waiter)
-          if (index >= 0) this.queue.splice(index, 1)
-          signal.removeEventListener('abort', waiter.onAbort)
-          reject(abortReason(signal))
+    release() {
+        while (this.queue.length > 0) {
+            const waiter = this.queue.shift();
+            if (!waiter)
+                continue;
+            if (waiter.signal && waiter.onAbort)
+                waiter.signal.removeEventListener("abort", waiter.onAbort);
+            if (waiter.signal?.aborted) {
+                waiter.reject(abortReason(waiter.signal));
+                continue;
+            }
+            waiter.resolve(() => this.release());
+            return;
         }
-        signal.addEventListener('abort', waiter.onAbort, { once: true })
-      }
-      this.queue.push(waiter)
-    })
-  }
-
-  release() {
-    while (this.queue.length > 0) {
-      const waiter = this.queue.shift()
-      if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener('abort', waiter.onAbort)
-      if (waiter.signal?.aborted) {
-        waiter.reject(abortReason(waiter.signal))
-        continue
-      }
-      waiter.resolve(() => this.release())
-      return
+        this.locked = false;
+        const idle = this.idleWaiters.splice(0);
+        for (const resolve of idle)
+            resolve();
     }
-    this.locked = false
-    const idle = this.idleWaiters.splice(0)
-    for (const resolve of idle) resolve()
-  }
-
-  async run(signal, task) {
-    const release = await this.acquire(signal)
-    try { return await task() }
-    finally { release() }
-  }
-
-  close(reason = new Error('service mutex closing')) {
-    if (!this.closed) {
-      this.closed = true
-      this.closeReason = reason
-      const queued = this.queue.splice(0)
-      for (const waiter of queued) {
-        if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener('abort', waiter.onAbort)
-        waiter.reject(reason)
-      }
+    async run(signal, task) {
+        const release = await this.acquire(signal);
+        try {
+            return await task();
+        }
+        finally {
+            release();
+        }
+    }
+    close(reason = new Error("service mutex closing")) {
+        if (!this.closed) {
+            this.closed = true;
+            this.closeReason = reason;
+            const queued = this.queue.splice(0);
+            for (const waiter of queued) {
+                if (waiter.signal && waiter.onAbort)
+                    waiter.signal.removeEventListener("abort", waiter.onAbort);
+                waiter.reject(reason);
+            }
+        }
+        if (!this.locked)
+            return Promise.resolve();
+        return new Promise((resolve) => this.idleWaiters.push(resolve));
     }
-    if (!this.locked) return Promise.resolve()
-    return new Promise((resolve) => this.idleWaiters.push(resolve))
-  }
 }

package/lib/token-budget.js

@@ -1,19 +1,15 @@
-// @ts-check
-
-/** @typedef {Record<string, unknown>} UnknownRecord */
-
-export const PORTABLE_BUDGET_ERROR_CODE = 'LCX_PORTABLE_BUDGET_EXCEEDED'
-const MAX_BUDGET_INPUT_CHARS = 2_000_000
-const CONSERVATIVE_IMAGE_TOKEN_COST = 2_048
-const CJK = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u
-const ASCII_WORD = /[A-Za-z0-9]/u
-const STRUCTURAL = /[\p{P}\p{S}]/u
-const DATA_URI = /^data:[^;,\s]+(?:;[^,\s]*)?;base64,[A-Za-z0-9+/\s]+={0,2}$/u
-const ENCODED_TEXT = /^[A-Za-z0-9+/_-]{512,}={0,2}$/u
-
+export const PORTABLE_BUDGET_ERROR_CODE = "LCX_PORTABLE_BUDGET_EXCEEDED";
+const MAX_BUDGET_INPUT_CHARS = 2_000_000;
+const CONSERVATIVE_IMAGE_TOKEN_COST = 2_048;
+const CJK = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+const ASCII_WORD = /[A-Za-z0-9]/u;
+const STRUCTURAL = /[\p{P}\p{S}]/u;
+const DATA_URI = /^data:[^;,\s]+(?:;[^,\s]*)?;base64,[A-Za-z0-9+/\s]+={0,2}$/u;
+const ENCODED_TEXT = /^[A-Za-z0-9+/_-]{512,}={0,2}$/u;
 /** @param {string} value */
-function looksEncodedText(value) { return DATA_URI.test(value) || ENCODED_TEXT.test(value) }
-
+function looksEncodedText(value) {
+    return DATA_URI.test(value) || ENCODED_TEXT.test(value);
+}
 /**
  * A small conservative fallback, deliberately not a tokenizer. The baseline
  * preserves legacy /4 while CJK and structural characters cost more.
@@ -21,84 +17,133 @@ function looksEncodedText(value) { return DATA_URI.test(value) || ENCODED_TEXT.t
  * @returns {number | undefined}
  */
 export function estimateTextTokens(value) {
-  if (typeof value !== 'string') return undefined
-  if (value.length > MAX_BUDGET_INPUT_CHARS || looksEncodedText(value)) return Math.max(1, value.length)
-  let weighted = 0
-  let asciiRun = 0
-  const flushAscii = () => { if (asciiRun > 0) weighted += Math.ceil(asciiRun / 4); asciiRun = 0 }
-  for (const char of value) {
-    if (ASCII_WORD.test(char)) { asciiRun += 1; continue }
-    flushAscii()
-    if (/\s/u.test(char)) continue
-    if (CJK.test(char) || STRUCTURAL.test(char)) weighted += 1
-    else weighted += Math.ceil(char.length / 2)
-  }
-  flushAscii()
-  return Math.max(1, Math.ceil(value.length / 4), weighted)
+    if (typeof value !== "string")
+        return undefined;
+    if (value.length > MAX_BUDGET_INPUT_CHARS || looksEncodedText(value))
+        return Math.max(1, value.length);
+    let weighted = 0;
+    let asciiRun = 0;
+    const flushAscii = () => {
+        if (asciiRun > 0)
+            weighted += Math.ceil(asciiRun / 4);
+        asciiRun = 0;
+    };
+    for (const char of value) {
+        if (ASCII_WORD.test(char)) {
+            asciiRun += 1;
+            continue;
+        }
+        flushAscii();
+        if (/\s/u.test(char))
+            continue;
+        if (CJK.test(char) || STRUCTURAL.test(char))
+            weighted += 1;
+        else
+            weighted += Math.ceil(char.length / 2);
+    }
+    flushAscii();
+    return Math.max(1, Math.ceil(value.length / 4), weighted);
 }
-
 /**
  * @param {unknown} value
  * @returns {value is UnknownRecord}
  */
-function isObject(value) { return value !== null && typeof value === 'object' && !Array.isArray(value) }
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 /**
  * @param {unknown} value
  * @param {Set<object>} [seen]
  * @returns {boolean}
  */
 function containsOpaqueValue(value, seen = new Set()) {
-  if (value === null || typeof value !== 'object') return false
-  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer || seen.has(value)) return true
-  seen.add(value)
-  return Object.values(value).some((entry) => containsOpaqueValue(entry, seen))
+    if (value === null || typeof value !== "object")
+        return false;
+    if (ArrayBuffer.isView(value) ||
+        value instanceof ArrayBuffer ||
+        seen.has(value))
+        return true;
+    seen.add(value);
+    return Object.values(value).some((entry) => containsOpaqueValue(entry, seen));
 }
 /** @param {unknown} value */
-function safeJson(value) { try { if (containsOpaqueValue(value)) return undefined; const encoded = JSON.stringify(value); return typeof encoded === 'string' ? encoded : undefined } catch { return undefined } }
+function safeJson(value) {
+    try {
+        if (containsOpaqueValue(value))
+            return undefined;
+        const encoded = JSON.stringify(value);
+        return typeof encoded === "string" ? encoded : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** @param {unknown} value */
-function safeScalar(value) { return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' ? String(value) : undefined }
-
+function safeScalar(value) {
+    return typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean"
+        ? String(value)
+        : undefined;
+}
 /**
  * @param {unknown} content
  * @returns {unknown[] | undefined}
  */
 function visibleContent(content) {
-  if (typeof content === 'string') return [{ type: 'text', text: content }]
-  if (!Array.isArray(content)) return undefined
-  const parts = []
-  for (const part of content) {
-    if (!isObject(part) || typeof part.type !== 'string') return undefined
-    if (['text', 'input_text', 'output_text'].includes(part.type)) {
-      if (typeof part.text !== 'string') return undefined
-      parts.push({ type: part.type, text: part.text })
-      continue
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    if (!Array.isArray(content))
+        return undefined;
+    const parts = [];
+    for (const part of content) {
+        if (!isObject(part) || typeof part.type !== "string")
+            return undefined;
+        if (["text", "input_text", "output_text"].includes(part.type)) {
+            if (typeof part.text !== "string")
+                return undefined;
+            parts.push({ type: part.type, text: part.text });
+            continue;
+        }
+        if (part.type === "reasoning") {
+            if (typeof part.text !== "string")
+                return undefined;
+            parts.push({ type: "reasoning", text: part.text });
+            continue;
+        }
+        if (part.type === "tool-call") {
+            const id = safeScalar(part.id);
+            const name = safeScalar(part.name);
+            const argumentsText = safeJson(part.arguments);
+            if (id === undefined || name === undefined || argumentsText === undefined)
+                return undefined;
+            parts.push({ type: "tool-call", id, name, arguments: argumentsText });
+            continue;
+        }
+        if (part.type === "tool-result") {
+            const toolCallId = safeScalar(part.toolCallId);
+            const toolName = safeScalar(part.toolName ?? part.name ?? "unknown");
+            const nested = visibleContent(part.content);
+            if (toolCallId === undefined ||
+                toolName === undefined ||
+                nested === undefined)
+                return undefined;
+            parts.push({
+                type: "tool-result",
+                toolCallId,
+                toolName,
+                content: nested,
+            });
+            continue;
+        }
+        if (["image", "input_image", "output_image", "dsh_image_attachment"].includes(part.type)) {
+            parts.push({ type: part.type, image: true });
+            continue;
+        }
+        return undefined;
     }
-    if (part.type === 'reasoning') {
-      if (typeof part.text !== 'string') return undefined
-      parts.push({ type: 'reasoning', text: part.text })
-      continue
-    }
-    if (part.type === 'tool-call') {
-      const id = safeScalar(part.id); const name = safeScalar(part.name); const argumentsText = safeJson(part.arguments)
-      if (id === undefined || name === undefined || argumentsText === undefined) return undefined
-      parts.push({ type: 'tool-call', id, name, arguments: argumentsText })
-      continue
-    }
-    if (part.type === 'tool-result') {
-      const toolCallId = safeScalar(part.toolCallId); const toolName = safeScalar(part.toolName ?? part.name ?? 'unknown'); const nested = visibleContent(part.content)
-      if (toolCallId === undefined || toolName === undefined || nested === undefined) return undefined
-      parts.push({ type: 'tool-result', toolCallId, toolName, content: nested })
-      continue
-    }
-    if (['image', 'input_image', 'output_image', 'dsh_image_attachment'].includes(part.type)) {
-      parts.push({ type: part.type, image: true })
-      continue
-    }
-    return undefined
-  }
-  return parts
+    return parts;
 }
-
 /**
  * Project an item to model-visible fields only. Opaque provider state, raw
  * binary, and replay/session metadata are intentionally excluded.
@@ -106,21 +151,39 @@ function visibleContent(content) {
  * @returns {unknown | undefined}
  */
 export function modelVisibleBudgetView(item) {
-  if (!isObject(item)) return undefined
-  if (item.type === 'function_call') {
-    const callId = safeScalar(item.call_id); const name = safeScalar(item.name); const argumentsText = safeJson(item.arguments)
-    return callId === undefined || name === undefined || argumentsText === undefined ? undefined : { type: 'function_call', call_id: callId, name, arguments: argumentsText }
-  }
-  if (item.type === 'function_call_output') {
-    const callId = safeScalar(item.call_id); const output = typeof item.output === 'string' ? item.output : safeJson(item.output)
-    return callId === undefined || output === undefined ? undefined : { type: 'function_call_output', call_id: callId, output }
-  }
-  if (item.type !== undefined && item.type !== 'message') return undefined
-  if (!['developer', 'system', 'user', 'assistant'].includes(String(item.role ?? ''))) return undefined
-  const content = visibleContent(item.content)
-  return content === undefined ? undefined : { role: String(item.role), content }
+    if (!isObject(item))
+        return undefined;
+    if (item.type === "function_call") {
+        const callId = safeScalar(item.call_id);
+        const name = safeScalar(item.name);
+        const argumentsText = safeJson(item.arguments);
+        return callId === undefined ||
+            name === undefined ||
+            argumentsText === undefined
+            ? undefined
+            : {
+                type: "function_call",
+                call_id: callId,
+                name,
+                arguments: argumentsText,
+            };
+    }
+    if (item.type === "function_call_output") {
+        const callId = safeScalar(item.call_id);
+        const output = typeof item.output === "string" ? item.output : safeJson(item.output);
+        return callId === undefined || output === undefined
+            ? undefined
+            : { type: "function_call_output", call_id: callId, output };
+    }
+    if (item.type !== undefined && item.type !== "message")
+        return undefined;
+    if (!["developer", "system", "user", "assistant"].includes(String(item.role ?? "")))
+        return undefined;
+    const content = visibleContent(item.content);
+    return content === undefined
+        ? undefined
+        : { role: String(item.role), content };
 }
-
 /**
  * Images have provider/model-dependent costs. Count each known image block with
  * a fixed conservative surcharge without inspecting base64 or attachment data.
@@ -128,38 +191,43 @@ export function modelVisibleBudgetView(item) {
  * @returns {number}
  */
 function imageTokenCost(value) {
-  if (Array.isArray(value)) {
-    let total = 0
-    for (const entry of value) total += imageTokenCost(entry)
-    return total
-  }
-  if (!isObject(value)) return 0
-  let total = value.image === true ? CONSERVATIVE_IMAGE_TOKEN_COST : 0
-  for (const entry of Object.values(value)) total += imageTokenCost(entry)
-  return total
+    if (Array.isArray(value)) {
+        let total = 0;
+        for (const entry of value)
+            total += imageTokenCost(entry);
+        return total;
+    }
+    if (!isObject(value))
+        return 0;
+    let total = value.image === true ? CONSERVATIVE_IMAGE_TOKEN_COST : 0;
+    for (const entry of Object.values(value))
+        total += imageTokenCost(entry);
+    return total;
 }
-
 /**
  * @param {unknown} item
  * @returns {number | undefined}
  */
 export function estimateBudgetItem(item) {
-  const view = modelVisibleBudgetView(item)
-  if (view === undefined) return undefined
-  const encoded = safeJson(view)
-  const textCost = estimateTextTokens(encoded)
-  return textCost === undefined ? undefined : textCost + imageTokenCost(view)
+    const view = modelVisibleBudgetView(item);
+    if (view === undefined)
+        return undefined;
+    const encoded = safeJson(view);
+    const textCost = estimateTextTokens(encoded);
+    return textCost === undefined ? undefined : textCost + imageTokenCost(view);
 }
-
 /** @param {unknown} maxChars */
 export function portableTokenCeiling(maxChars) {
-  return Number.isSafeInteger(maxChars) && /** @type {number} */ (maxChars) > 0 ? Math.ceil(/** @type {number} */ (maxChars) / 4) : undefined
+    return typeof maxChars === "number" &&
+        Number.isSafeInteger(maxChars) &&
+        maxChars > 0
+        ? Math.ceil(maxChars / 4)
+        : undefined;
 }
-
 /** @param {string} message */
 export function portableBudgetError(message) {
-  /** @type {Error & { code?: string }} */
-  const error = new Error(message)
-  error.code = PORTABLE_BUDGET_ERROR_CODE
-  return error
+    /** @type {Error & { code?: string }} */
+    const error = new Error(message);
+    error.code = PORTABLE_BUDGET_ERROR_CODE;
+    return error;
 }