@combycode/llm-sdk 3.2.1 → 3.3.0

package/dist/llm/client-internal.d.ts

@@ -46,5 +46,7 @@ export interface ClientRouting {
     readonly cacheName: string;
 }
 export declare function buildContext(client: LLMClient, options: ExecuteOptions): RequestContext;
-export declare function resolveApi(provider: ProviderName, api?: ApiType | 'auto'): ApiType;
+export declare function resolveApi(provider: ProviderName, api?: ApiType | 'auto', 
+/** The catalog's per-model preference, when the model is a known one. */
+preferred?: ApiType | null): ApiType;
 export declare function resolveAdapter(config: LLMClientConfig, api: ApiType): ProviderAdapter;

package/dist/llm/client.d.ts

@@ -88,6 +88,16 @@ export declare class LLMClient {
     /** Anything the spec left out on purpose reaches the caller as a warning.
      *  Said once per request; the build already de-duplicates within one. */
     private reportBuildNotes;
+    /** Drop `thinking: { mode: 'off' }` where the model cannot honour it, and say
+     *  so. Returns the note, or null when there was nothing to adjust.
+     *
+     *  Dropped rather than sent: the wire spec turns `off` into a real field
+     *  (`thinkingBudget: 0` on 2.5, `thinkingLevel: MINIMAL` on 3.x), and the
+     *  models flagged here answer 400 to it. The caller gets a request that works
+     *  plus a warning that their instruction could not be followed, instead of a
+     *  failed call — or, worse, the silence this replaced, where `off` was
+     *  accepted, nothing was emitted, and the model reasoned anyway. */
+    private limitThinking;
     complete(input: string | ContentPart[] | Message[], options?: ExecuteOptions): Promise<CompletionResponse>;
     /** Run `complete` with a JSON Schema enforced via `structured`. Strips any
      *  leading/trailing markdown fences from the model reply, then JSON.parses

package/dist/llm/providers/anthropic/messages.d.ts

@@ -7,12 +7,37 @@ import type { SSEEvent } from '../../../network/types';
 import type { ContentPart } from '../../types/messages';
 import type { ProviderAdapter, ProviderHttpRequest } from '../../types/provider';
 import type { NormalizedRequest } from '../../types/request';
-import { type CompletionResponse } from '../../types/response';
+import { type CompletionResponse, type FileOutput, type Usage } from '../../types/response';
 import type { StreamEvent } from '../../types/stream';
 export interface AnthropicAdapterConfig {
     apiKey: string;
     baseURL?: string;
 }
+/** Billed tier (response usage.service_tier) → {raw, catalog key}. Identity:
+ *  the catalog is keyed by Anthropic's own billed names (standard|priority|batch). */
+export declare function anthropicBilledTier(raw: unknown): {
+    serviceTier?: string;
+    pricingTier?: string;
+};
+/** Extract hosted code-execution output files from one content block. Shared by
+ *  the buffered (`parseResponse`) and streamed (`content_block_start`) paths so
+ *  both surface the exact same `FileOutput[]`. The current tool
+ *  (code_execution_20260521) emits `bash_code_execution_tool_result` →
+ *  `bash_code_execution_result` → `content[]` of `bash_code_execution_output`;
+ *  older tool versions emit the `code_execution_*` equivalents. Both carry
+ *  `file_id`. (`text_editor_code_execution_tool_result` blocks are file
+ *  create/view/edit markers with no downloadable id, so they are not surfaced.) */
+export declare function filesFromCodeExecBlock(block: Record<string, unknown>): FileOutput[];
+/** Builtin-tool payload from a `server_tool_use` input: the code (code execution)
+ *  or the query (web search). Shared by the buffered + streamed paths. */
+export declare function builtinInputPayload(tool: string, input: Record<string, unknown> | undefined): {
+    code?: string;
+    query?: string;
+    url?: string;
+};
+/** stdout from a code-execution `*_tool_result` block's content, if present. */
+export declare function resultStdout(content: unknown): string | undefined;
+export declare function anthropicUsage(u: Record<string, unknown> | undefined): Usage;
 export declare class AnthropicAdapter implements ProviderAdapter {
     readonly name: "anthropic";
     protected readonly apiKey: string;
@@ -42,12 +67,12 @@ export declare class AnthropicAdapter implements ProviderAdapter {
     }, _req: NormalizedRequest, forceCache?: boolean): Record<string, unknown>;
     private buildContentPart;
     parseResponse(raw: unknown, latencyMs: number): CompletionResponse;
+    /** Stateless entry, as the ProviderAdapter interface requires: a fresh spec
+     *  run per event, so nothing correlates across events. */
     parseStreamEvent(event: SSEEvent): StreamEvent[];
-    /** Stateful — Anthropic streams `server_tool_use` input via `input_json_delta`
-     *  (empty at block start) and returns the result in a separate `*_tool_result`
-     *  block. The closure accumulates each call's input (code / query) and attaches it
-     *  to the matching `builtin_tool_end`. */
+    /** Stateful, and the one callers should use. Anthropic streams a
+     *  `server_tool_use` input via `input_json_delta` and returns the result in a
+     *  separate `*_tool_result` block, so the input has to be carried between
+     *  them; the spec's `state` is where that lives now. */
     createStreamParser(): (event: SSEEvent) => StreamEvent[];
-    private streamEvents;
-    private parseUsage;
 }

