@arnilo/prism 0.0.15 → 0.0.17

package/dist/node/agent-definitions.js

@@ -1,13 +1,12 @@
+import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
-import { readFile } from "node:fs/promises";
-import { readdir, stat } from "node:fs/promises";
-import { parseSkillFile, splitFrontmatter } from "../contribution-parsing.js";
 import { resolveAgentDefinition } from "../agent-definitions.js";
+import { parseSkillFile, splitFrontmatter } from "../contribution-parsing.js";
 import { assertPermission, isTrusted } from "../security.js";
-import { isPathInsideReal } from "./trust.js";
-import { readOptionalFile } from "./contribution-discovery.js";
 import { createSkillRegistry } from "../skills.js";
 import { isNodeErrorCode } from "./config.js";
+import { readOptionalFile } from "./contribution-discovery.js";
+import { isPathInsideReal } from "./trust.js";
 const defaultInclude = {
     systemPrompt: true,
     agentPrompt: true,
@@ -288,7 +287,13 @@ function resolveSkillContexts(skills, contextProviders) {
 function collectMetadata(front) {
     const metadata = {};
     for (const [key, value] of front) {
-        if (key !== "name" && key !== "description" && key !== "model" && key !== "tools" && key !== "skills" && key !== "context" && key !== "instructions") {
+        if (key !== "name" &&
+            key !== "description" &&
+            key !== "model" &&
+            key !== "tools" &&
+            key !== "skills" &&
+            key !== "context" &&
+            key !== "instructions") {
             metadata[key] = value;
         }
     }
@@ -305,7 +310,10 @@ function getStringList(front, key) {
     if (Array.isArray(value))
         return value.map(String);
     if (typeof value === "string")
-        return value.split(",").map((s) => s.trim()).filter(Boolean);
+        return value
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
     return undefined;
 }
 function bodyAsInstructions(text, path) {
@@ -348,7 +356,7 @@ async function readOptional(read, path) {
 const NAME_RE = /^[A-Za-z0-9 _-]+$/;
 function parentDirName(path) {
     const parts = path.split(/[/\\]+/).filter(Boolean);
-    return parts.length >= 2 ? parts[parts.length - 2] : parts[parts.length - 1] ?? "";
+    return parts.length >= 2 ? parts[parts.length - 2] : (parts[parts.length - 1] ?? "");
 }
 /** Parse a `CONTEXT.md` into a static {@link ContextProvider}. The markdown
  *  body becomes the context block content; frontmatter `name` overrides the

package/dist/node/contribution-discovery.d.ts

@@ -1,6 +1,5 @@
 import type { ContributionFileKind, DiscoveredContribution } from "../contracts.js";
-import type { PermissionPolicy } from "../security.js";
-import type { TrustPolicy } from "../security.js";
+import type { PermissionPolicy, TrustPolicy } from "../security.js";
 export interface DiscoveryOptions {
     readonly kinds: readonly ContributionFileKind[];
     /** Workspace root. Scans `<root>/.agents/<kind>s/<name>/`. Gated by `trust`. */

package/dist/node/contribution-discovery.js

@@ -1,10 +1,10 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { isJsonObject } from "../config.js";
-import { assertPermission } from "../security.js";
-import { isPathInsideReal } from "./trust.js";
 import { parseSkillFile } from "../contribution-parsing.js";
+import { assertPermission } from "../security.js";
 import { isNodeErrorCode } from "./config.js";
+import { isPathInsideReal } from "./trust.js";
 /**
  * Discover contributions on disk. Scans the workspace `.agents/` tree only;
  * no global root. One `readdir` per kind-root; no `import()`. Inert output —
@@ -72,7 +72,7 @@ async function readEntry(dir, fallbackName, kind, origin) {
             return readManifestEntry(dir, fallbackName, kind, origin);
     }
 }
-async function readSkillEntry(dir, fallbackName, origin) {
+async function readSkillEntry(dir, _fallbackName, origin) {
     const path = join(dir, "SKILL.md");
     if (!(await isPathInsideReal(dir, path)))
         return undefined;

package/dist/node/session-store-jsonl.js

@@ -1,6 +1,6 @@
-import { mkdir, readFile, appendFile } from "node:fs/promises";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { SESSION_APPEND_CONFLICT_CODE, SessionAppendConflictError, SessionSearchUnsupportedError, isSessionEntryKind, SESSION_ENTRY_SCHEMA_VERSION, } from "../contracts.js";
+import { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, SessionSearchUnsupportedError, } from "../contracts.js";
 import { isNodeErrorCode } from "./config.js";
 export function createJsonlSessionStore(pathOrOptions) {
     const options = typeof pathOrOptions === "string" ? { path: pathOrOptions, createDirectory: true } : pathOrOptions;
@@ -93,7 +93,10 @@ function parseEntry(line, lineNumber) {
 }
 function validateSessionEntry(value, lineNumber, raw) {
     if (!isBasicSessionEntry(value)) {
-        return { ok: false, error: { line: lineNumber, message: "Invalid session entry: expected object with id, sessionId, timestamp, and kind", raw } };
+        return {
+            ok: false,
+            error: { line: lineNumber, message: "Invalid session entry: expected object with id, sessionId, timestamp, and kind", raw },
+        };
     }
     const entry = value;
     if (entry.parentId !== undefined && typeof entry.parentId !== "string") {
@@ -149,10 +152,10 @@ function isBasicSessionEntry(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
     const entry = value;
-    return typeof entry.id === "string"
-        && typeof entry.sessionId === "string"
-        && typeof entry.timestamp === "string"
-        && typeof entry.kind === "string";
+    return (typeof entry.id === "string" &&
+        typeof entry.sessionId === "string" &&
+        typeof entry.timestamp === "string" &&
+        typeof entry.kind === "string");
 }
 function isMessage(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))

package/dist/node/settings.d.ts

@@ -1,6 +1,6 @@
 import { type ConfigLayer } from "../config.js";
-import { type NodeConfigFile } from "./config.js";
 import type { SettingsProvider } from "../contracts.js";
+import { type NodeConfigFile } from "./config.js";
 export type NodeSettingsFile = NodeConfigFile;
 export declare function defaultUserSettingsPath(appName?: string): string;
 export declare function readSettingsFile(path: string): Promise<ConfigLayer["config"]>;

package/dist/node/settings.js

@@ -1,8 +1,8 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { mergeConfigLayers } from "../config.js";
-import { readConfigFile, isNodeErrorCode } from "./config.js";
 import { createStaticSettingsProvider } from "../settings.js";
+import { isNodeErrorCode, readConfigFile } from "./config.js";
 export function defaultUserSettingsPath(appName = "prism") {
     return join(homedir(), ".config", appName, "settings.json");
 }

package/dist/node/system-project-prompts.js

@@ -14,10 +14,8 @@ import { readOptionalFile } from "./contribution-discovery.js";
  *  singletons don't fit `discoverContributions`' named-subdir scanner, so this is a
  *  sibling loader mirroring `src/node/instruction-injectors.ts`'s per-concern adapter shape. */
 export async function loadSystemPromptFiles(options) {
-    const agentsPath = options.agentsMdPath
-        ?? (options.workspaceRoot !== undefined ? join(options.workspaceRoot, "AGENTS.md") : undefined);
-    const systemPath = options.systemMdPath
-        ?? (options.globalRoot !== undefined ? join(options.globalRoot, ".prism", "agent", "SYSTEM.md") : undefined);
+    const agentsPath = options.agentsMdPath ?? (options.workspaceRoot !== undefined ? join(options.workspaceRoot, "AGENTS.md") : undefined);
+    const systemPath = options.systemMdPath ?? (options.globalRoot !== undefined ? join(options.globalRoot, ".prism", "agent", "SYSTEM.md") : undefined);
     const out = [];
     if (systemPath !== undefined) {
         const layer = await readSystemFile(systemPath, options.permission);

package/dist/node/trust.js

@@ -1,5 +1,5 @@
-import { isAbsolute, relative, resolve, dirname, basename, join } from "node:path";
 import { realpath } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { isNodeErrorCode } from "./config.js";
 export function isPathInside(root, target) {
     const from = resolve(root);

package/dist/persistence-lifecycle.js

@@ -64,9 +64,7 @@ export function createMemoryPersistenceLifecycle() {
         async applyRetention(input) {
             throwIfAborted(input.signal);
             assertOwnership(input);
-            const held = new Set([...holds.values()]
-                .filter((hold) => sameOwnership(input, hold) && hold.resourceKind === "session")
-                .map((hold) => hold.resourceId));
+            const held = new Set([...holds.values()].filter((hold) => sameOwnership(input, hold) && hold.resourceKind === "session").map((hold) => hold.resourceId));
             const candidates = input.candidates ?? [];
             const deletedIds = [];
             const skippedHeld = [];

package/dist/provider-events.js

@@ -35,7 +35,9 @@ export function reconstructToolCallDeltas(events) {
             partial.argumentsText += event.argumentsText;
         partials.set(event.index, partial);
     }
-    return [...partials.entries()].sort(([a], [b]) => a - b).map(([index, partial]) => {
+    return [...partials.entries()]
+        .sort(([a], [b]) => a - b)
+        .map(([index, partial]) => {
         if (!partial.id || !partial.name) {
             throw new ProviderTransportError("incomplete_delta", `Incomplete tool call delta at index ${index}`);
         }

package/dist/provider-request-policy.js

@@ -50,10 +50,9 @@ export function mergeProviderRequestOptions(base, patch) {
         cache: {
             ...base.cache,
             ...patch.cache,
-            breakpoints: base.cache?.breakpoints || patch.cache?.breakpoints ? [
-                ...(base.cache?.breakpoints ?? []),
-                ...(patch.cache?.breakpoints ?? []),
-            ] : undefined,
+            breakpoints: base.cache?.breakpoints || patch.cache?.breakpoints
+                ? [...(base.cache?.breakpoints ?? []), ...(patch.cache?.breakpoints ?? [])]
+                : undefined,
         },
     };
 }

package/dist/providers/media.d.ts

@@ -1,5 +1,5 @@
+import { type MediaContentBlock, type ModelInputCapability, type ResolvedMediaContent, type ResolveMediaContentOptions } from "../content.js";
 import type { AudioContent, ContentBlock, DocumentContent, FileContent, JsonObject, Message, ModelCapabilities, ModelConfig } from "../contracts.js";
-import { type MediaContentBlock, type ModelInputCapability, type ResolveMediaContentOptions, type ResolvedMediaContent } from "../content.js";
 /** Default upload-cache entry cap per provider media session. */
 export declare const DEFAULT_PROVIDER_UPLOAD_CACHE_ENTRIES = 32;
 /** Inline OpenAI file_data ceiling before preferring Files API upload. */

package/dist/providers/openai-compatible.d.ts

@@ -1,4 +1,4 @@
-import type { AIProvider, ProviderRequest } from "../contracts.js";
+import type { AIProvider, JsonObject, Message, ProviderEvent, ProviderRequest, Usage } from "../contracts.js";
 import { type CredentialValueSource } from "../credentials.js";
 export interface OpenAICompatibleProviderOptions {
     readonly id?: string;
@@ -9,5 +9,46 @@ export interface OpenAICompatibleProviderOptions {
     readonly chatCompletionsUrl?: string | ((request: ProviderRequest) => string);
     /** Default `bearer`. Azure resource keys use `api-key`; host-signed fetches may use `none`. */
     readonly authStyle?: "bearer" | "api-key" | "none";
+    /** Extra provider-specific body fields (thinking/reasoning/cache); merged over the base body. */
+    readonly buildBodyExtra?: (request: ProviderRequest) => JsonObject | undefined;
+    /** Transform messages before serialization (e.g. cache-control markers). Defaults to `request.messages`. */
+    readonly mapMessages?: (request: ProviderRequest) => readonly Message[];
+    /** Custom message serializer (e.g. Z.AI `reasoning_content` replay). Defaults to assert + `serializeOpenAIChatMessage`. */
+    readonly serializeMessage?: (message: Message, request: ProviderRequest) => JsonObject;
+    /** Custom usage mapping (e.g. OpenRouter cost fields). Defaults to `mapOpenAIChatUsage`. */
+    readonly mapUsage?: (usage: unknown) => Usage | undefined;
+    /** Extra request headers (merged over caller headers; provider auth/content-type still win). */
+    readonly extraHeaders?: (request: ProviderRequest) => Record<string, string>;
+    /** Final body transform applied last (token limits, compat stripping). Wins over everything. */
+    readonly transformBody?: (body: JsonObject, request: ProviderRequest) => JsonObject;
+    /** Require `[DONE]` and a `finish_reason` before emitting `done`; truncated streams yield an error. `done` then carries the final usage. */
+    readonly strictCompletion?: boolean;
+    /** Emit the final stream usage on the `done` event (without strict completion checks). */
+    readonly doneUsage?: boolean;
+    /** Prefix for HTTP error messages (default `OpenAI-compatible request failed`). */
+    readonly requestFailedPrefix?: string;
+    /** Custom HTTP error mapping (e.g. NeuralWatt retry classification). Receives the response and redacted body text. */
+    readonly mapHttpError?: (response: Response, bodyText: string, secrets: readonly (string | undefined)[]) => Error;
+    /** Handle SSE comment lines in the stream (e.g. NeuralWatt energy/cost telemetry). */
+    readonly onComment?: (text: string) => ProviderEvent | undefined;
 }
+export interface OpenAIChatEventsOptions {
+    readonly signal?: AbortSignal;
+    /** Require `[DONE]` and a `finish_reason`; `done` then carries the final usage. */
+    readonly strictCompletion?: boolean;
+    /** Emit the final stream usage on the `done` event. */
+    readonly doneUsage?: boolean;
+    readonly mapUsage?: (usage: unknown) => Usage | undefined;
+    /** Handle an SSE comment line (text after `:`), e.g. NeuralWatt `: energy` / `: cost` telemetry. Returned events are yielded in stream order before the data of the same SSE event. */
+    readonly onComment?: (text: string) => ProviderEvent | undefined;
+}
+/**
+ * Shared OpenAI Chat Completions SSE stream loop: maps `data:` frames to Prism
+ * `ProviderEvent` values (text/thinking deltas, tool-call fragments, usage, done/error).
+ */
+export declare function openAIChatEvents(body: ReadableStream<Uint8Array>, options?: OpenAIChatEventsOptions): AsyncIterable<ProviderEvent>;
 export declare function createOpenAICompatibleProvider(options: OpenAICompatibleProviderOptions): AIProvider;
+/** Subset of factory options that shape the request body. */
+export type OpenAIChatBodyOptions = Pick<OpenAICompatibleProviderOptions, "mapMessages" | "serializeMessage" | "buildBodyExtra" | "transformBody">;
+/** Base Chat Completions request body builder, exported for provider packages keeping public body helpers. */
+export declare function buildOpenAIChatBody(request: ProviderRequest, options?: OpenAIChatBodyOptions): JsonObject;

package/dist/providers/openai-compatible.js

@@ -1,28 +1,110 @@
 import { resolveCredentialValue } from "../credentials.js";
 import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallFromArgumentsText, } from "../provider-events.js";
-import { assertOpenAIChatMessage, applyOpenAIChatStructuredOutput, mapOpenAIChatUsage, serializeOpenAIChatMessage, serializeOpenAITool, } from "./openai-primitives.js";
-import { ProviderTransportError, readBoundedResponseText, readSseData, } from "./transport.js";
 import { assertStructuredOutputRequestSupported } from "../structured-output.js";
+import { applyOpenAIChatStructuredOutput, assertOpenAIChatMessage, mapOpenAIChatUsage, serializeOpenAIChatMessage, serializeOpenAITool, } from "./openai-primitives.js";
+import { httpStatusError, ProviderTransportError, readBoundedResponseText, readSseEvents } from "./transport.js";
+/**
+ * Shared OpenAI Chat Completions SSE stream loop: maps `data:` frames to Prism
+ * `ProviderEvent` values (text/thinking deltas, tool-call fragments, usage, done/error).
+ */
+export async function* openAIChatEvents(body, options = {}) {
+    const tools = new Map();
+    let usage;
+    let sawDoneMarker = false;
+    let sawFinishReason = false;
+    for await (const sseEvent of readSseEvents(body, { signal: options.signal })) {
+        if (options.onComment && sseEvent.comments?.length) {
+            for (const text of sseEvent.comments) {
+                const commentEvent = options.onComment(text);
+                if (commentEvent)
+                    yield commentEvent;
+            }
+        }
+        const data = sseEvent.data.trim();
+        if (!data)
+            continue;
+        if (data === "[DONE]") {
+            sawDoneMarker = true;
+            break;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(data);
+        }
+        catch (error) {
+            // Malformed chunks are terminal: yield the error instead of crashing the generator.
+            yield providerError(error, []);
+            return;
+        }
+        const mapped = (options.mapUsage ?? mapOpenAIChatUsage)(parsed.usage);
+        if (mapped) {
+            usage = mapped;
+            yield providerUsage(mapped);
+        }
+        for (const choice of parsed.choices ?? []) {
+            if (choice.finish_reason)
+                sawFinishReason = true;
+            const delta = choice.delta ?? {};
+            if (typeof delta.content === "string" && delta.content)
+                yield providerTextDelta(delta.content);
+            const thinking = delta.reasoning ?? delta.reasoning_content;
+            if (typeof thinking === "string" && thinking) {
+                yield providerThinkingDelta(thinking);
+            }
+            for (const tool of delta.tool_calls ?? []) {
+                const index = tool.index ?? 0;
+                const current = tools.get(index) ?? { argumentsText: "" };
+                current.id = tool.id ?? current.id;
+                current.name = tool.function?.name ?? current.name;
+                current.argumentsText += tool.function?.arguments ?? "";
+                tools.set(index, current);
+                yield providerToolCallDelta({
+                    index,
+                    id: tool.id,
+                    name: tool.function?.name,
+                    argumentsText: tool.function?.arguments,
+                });
+            }
+        }
+    }
+    const incomplete = [...tools.entries()].find(([, call]) => !call.id || !call.name);
+    if (incomplete) {
+        yield providerError(new ProviderTransportError("incomplete_delta", `Incomplete tool call delta at index ${incomplete[0]}`));
+        return;
+    }
+    if (options.strictCompletion && (!sawDoneMarker || !sawFinishReason)) {
+        // Truncated streams must fail loudly — emitting done would mark partial output as succeeded.
+        yield providerError(new Error(`Chat stream ended without completion evidence ` +
+            `([DONE]: ${sawDoneMarker ? "received" : "missing"}, ` +
+            `finish_reason: ${sawFinishReason ? "received" : "missing"})`));
+        return;
+    }
+    for (const call of tools.values()) {
+        yield providerToolCall(toolCallFromArgumentsText(call.id, call.name, call.argumentsText));
+    }
+    yield providerDone(options.strictCompletion || options.doneUsage ? usage : undefined);
+}
 export function createOpenAICompatibleProvider(options) {
     const providerId = options.id ?? "openai-compatible";
     return {
         id: providerId,
         async *generate(request) {
+            if (request.signal?.aborted)
+                throw request.signal.reason ?? new Error("aborted");
             const apiKey = await resolveCredentialValue(options.apiKey, {
                 name: "apiKey",
                 provider: providerId,
             });
             const fetchImpl = options.fetch ?? fetch;
             const secrets = [apiKey];
-            const tools = new Map();
             try {
                 const url = typeof options.chatCompletionsUrl === "function"
                     ? options.chatCompletionsUrl(request)
-                    : options.chatCompletionsUrl
-                        ?? `${options.baseUrl.replace(/\/$/, "")}/chat/completions`;
+                    : (options.chatCompletionsUrl ?? `${options.baseUrl.replace(/\/+$/, "")}/chat/completions`);
                 const authStyle = options.authStyle ?? "bearer";
                 const headers = {
                     ...Object.fromEntries(Object.entries(request.options?.headers ?? {}).filter((entry) => typeof entry[1] === "string")),
+                    ...options.extraHeaders?.(request),
                     "content-type": "application/json",
                 };
                 if (apiKey && authStyle === "api-key")
@@ -32,56 +114,28 @@ export function createOpenAICompatibleProvider(options) {
                 const response = await fetchImpl(url, {
                     method: "POST",
                     headers,
-                    body: JSON.stringify(toOpenAIRequest(request)),
+                    body: JSON.stringify(toOpenAIRequest(request, options)),
                     signal: request.signal,
                 });
                 if (!response.ok) {
-                    yield providerError(new Error(`OpenAI-compatible request failed: ${response.status} ${await readBoundedResponseText(response, { secrets })}`), secrets);
+                    const bodyText = await readBoundedResponseText(response, { secrets });
+                    const error = options.mapHttpError
+                        ? options.mapHttpError(response, bodyText, secrets)
+                        : httpStatusError(options.requestFailedPrefix ?? "OpenAI-compatible request failed", response, bodyText);
+                    yield providerError(error, secrets);
                     return;
                 }
                 if (!response.body) {
                     yield providerError(new Error("OpenAI-compatible response had no body"), secrets);
                     return;
                 }
-                for await (const data of readSseData(response.body, { signal: request.signal })) {
-                    if (data === "[DONE]")
-                        break;
-                    const parsed = JSON.parse(data);
-                    const usage = mapOpenAIChatUsage(parsed.usage);
-                    if (usage)
-                        yield providerUsage(usage);
-                    for (const choice of parsed.choices ?? []) {
-                        const delta = choice.delta ?? {};
-                        if (typeof delta.content === "string" && delta.content)
-                            yield providerTextDelta(delta.content);
-                        if (typeof delta.reasoning_content === "string" && delta.reasoning_content) {
-                            yield providerThinkingDelta(delta.reasoning_content);
-                        }
-                        for (const tool of delta.tool_calls ?? []) {
-                            const index = tool.index ?? 0;
-                            const current = tools.get(index) ?? { argumentsText: "" };
-                            current.id = tool.id ?? current.id;
-                            current.name = tool.function?.name ?? current.name;
-                            current.argumentsText += tool.function?.arguments ?? "";
-                            tools.set(index, current);
-                            yield providerToolCallDelta({
-                                index,
-                                id: tool.id,
-                                name: tool.function?.name,
-                                argumentsText: tool.function?.arguments,
-                            });
-                        }
-                    }
-                }
-                const incomplete = [...tools.entries()].find(([, call]) => !call.id || !call.name);
-                if (incomplete) {
-                    yield providerError(new ProviderTransportError("incomplete_delta", `Incomplete tool call delta at index ${incomplete[0]}`), secrets);
-                    return;
-                }
-                for (const call of tools.values()) {
-                    yield providerToolCall(toolCallFromArgumentsText(call.id, call.name, call.argumentsText));
-                }
-                yield providerDone();
+                yield* openAIChatEvents(response.body, {
+                    signal: request.signal,
+                    strictCompletion: options.strictCompletion,
+                    doneUsage: options.doneUsage,
+                    mapUsage: options.mapUsage,
+                    onComment: options.onComment,
+                });
             }
             catch (error) {
                 yield providerError(error, secrets);
@@ -89,11 +143,13 @@ export function createOpenAICompatibleProvider(options) {
         },
     };
 }
-function toOpenAIRequest(request) {
+function toOpenAIRequest(request, options) {
     assertStructuredOutputRequestSupported(request.model, request.options);
     const body = {
         model: request.model.model,
-        messages: request.messages.map((message, index) => {
+        messages: (options.mapMessages?.(request) ?? request.messages).map((message, index) => {
+            if (options.serializeMessage)
+                return options.serializeMessage(message, request);
             assertOpenAIChatMessage(message, `messages[${index}]`);
             return serializeOpenAIChatMessage(message, request.model.capabilities ?? {});
         }),
@@ -103,6 +159,11 @@ function toOpenAIRequest(request) {
         ...request.model.parameters,
     };
     applyOpenAIChatStructuredOutput(body, request.options?.structuredOutput);
-    return body;
+    const merged = { ...body, ...options.buildBodyExtra?.(request) };
+    return options.transformBody ? options.transformBody(merged, request) : merged;
+}
+/** Base Chat Completions request body builder, exported for provider packages keeping public body helpers. */
+export function buildOpenAIChatBody(request, options = {}) {
+    return toOpenAIRequest(request, options);
 }
 //# sourceMappingURL=openai-compatible.js.map

package/dist/providers/openai-primitives.js

@@ -110,13 +110,13 @@ export function mapOpenAIChatUsage(usage) {
     if (!usage || typeof usage !== "object" || Array.isArray(usage))
         return undefined;
     const wire = usage;
-    if (wire.prompt_tokens === undefined
-        && wire.completion_tokens === undefined
-        && wire.total_tokens === undefined
-        && wire.prompt_cache_hit_tokens === undefined
-        && wire.prompt_tokens_details?.cached_tokens === undefined
-        && wire.prompt_tokens_details?.cache_write_tokens === undefined
-        && wire.prompt_tokens_details?.cache_creation_input_tokens === undefined) {
+    if (wire.prompt_tokens === undefined &&
+        wire.completion_tokens === undefined &&
+        wire.total_tokens === undefined &&
+        wire.prompt_cache_hit_tokens === undefined &&
+        wire.prompt_tokens_details?.cached_tokens === undefined &&
+        wire.prompt_tokens_details?.cache_write_tokens === undefined &&
+        wire.prompt_tokens_details?.cache_creation_input_tokens === undefined) {
         return undefined;
     }
     return {

package/dist/providers/transport.d.ts

@@ -20,6 +20,12 @@ export declare class ProviderTransportError extends Error {
     readonly limitBytes?: number;
     constructor(code: ProviderTransportErrorCode, message: string, limitBytes?: number);
 }
+/** HTTP failure error carrying the status as numeric `code` plus any `Retry-After`
+ *  hint as `retryAfterMs`, so retry policies classify transience and pace retries
+ *  without parsing message text. Both fields flow into `ErrorInfo` via errorToErrorInfo. */
+export declare function httpStatusError(prefix: string, response: Response, bodyText: string): Error;
+/** Parse a `Retry-After` header (delay-seconds or HTTP-date) into milliseconds. */
+export declare function parseRetryAfterMs(value: string | null, now?: number): number | undefined;
 export interface ReadSseEventsOptions extends BoundedStreamLimits {
     readonly signal?: AbortSignal;
 }

package/dist/providers/transport.js

@@ -13,6 +13,27 @@ export class ProviderTransportError extends Error {
         this.limitBytes = limitBytes;
     }
 }
+/** HTTP failure error carrying the status as numeric `code` plus any `Retry-After`
+ *  hint as `retryAfterMs`, so retry policies classify transience and pace retries
+ *  without parsing message text. Both fields flow into `ErrorInfo` via errorToErrorInfo. */
+export function httpStatusError(prefix, response, bodyText) {
+    const error = new Error(`${prefix}: ${response.status} ${bodyText}`);
+    error.code = response.status;
+    const hint = parseRetryAfterMs(response.headers.get("retry-after"));
+    if (hint !== undefined)
+        error.retryAfterMs = hint;
+    return error;
+}
+/** Parse a `Retry-After` header (delay-seconds or HTTP-date) into milliseconds. */
+export function parseRetryAfterMs(value, now = Date.now()) {
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds * 1000;
+    const date = Date.parse(value);
+    return Number.isNaN(date) ? undefined : Math.max(0, date - now);
+}
 function resolveLimits(options) {
     return {
         maxEventBytes: options?.maxEventBytes ?? DEFAULT_MAX_EVENT_BYTES,

package/dist/providers.d.ts

@@ -2,6 +2,8 @@ import type { AIProvider, ModelConfig, ProviderResolver } from "./contracts.js";
 import { type DuplicateRegistrationOptions } from "./registry-options.js";
 export interface ProviderRegistry {
     register(provider: AIProvider): void;
+    /** Remove a provider; returns false when the id was not registered. */
+    unregister(id: string): boolean;
     get(id: string): AIProvider | undefined;
     resolve(model: Pick<ModelConfig, "provider"> | string): AIProvider;
     list(): readonly AIProvider[];

package/dist/providers.js

@@ -6,6 +6,9 @@ export function createProviderRegistry(providers = [], options = {}) {
             assertCanRegister(byId, provider.id, "provider", provider.id, options.duplicate);
             byId.set(provider.id, provider);
         },
+        unregister(id) {
+            return byId.delete(id);
+        },
         get(id) {
             return byId.get(id);
         },

package/dist/redaction.d.ts

@@ -8,5 +8,6 @@ export declare function redactAgentEvent(event: AgentEvent, redactor?: SecretRed
 export declare function redactSessionEntry(entry: SessionEntry, redactor?: SecretRedactor): SessionEntry;
 export declare function redactProviderRequest(request: ProviderRequest, redactor?: SecretRedactor): ProviderRequest;
 export declare function redactRunLedgerRecord<T extends RunLedgerRecord>(record: T, redactor?: SecretRedactor): T;
+export declare function resolveRedactor(redactor?: SecretRedactor, secrets?: readonly (string | undefined)[]): SecretRedactor | undefined;
 export declare function redactSecrets<T>(value: T, secrets: readonly (string | undefined)[]): T;
 export declare function errorToErrorInfo(error: unknown, secrets?: readonly (string | undefined)[]): ErrorInfo;