package/dist/llm/providers/anthropic/response-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const ANTHROPIC_RESPONSE_REGISTRY: Registry;

package/dist/llm/providers/anthropic/stream-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const ANTHROPIC_STREAM_REGISTRY: Registry;

package/dist/llm/providers/google/generate.d.ts

@@ -3,12 +3,15 @@ import type { SSEEvent } from '../../../network/types';
 import type { ContentPart } from '../../types/messages';
 import type { ProviderAdapter, ProviderHttpRequest } from '../../types/provider';
 import type { NormalizedRequest } from '../../types/request';
-import { type CompletionResponse } from '../../types/response';
+import { type CompletionResponse, type Usage } from '../../types/response';
 import type { StreamEvent } from '../../types/stream';
 export interface GoogleAdapterConfig {
     apiKey: string;
     baseURL?: string;
 }
+/** generateContent token usage. Exported so the spec-driven parser runs this
+ *  and not a second copy of it. */
+export declare function googleUsage(u: Record<string, unknown> | undefined): Usage;
 export declare class GoogleAdapter implements ProviderAdapter {
     readonly name: "google";
     private readonly apiKey;
@@ -36,13 +39,9 @@ export declare class GoogleAdapter implements ProviderAdapter {
         content: string | ContentPart[];
     }): Record<string, unknown>;
     parseResponse(raw: unknown, latencyMs: number): CompletionResponse;
+    /** Stateless entry, as the ProviderAdapter interface requires: a fresh spec
+     *  run per event, so nothing correlates across events. */
     parseStreamEvent(event: SSEEvent): StreamEvent[];
-    /** Stateful — Google splits the code-execution marker (`executableCode` /
-     *  `codeExecutionResult`) and the produced file (`inlineData`) across parts and
-     *  often across SSE events. The closure remembers "code execution began in this
-     *  stream" so a later `inlineData` blob is routed to `files` (a code-exec
-     *  artifact) rather than `media` (conversational output). */
+    /** Stateful, and the one callers should use. The code-execution flag latches across chunks and decides whether inlineData is an artifact or media. */
     createStreamParser(): (event: SSEEvent) => StreamEvent[];
-    private streamEvents;
-    private parseUsage;
 }

package/dist/llm/providers/google/interactions-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const GOOGLE_INTERACTIONS_REGISTRY: Registry;

package/dist/llm/providers/google/interactions-stream-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const GOOGLE_INTERACTIONS_STREAM_REGISTRY: Registry;

package/dist/llm/providers/google/interactions.d.ts

@@ -6,12 +6,15 @@ import type { SSEEvent } from '../../../network/types';
 import type { Message } from '../../types/messages';
 import type { ProviderAdapter, ProviderHttpRequest } from '../../types/provider';
 import type { NormalizedRequest } from '../../types/request';
-import { type CompletionResponse } from '../../types/response';
+import { type CompletionResponse, type Usage } from '../../types/response';
 import type { StreamEvent } from '../../types/stream';
 export interface GoogleInteractionsAdapterConfig {
     apiKey: string;
     baseURL?: string;
 }
+/** Interactions token usage. Exported so the spec-driven parser runs this and
+ *  not a second copy of it. */
+export declare function googleInteractionsUsage(u: Record<string, unknown> | undefined): Usage;
 export declare class GoogleInteractionsAdapter implements ProviderAdapter {
     readonly name: "google";
     private readonly apiKey;
@@ -37,10 +40,9 @@ export declare class GoogleInteractionsAdapter implements ProviderAdapter {
      *  `interaction.failed` finish the turn (usage under `interaction.usage`). A
      *  function call's `arguments_delta` carries no id, so we correlate it to the
      *  currently-open call id held in `state`. */
-    private streamEvents;
+    /** Stateless entry, as the ProviderAdapter interface requires: a fresh spec
+     *  run per event, so nothing correlates across events. */
     parseStreamEvent(event: SSEEvent): StreamEvent[];
-    /** Per-stream stateful parser — correlates a function call's streamed arguments
-     *  and end to the call opened by its `step.start`. */
+    /** Stateful, and the one callers should use. The open call's id is carried between its fragments and its close. */
     createStreamParser(): (event: SSEEvent) => StreamEvent[];
-    private parseUsage;
 }

package/dist/llm/providers/google/response-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const GOOGLE_RESPONSE_REGISTRY: Registry;

package/dist/llm/providers/google/stream-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const GOOGLE_STREAM_REGISTRY: Registry;

package/dist/llm/providers/openai/completions.d.ts

@@ -4,7 +4,7 @@ import type { Registry } from '../../../wire/interpreter';
 import type { ContentPart } from '../../types/messages';
 import type { ProviderAdapter, ProviderHttpRequest } from '../../types/provider';
 import type { NormalizedRequest } from '../../types/request';
-import { type CompletionResponse } from '../../types/response';
+import { type CompletionResponse, type Usage } from '../../types/response';
 import type { StreamEvent } from '../../types/stream';
 export interface OpenAIAdapterConfig {
     apiKey: string;
@@ -15,7 +15,16 @@ export interface OpenAIAdapterConfig {
  *  for backends that omit ids), stable across the stream's chunks. */
 export interface OpenAIStreamState {
     toolIdByIndex: Map<number, string>;
+    /** Open audio output: gpt-audio streams its reply as `delta.audio`, and the
+     *  media_start/chunk/end trio has to be paired across events. */
+    audio?: {
+        open: boolean;
+        id?: string;
+    };
 }
+/** Token usage, from either Chat Completions or Responses naming. Exported so
+ *  the spec-driven parser calls the same code rather than a second copy. */
+export declare function openaiUsage(u: Record<string, unknown> | undefined): Usage;
 export declare class OpenAIAdapter implements ProviderAdapter {
     readonly name: ProviderAdapter['name'];
     protected readonly apiKey: string;
@@ -46,10 +55,19 @@ export declare class OpenAIAdapter implements ProviderAdapter {
     }): Record<string, unknown>[];
     private buildMessage;
     enableStreaming(providerReq: ProviderHttpRequest, _req: NormalizedRequest): void;
+    /** The response spec this adapter parses with. Overridden by OpenRouter,
+     *  which is Chat Completions plus one rule. */
+    protected responseSpecId(): string;
+    protected responseRegistry(): Registry;
     parseResponse(raw: unknown, latencyMs: number): CompletionResponse;
-    parseStreamEvent(event: SSEEvent, state?: OpenAIStreamState): StreamEvent[];
     /** Per-stream: correlates streamed tool-call fragments by index and synthesizes
      *  a stable id for backends that omit tool-call ids (see `parseStreamEvent`). */
+    /** Stateless entry, as the ProviderAdapter interface requires: a fresh spec
+     *  run per event, so nothing correlates across events. */
+    parseStreamEvent(event: SSEEvent): StreamEvent[];
+    /** Stateful, and the one callers should use. Tool-call fragments correlate by index because only the first carries an id. */
     createStreamParser(): (event: SSEEvent) => StreamEvent[];
-    private parseUsage;
+    /** Overridden by OpenRouter, which appends its `:online` web-search pair. */
+    protected streamSpecId(): string;
+    protected streamRegistry(): Registry;
 }

package/dist/llm/providers/openai/response-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const OPENAI_RESPONSE_REGISTRY: Registry;

package/dist/llm/providers/openai/responses-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const OPENAI_RESPONSES_REGISTRY: Registry;

package/dist/llm/providers/openai/responses-stream-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const OPENAI_RESPONSES_STREAM_REGISTRY: Registry;

package/dist/llm/providers/openai/responses.d.ts

@@ -3,16 +3,32 @@
  *  Modern API: input (not messages), instructions (not system role),
  *  output items (not choices), function_call/function_call_output for tools. */
 import type { SSEEvent } from '../../../network/types';
-import type { AssistantPhase, Message } from '../../types/messages';
+import type { Message, ToolCaller } from '../../types/messages';
 import type { Registry } from '../../../wire/interpreter';
 import type { ProviderAdapter, ProviderHttpRequest } from '../../types/provider';
 import type { NormalizedRequest } from '../../types/request';
-import { type CompletionResponse, type FileOutput, type Usage } from '../../types/response';
+import { type BuiltinToolCall, type CompletionResponse, type FileOutput, type Usage } from '../../types/response';
 import type { StreamEvent } from '../../types/stream';
 export interface OpenAIResponsesAdapterConfig {
     apiKey: string;
     baseURL?: string;
 }
+export declare function fromWireCaller(raw: unknown): ToolCaller | undefined;
+export declare function builtinCallFromResponsesItem(item: Record<string, unknown>): BuiltinToolCall | null;
+/** Extract hosted code-execution output files from one Responses output item.
+ *  Shared by the buffered (`parseResponse`) and streamed (`response.output_item.done`)
+ *  paths so both surface the exact same `FileOutput[]`. Two sources:
+ *    - `message` items → `container_file_citation` annotations (downloadable
+ *      container files, fetched by file id from `/v1/containers/{cid}/files/{id}`);
+ *    - `code_interpreter_call` items → image outputs returned by URL.
+ *
+ *  Dedup: `plt.show()` makes OpenAI emit an auto-display container file ALONGSIDE the
+ *  explicitly-saved one. When the same image was also saved, we drop the display
+ *  duplicate (matches ChatGPT's own UI); a display-only run keeps its sole figure. */
+export declare function filesFromResponsesOutputItem(item: Record<string, unknown>): FileOutput[];
+/** Responses-API token usage. Exported so the spec-driven parser runs this and
+ *  not a second copy of it. */
+export declare function openaiResponsesUsage(u: Record<string, unknown> | undefined): Usage;
 export declare class OpenAIResponsesAdapter implements ProviderAdapter {
     readonly name: ProviderAdapter['name'];
     protected readonly apiKey: string;
@@ -33,11 +49,23 @@ export declare class OpenAIResponsesAdapter implements ProviderAdapter {
     /** Reached through the wire registry while building the request. */
     buildInputItems(msg: Message, toolNames?: Map<string, string>): unknown[];
     enableStreaming(providerReq: ProviderHttpRequest): void;
+    /** Overridden by xAI, whose Responses API is this one. */
+    protected responseSpecId(): string;
+    /** Overridden alongside the spec id: xAI extends file extraction, so its
+     *  registry supplies a different `oaiRespFiles` -- the parse-side twin of its
+     *  `filesFromOutputItem` override. */
+    protected responseRegistry(): Registry;
     parseResponse(raw: unknown, latencyMs: number): CompletionResponse;
-    parseStreamEvent(event: SSEEvent, phaseByItem?: Map<string, AssistantPhase>): StreamEvent[];
     /** Stateless — each output item finalizes with all its file annotations in a
      *  single response.output_item.done event. */
+    /** Stateless entry, as the ProviderAdapter interface requires: a fresh spec
+     *  run per event, so nothing correlates across events. */
+    parseStreamEvent(event: SSEEvent): StreamEvent[];
+    /** Stateful, and the one callers should use. `phase` is announced once when an item is added but belongs on every text delta of that item, and the spec's state is where that is remembered. */
     createStreamParser(): (event: SSEEvent) => StreamEvent[];
+    /** Overridden by xAI, which extends file extraction. */
+    protected streamSpecId(): string;
+    protected streamRegistry(): Registry;
     /** Hosted code-execution output files from one output item. Overridable so
      *  Responses-compatible providers with a different file shape (e.g. xAI, which
      *  embeds files in the code-interpreter `logs` payload) can extend it. */

package/dist/llm/providers/openai/stream-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const OPENAI_STREAM_REGISTRY: Registry;

package/dist/llm/providers/openrouter/completions.d.ts

@@ -1,9 +1,7 @@
 /** OpenRouter provider adapter — OpenAI-compatible with extensions. */
-import type { SSEEvent } from '../../../network/types';
 import type { ProviderAdapter } from '../../types/provider';
-import type { CompletionResponse } from '../../types/response';
-import type { StreamEvent } from '../../types/stream';
 import { OpenAIAdapter } from '../openai/completions';
+import type { Registry } from '../../../wire/interpreter';
 export interface OpenRouterAdapterConfig {
     apiKey: string;
     baseURL?: string;
@@ -17,8 +15,14 @@ export declare class OpenRouterAdapter extends OpenAIAdapter {
      *  rename, the reasoning strip, the tier remap, the routing passthrough — is the
      *  `openrouter` overlay in the shared spec. Naming the flavor IS the override now. */
     protected readonly wireFlavor: string;
-    parseResponse(raw: unknown, latencyMs: number): CompletionResponse;
-    /** Stateful — emit a single `web_search` builtin-tool pair the first time
-     *  `url_citation` annotations appear in the stream (the `:online` search signal). */
-    createStreamParser(): (event: SSEEvent) => StreamEvent[];
+    /** The `:online` web-search rule that used to live in an override is the
+     *  `openrouter` delta of the shared response spec. Naming the spec IS the
+     *  override now, exactly as `wireFlavor` is for the request side. */
+    protected responseSpecId(): string;
+    protected responseRegistry(): Registry;
+    /** The `:online` web-search pair is the `openrouter` delta of the shared
+     *  stream spec, so naming the spec IS the override -- as it already is for the
+     *  request side and the buffered response. */
+    protected streamSpecId(): string;
+    protected streamRegistry(): Registry;
 }

package/dist/llm/providers/openrouter/response-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const OPENROUTER_RESPONSE_REGISTRY: Registry;

package/dist/llm/providers/openrouter/stream-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const OPENROUTER_STREAM_REGISTRY: Registry;

package/dist/llm/providers/response-registries.d.ts

@@ -0,0 +1,5 @@
+import type { Registry } from '../../wire/interpreter';
+export declare const RESPONSE_REGISTRIES: Record<string, Registry>;
+/** Every name any response registry supplies. For checks that only ask "does
+ *  this resolve anywhere", never for dispatch. */
+export declare function allResponseNames(): Set<string>;

package/dist/llm/providers/xai/completions.d.ts

@@ -4,11 +4,9 @@
  *  - Reasoning via model variant (grok-*-reasoning), not reasoning param
  *  - Returns reasoning_content in message (plain text, unlike OpenAI which hides it)
  */
-import type { SSEEvent } from '../../../network/types';
 import type { ProviderAdapter } from '../../types/provider';
 import type { CompletionResponse } from '../../types/response';
-import type { StreamEvent } from '../../types/stream';
-import { OpenAIAdapter, type OpenAIStreamState } from '../openai/completions';
+import { OpenAIAdapter } from '../openai/completions';
 export interface XAIAdapterConfig {
     apiKey: string;
     baseURL?: string;
@@ -22,5 +20,4 @@ export declare class XAIAdapter extends OpenAIAdapter {
      *  `xai` overlay in the shared spec. Naming the flavor IS the override now. */
     protected readonly wireFlavor: string;
     parseResponse(raw: unknown, latencyMs: number): CompletionResponse;
-    parseStreamEvent(event: SSEEvent, state?: OpenAIStreamState): StreamEvent[];
 }

package/dist/llm/providers/xai/responses-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const XAI_RESPONSES_REGISTRY: Registry;

package/dist/llm/providers/xai/responses.d.ts

@@ -8,11 +8,23 @@
 import type { ProviderAdapter } from '../../types/provider';
 import type { FileOutput } from '../../types/response';
 import { OpenAIResponsesAdapter } from '../openai/responses';
+import type { Registry } from '../../../wire/interpreter';
 export interface XAIResponsesAdapterConfig {
     apiKey: string;
     baseURL?: string;
 }
+/** xAI returns code-execution output files INLINE inside the `code_interpreter_call`
+ *  `logs` payload (a JSON string: `{stdout, output_files:[{file_name, mime_type, data:[…bytes]}]}`),
+ *  not as OpenAI-style `container_file_citation` annotations. Requires the request to
+ *  ask for them via `include: ['code_interpreter_call.outputs']`. */
+export declare function xaiCodeExecFiles(item: Record<string, unknown>): FileOutput[];
 export declare class XAIResponsesAdapter extends OpenAIResponsesAdapter {
+    /** Identical to OpenAI's by inheritance, but addressed by its own id so the
+     *  target has a spec of its own rather than a special case in the lookup. */
+    protected responseSpecId(): string;
+    protected responseRegistry(): Registry;
+    protected streamSpecId(): string;
+    protected streamRegistry(): Registry;
     readonly name: ProviderAdapter['name'];
     constructor(config: XAIResponsesAdapterConfig);
     baseURL(): string;

package/dist/llm/providers/xai/stream-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from '../../../wire/interpreter';
+export declare const XAI_STREAM_REGISTRY: Registry;

package/dist/plugins/context-guard/facts.d.ts

@@ -3,6 +3,15 @@
  *  in this shape; consumers (renderFactsLayer, snapshots) read them. */
 export declare const FACT_CATEGORIES: readonly ["name", "date", "time", "path", "url", "email", "phone", "address", "amount", "number", "identifier", "other"];
 export type FactCategory = (typeof FACT_CATEGORIES)[number];
+/** Narrow a parsed category to the union, falling back to `other`.
+ *
+ *  Categories are read back out of a system prompt or off a fact-extract tool's
+ *  JSON, so the string is model-influenced rather than ours. Casting it into
+ *  `FactCategory` would type a value the union does not contain, and every
+ *  consumer that switches on the category would then meet a branch it was
+ *  compiled believing could not happen. `other` is the union's catch-all and is
+ *  what an unrecognised category means. */
+export declare function toFactCategory(raw: string): FactCategory;
 export interface ExtractedFact {
     /** Short descriptive label. Lowercase, snake_or_dotted notation. */
     key: string;

package/dist/plugins/context-guard/tools.d.ts

@@ -30,6 +30,9 @@ export declare class StrategyToolsImpl implements StrategyTools {
         middle: HistoryEntry[];
         old: HistoryEntry[];
     };
+    /** What the request weighs right now, including any compaction already
+     *  applied in this call. */
+    measureCurrent(): number;
     measure(items: readonly HistoryEntry[] | Message[]): number;
     extractFacts(entries: readonly HistoryEntry[], categories?: string[]): Promise<ExtractedFact[]>;
     summarize(entries: readonly HistoryEntry[], maxLength: number, focus?: string): Promise<string>;

package/dist/plugins/context-guard/types.d.ts

@@ -82,6 +82,11 @@ export interface StrategyTools {
         old: HistoryEntry[];
     };
     measure(items: readonly HistoryEntry[] | Message[]): number;
+    /** Tokens in the request AS IT STANDS, after whatever this strategy has
+     *  already done to it. `ReactContext.current` is the count that TRIGGERED
+     *  the compaction and no mutation updates it, so it is the wrong number to
+     *  judge the compaction by. */
+    measureCurrent(): number;
     extractFacts(entries: readonly HistoryEntry[], categories?: string[]): Promise<ExtractedFact[]>;
     summarize(entries: readonly HistoryEntry[], maxLength: number, focus?: string): Promise<string>;
     replaceRange(from: number, to: number, replacement: Message): void;

package/dist/util/audio-mime.d.ts

@@ -0,0 +1,16 @@
+/** Detect an audio clip's MIME type from its leading magic bytes.
+ *
+ *  Same problem as `sniffImageMime`, from the opposite direction. OpenAI's chat
+ *  completions return `message.audio` as `{ id, data, expires_at, transcript }`
+ *  and NO `format` field, so the adapter's `audio/${format ?? 'wav'}` fell through
+ *  to the default every single time: request mp3, receive mp3 bytes (`ID3...`),
+ *  and get told it is `audio/wav`. Anything that trusts the label — an <audio>
+ *  element, a file written to disk, a follow-up upload with a strict validator —
+ *  is then working from a lie.
+ *
+ *  The bytes are the only honest source here, and the caller's requested format is
+ *  not available at parse time.
+ *
+ *  Returns the CONTAINER, which is what a player needs: Opus arrives inside Ogg
+ *  and is reported as `audio/ogg`. */
+export declare function sniffAudioMime(b: Uint8Array): string | undefined;

package/dist/util/compare.d.ts

@@ -0,0 +1,13 @@
+/** Ordering that does not depend on where the process is running.
+ *
+ *  `String.prototype.localeCompare` with no locale argument reads the HOST's
+ *  default locale, so the same inputs sort differently on different machines:
+ *  under `sv-SE` or `tr-TR`, `ünique` sorts after `user-name` rather than next
+ *  to `unique`. That is fine for a list shown to a person and wrong for
+ *  anything whose order becomes bytes — a rendered system prompt changes
+ *  content with the host's locale, which breaks reproducibility and misses the
+ *  provider's prompt cache on a prefix that should have been identical.
+ *
+ *  Codepoint order is not "nicer" than collation. It is the same everywhere,
+ *  which is the only property these call sites actually need. */
+export declare function byCodepoint(a: string, b: string): number;

package/dist/wire/interpreter.d.ts

@@ -270,6 +270,8 @@ export interface Registry {
 }
 export declare function getPath(root: any, path: string): any;
 export declare function evalCond(cond: Cond | undefined, ctx: Ctx, reg: Registry): boolean;
+export declare const OMIT: unique symbol;
+export declare function evalTemplate(tpl: Json, ctx: Ctx, reg: Registry): Json | typeof OMIT;
 export declare function resolveVariants(spec: WireSpec, model: string, reg: Registry): Set<string>;
 export interface BuiltRequest {
     body: Record<string, unknown>;