@arnilo/prism 0.0.3 → 0.0.5

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

@@ -1,6 +1,7 @@
 import { mkdir, readFile, appendFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { SESSION_APPEND_CONFLICT_CODE, SessionAppendConflictError, isSessionEntryKind, SESSION_ENTRY_SCHEMA_VERSION } from "../contracts.js";
+import { isNodeErrorCode } from "./config.js";
 export function createJsonlSessionStore(pathOrOptions) {
     const options = typeof pathOrOptions === "string" ? { path: pathOrOptions, createDirectory: true } : pathOrOptions;
     const path = options.path;
@@ -16,7 +17,12 @@ export function createJsonlSessionStore(pathOrOptions) {
             appendChain = appendChain.then(async () => {
                 if (options.createDirectory !== false)
                     await mkdir(dirname(path), { recursive: true });
-                const entries = await readEntries(path);
+                const readResult = await readJsonlSessionEntries(path);
+                if (readResult.errors.length > 0) {
+                    const first = readResult.errors[0];
+                    throw new Error(`Invalid JSONL at line ${first.line}: ${first.message}`);
+                }
+                const entries = readResult.entries;
                 const dedupKey = appendOptions?.idempotencyKey
                     ? `${entry.sessionId}\u0000${appendOptions.idempotencyKey}\u0000${appendOptions.expectedParentId ?? ""}`
                     : undefined;
@@ -49,7 +55,7 @@ export async function readJsonlSessionEntries(path) {
         text = await readFile(path, "utf8");
     }
     catch (error) {
-        if (isMissingFile(error))
+        if (isNodeErrorCode(error, "ENOENT"))
             return { entries: [], errors: [] };
         throw new Error(`Failed to read session store ${path}: ${errorMessage(error)}`);
     }
@@ -163,9 +169,6 @@ function isAgentEvent(value) {
 function isPlainObject(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
-function isMissingFile(error) {
-    return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/node/settings.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { mergeConfigLayers } from "../config.js";
-import { readConfigFile } from "./config.js";
+import { readConfigFile, isNodeErrorCode } from "./config.js";
 import { createStaticSettingsProvider } from "../settings.js";
 export function defaultUserSettingsPath(appName = "prism") {
     return join(homedir(), ".config", appName, "settings.json");
@@ -16,7 +16,7 @@ export async function loadSettingsFiles(files) {
             layers.push({ name: file.name, config: await readSettingsFile(file.path) });
         }
         catch (error) {
-            if (file.optional && error instanceof Error && error.message.includes("ENOENT"))
+            if (file.optional && isNodeErrorCode(error, "ENOENT"))
                 continue;
             throw error;
         }

package/dist/node/trust.js

@@ -1,5 +1,6 @@
 import { isAbsolute, relative, resolve, dirname, basename, join } from "node:path";
 import { realpath } from "node:fs/promises";
+import { isNodeErrorCode } from "./config.js";
 export function isPathInside(root, target) {
     const from = resolve(root);
     const to = resolve(target);
@@ -25,7 +26,7 @@ export async function isPathInsideReal(root, target) {
         to = await realpath(target);
     }
     catch (error) {
-        if (!isMissingFile(error))
+        if (!isNodeErrorCode(error, "ENOENT"))
             return false;
         const parent = dirname(target);
         try {
@@ -50,7 +51,4 @@ export function createPathTrustPolicy(options) {
         },
     };
 }
-function isMissingFile(error) {
-    return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
 //# sourceMappingURL=trust.js.map

package/dist/observability.d.ts

@@ -0,0 +1,3 @@
+import type { ErrorInfo, ProviderRequest, ProviderTurnMetadata } from "./contracts.js";
+export declare function createProviderTurnMetadata(request: ProviderRequest, providerId: string, fields?: Omit<ProviderTurnMetadata, "providerId" | "model">): ProviderTurnMetadata;
+export declare function readProviderHttpStatus(error?: ErrorInfo): number | undefined;

package/dist/observability.js

@@ -0,0 +1,18 @@
+export function createProviderTurnMetadata(request, providerId, fields = {}) {
+    return {
+        providerId,
+        model: request.model,
+        requestId: readRequestId(request),
+        ...fields,
+    };
+}
+export function readProviderHttpStatus(error) {
+    return typeof error?.code === "number" ? error.code : undefined;
+}
+function readRequestId(request) {
+    const fromMetadata = request.metadata?.requestId;
+    if (typeof fromMetadata === "string" && fromMetadata.length > 0)
+        return fromMetadata;
+    return request.options?.sessionId;
+}
+//# sourceMappingURL=observability.js.map

package/dist/providers/media.d.ts

@@ -0,0 +1,44 @@
+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. */
+export declare const DEFAULT_OPENAI_INLINE_FILE_BYTES: number;
+export interface ProviderMediaScope {
+    readonly sessionId?: string;
+    readonly runId?: string;
+    readonly tenantId?: string;
+}
+export interface BoundedUploadCache<T> {
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    keys(): readonly string[];
+    clear(): void;
+}
+export declare function assertProviderMediaCapability(modality: ModelInputCapability, capabilities: ModelCapabilities, model: ModelConfig): void;
+export declare function rejectProviderMediaBlock(part: ContentBlock, capabilities: ModelCapabilities, model: ModelConfig): never;
+export declare function createBoundedUploadCache<T>(maxEntries?: number): BoundedUploadCache<T>;
+export declare function providerUploadCacheKey(scope: ProviderMediaScope, fingerprint: string): string;
+export declare function mediaFingerprint(mediaType: string, bytes: Uint8Array, name?: string): string;
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export declare function isPdfMediaType(mediaType: string): boolean;
+export declare function openAIAudioFormat(mediaType: string): string;
+export declare function serializeOpenAIResponsesInputFile(options: {
+    readonly filename: string;
+    readonly fileData?: string;
+    readonly fileId?: string;
+}): JsonObject;
+export declare function serializeOpenAIResponsesInputAudio(options: {
+    readonly data: string;
+    readonly format: string;
+}): JsonObject;
+export declare function serializePdfDocumentWireBlock(options: {
+    readonly mediaType: string;
+    readonly data: string;
+    readonly title?: string;
+}): JsonObject;
+export declare function resolveProviderMediaBlock(block: AudioContent | FileContent | DocumentContent, options?: ResolveMediaContentOptions): Promise<ResolvedMediaContent>;
+/** Resolve every media block once and enforce aggregate request bounds before provider I/O. */
+export declare function resolveProviderMediaMessages(messages: readonly Message[], model: ModelConfig, options?: ResolveMediaContentOptions): Promise<ReadonlyMap<MediaContentBlock, ResolvedMediaContent>>;
+export declare function defaultProviderFilename(block: MediaContentBlock, fallback: string): string;
+export declare const DEFAULT_PROVIDER_MEDIA_ITEM_BYTES = 10000000;

package/dist/providers/media.js

@@ -0,0 +1,126 @@
+import { createHash } from "node:crypto";
+import { assertMessagesSupportModelCapabilities, contentBlockInputModality, DEFAULT_MAX_MEDIA_ITEM_BYTES, resolveMediaContentBlock, resolveMediaContentBlocks, UnsupportedModalityError, } from "../content.js";
+/** Default upload-cache entry cap per provider media session. */
+export const DEFAULT_PROVIDER_UPLOAD_CACHE_ENTRIES = 32;
+/** Inline OpenAI file_data ceiling before preferring Files API upload. */
+export const DEFAULT_OPENAI_INLINE_FILE_BYTES = 4 * 1024 * 1024;
+export function assertProviderMediaCapability(modality, capabilities, model) {
+    const supported = capabilities.input;
+    if (supported?.length && !supported.includes(modality)) {
+        throw new UnsupportedModalityError(modality, model);
+    }
+}
+export function rejectProviderMediaBlock(part, capabilities, model) {
+    const modality = contentBlockInputModality(part);
+    if (modality)
+        assertProviderMediaCapability(modality, capabilities, model);
+    throw new Error(`Provider ${model.provider} does not support ${part.type} content blocks`);
+}
+export function createBoundedUploadCache(maxEntries = DEFAULT_PROVIDER_UPLOAD_CACHE_ENTRIES) {
+    const map = new Map();
+    return {
+        get(key) {
+            return map.get(key);
+        },
+        set(key, value) {
+            if (map.has(key))
+                map.delete(key);
+            else if (map.size >= maxEntries) {
+                const oldest = map.keys().next().value;
+                if (oldest !== undefined)
+                    map.delete(oldest);
+            }
+            map.set(key, value);
+        },
+        keys() {
+            return [...map.keys()];
+        },
+        clear() {
+            map.clear();
+        },
+    };
+}
+export function providerUploadCacheKey(scope, fingerprint) {
+    const prefix = [scope.tenantId, scope.sessionId, scope.runId].filter((value) => !!value).join(":");
+    return prefix ? `${prefix}:${fingerprint}` : fingerprint;
+}
+export function mediaFingerprint(mediaType, bytes, name) {
+    const hash = createHash("sha256").update(bytes).digest("hex");
+    return `${mediaType}:${name ?? ""}:${hash}`;
+}
+export function bytesToBase64(bytes) {
+    return Buffer.from(bytes).toString("base64");
+}
+export function isPdfMediaType(mediaType) {
+    const normalized = mediaType.toLowerCase();
+    return normalized === "application/pdf" || normalized.endsWith("+pdf");
+}
+export function openAIAudioFormat(mediaType) {
+    const normalized = mediaType.toLowerCase();
+    if (normalized.includes("wav"))
+        return "wav";
+    if (normalized.includes("mpeg") || normalized.includes("mp3"))
+        return "mp3";
+    if (normalized.includes("ogg"))
+        return "ogg";
+    if (normalized.includes("flac"))
+        return "flac";
+    if (normalized.includes("webm"))
+        return "webm";
+    if (normalized.includes("m4a") || normalized.includes("mp4"))
+        return "m4a";
+    return "wav";
+}
+export function serializeOpenAIResponsesInputFile(options) {
+    if (options.fileId) {
+        return { type: "input_file", file_id: options.fileId };
+    }
+    if (!options.fileData) {
+        throw new Error("OpenAI Responses file block requires inline file_data or uploaded file_id");
+    }
+    return { type: "input_file", filename: options.filename, file_data: options.fileData };
+}
+export function serializeOpenAIResponsesInputAudio(options) {
+    return { type: "input_audio", input_audio: { data: options.data, format: options.format } };
+}
+export function serializePdfDocumentWireBlock(options) {
+    if (!isPdfMediaType(options.mediaType)) {
+        throw new Error(`PDF document blocks require application/pdf media type, got ${options.mediaType}`);
+    }
+    return {
+        type: "document",
+        source: { type: "base64", media_type: options.mediaType, data: options.data },
+        ...(options.title ? { title: options.title } : {}),
+    };
+}
+export async function resolveProviderMediaBlock(block, options = {}) {
+    return resolveMediaContentBlock(block, options);
+}
+/** Resolve every media block once and enforce aggregate request bounds before provider I/O. */
+export async function resolveProviderMediaMessages(messages, model, options = {}) {
+    assertMessagesSupportModelCapabilities(model, messages);
+    const blocks = messages.flatMap((message) => message.content.filter(isMediaContentBlock));
+    const resolved = await resolveMediaContentBlocks(blocks, options);
+    return new Map(blocks.map((block, index) => [block, resolved[index]]));
+}
+function isMediaContentBlock(block) {
+    return contentBlockInputModality(block) !== undefined;
+}
+export function defaultProviderFilename(block, fallback) {
+    if ("name" in block && block.name)
+        return block.name;
+    if (block.type === "document")
+        return "document.pdf";
+    if (block.type === "audio")
+        return `audio.${openAIAudioFormat(declaredMediaType(block))}`;
+    return fallback;
+}
+function declaredMediaType(block) {
+    if ("mediaType" in block && block.mediaType)
+        return block.mediaType;
+    if (block.type === "image" && block.mimeType)
+        return block.mimeType;
+    return "application/octet-stream";
+}
+export const DEFAULT_PROVIDER_MEDIA_ITEM_BYTES = DEFAULT_MAX_MEDIA_ITEM_BYTES;
+//# sourceMappingURL=media.js.map

package/dist/providers/openai-compatible.js

@@ -1,6 +1,8 @@
 import { resolveCredentialValue } from "../credentials.js";
 import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallContent, } from "../provider-events.js";
-import { redactSecrets } from "../redaction.js";
+import { assertOpenAIChatMessage, applyOpenAIChatStructuredOutput, mapOpenAIChatUsage, serializeOpenAIChatMessage, serializeOpenAITool, } from "./openai-primitives.js";
+import { parseJsonObjectArguments, readBoundedResponseText, readSseData, } from "./transport.js";
+import { assertStructuredOutputRequestSupported } from "../structured-output.js";
 export function createOpenAICompatibleProvider(options) {
     const providerId = options.id ?? "openai-compatible";
     return {
@@ -25,18 +27,18 @@ export function createOpenAICompatibleProvider(options) {
                     signal: request.signal,
                 });
                 if (!response.ok) {
-                    yield providerError(new Error(`OpenAI-compatible request failed: ${response.status} ${await safeText(response)}`), secrets);
+                    yield providerError(new Error(`OpenAI-compatible request failed: ${response.status} ${await readBoundedResponseText(response, { secrets })}`), 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)) {
+                for await (const data of readSseData(response.body, { signal: request.signal })) {
                     if (data === "[DONE]")
                         break;
                     const parsed = JSON.parse(data);
-                    const usage = toUsage(parsed.usage);
+                    const usage = mapOpenAIChatUsage(parsed.usage);
                     if (usage)
                         yield providerUsage(usage);
                     for (const choice of parsed.choices ?? []) {
@@ -63,8 +65,9 @@ export function createOpenAICompatibleProvider(options) {
                     }
                 }
                 for (const call of tools.values()) {
-                    if (call.id && call.name)
-                        yield providerToolCall(toolCallContent(call.id, call.name, parseArgs(call.argumentsText)));
+                    if (call.id && call.name) {
+                        yield providerToolCall(toolCallContent(call.id, call.name, parseJsonObjectArguments(call.argumentsText, { toolName: call.name })));
+                    }
                 }
                 yield providerDone();
             }
@@ -75,123 +78,19 @@ export function createOpenAICompatibleProvider(options) {
     };
 }
 function toOpenAIRequest(request) {
-    return {
+    assertStructuredOutputRequestSupported(request.model, request.options);
+    const body = {
         model: request.model.model,
-        messages: request.messages.map((message) => toOpenAIMessage(message, request.model.capabilities ?? {})),
-        tools: request.tools?.map(toOpenAITool),
+        messages: request.messages.map((message, index) => {
+            assertOpenAIChatMessage(message, `messages[${index}]`);
+            return serializeOpenAIChatMessage(message, request.model.capabilities ?? {});
+        }),
+        tools: request.tools?.map(serializeOpenAITool),
         stream: true,
         stream_options: { include_usage: true },
         ...request.model.parameters,
     };
-}
-function toOpenAIMessage(message, capabilities = {}) {
-    if (message.role === "tool") {
-        const result = message.content.find((part) => part.type === "tool_result");
-        return {
-            role: "tool",
-            tool_call_id: result?.toolCallId ?? "",
-            content: result ? JSON.stringify(result.result ?? result.error ?? null) : "",
-        };
-    }
-    if (message.role === "assistant") {
-        const toolCalls = message.content.filter((part) => part.type === "tool_call");
-        const textParts = message.content.filter((part) => part.type === "text" || part.type === "thinking");
-        if (toolCalls.length > 0) {
-            return {
-                role: "assistant",
-                content: textParts.map((part) => (part.type === "text" ? part.text : part.text)).join("\n") || null,
-                tool_calls: toolCalls.map((call) => ({
-                    id: call.id,
-                    type: "function",
-                    function: { name: call.name, arguments: JSON.stringify(call.arguments) },
-                })),
-            };
-        }
-    }
-    const content = [];
-    for (const part of message.content) {
-        if (part.type === "text" || part.type === "thinking") {
-            content.push({ type: "text", text: part.text });
-        }
-        else if (part.type === "image") {
-            if (!capabilities.input?.includes("image")) {
-                throw new Error(`Provider ${message.role} message includes image but model does not declare image input capability`);
-            }
-            content.push(toOpenAIImage(part));
-        }
-        else if (part.type === "tool_call") {
-            throw new Error("Provider assistant tool_call blocks must be the only content on the message");
-        }
-        else if (part.type === "tool_result") {
-            throw new Error("Provider tool_result blocks must appear in role=tool messages");
-        }
-    }
-    if (content.length === 1 && content[0].type === "text") {
-        return { role: message.role, content: content[0].text };
-    }
-    return { role: message.role, content };
-}
-function toOpenAIImage(part) {
-    const url = part.url ?? (part.data ? `data:${part.mimeType ?? "image/png"};base64,${part.data}` : undefined);
-    if (!url)
-        throw new Error("Provider image block missing url or data");
-    return { type: "image_url", image_url: { url } };
-}
-function toOpenAITool(tool) {
-    return {
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: tool.parameters ?? { type: "object" },
-        },
-    };
-}
-async function* readSseData(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split(/\r?\n/);
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-            if (line.startsWith("data: "))
-                yield line.slice(6).trim();
-        }
-    }
-    buffer += decoder.decode();
-    for (const line of buffer.split(/\r?\n/)) {
-        if (line.startsWith("data: "))
-            yield line.slice(6).trim();
-    }
-}
-async function safeText(response) {
-    try {
-        return redactSecrets(await response.text(), []);
-    }
-    catch {
-        return "";
-    }
-}
-function parseArgs(text) {
-    if (!text)
-        return {};
-    const parsed = JSON.parse(text);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-}
-function toUsage(usage) {
-    if (!usage)
-        return undefined;
-    return {
-        inputTokens: usage.prompt_tokens,
-        outputTokens: usage.completion_tokens,
-        totalTokens: usage.total_tokens,
-        cacheReadTokens: usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_cache_hit_tokens,
-        cacheWriteTokens: usage.prompt_tokens_details?.cache_write_tokens,
-    };
+    applyOpenAIChatStructuredOutput(body, request.options?.structuredOutput);
+    return body;
 }
 //# sourceMappingURL=openai-compatible.js.map

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

@@ -0,0 +1,9 @@
+import type { JsonObject, Message, ModelCapabilities, StructuredOutputOptions, ToolDefinition, Usage } from "../contracts.js";
+export declare function assertOpenAIChatMessage(message: unknown, path: string): asserts message is Message;
+export declare function serializeOpenAIChatStructuredOutput(options: StructuredOutputOptions): JsonObject;
+export declare function serializeOpenAIResponsesStructuredOutput(options: StructuredOutputOptions): JsonObject;
+export declare function applyOpenAIChatStructuredOutput(body: Record<string, unknown>, structuredOutput?: StructuredOutputOptions): void;
+export declare function applyOpenAIResponsesStructuredOutput(body: Record<string, unknown>, structuredOutput?: StructuredOutputOptions): void;
+export declare function serializeOpenAITool(tool: ToolDefinition): JsonObject;
+export declare function serializeOpenAIChatMessage(message: Message, capabilities?: ModelCapabilities): JsonObject;
+export declare function mapOpenAIChatUsage(usage: unknown): Usage | undefined;

package/dist/providers/openai-primitives.js

@@ -0,0 +1,129 @@
+export function assertOpenAIChatMessage(message, path) {
+    if (!message || typeof message !== "object") {
+        throw new Error(`Invalid provider message at ${path}: expected object`);
+    }
+    const candidate = message;
+    if (typeof candidate.role !== "string") {
+        throw new Error(`Invalid provider message at ${path}: expected role`);
+    }
+    if (!Array.isArray(candidate.content)) {
+        throw new Error(`Invalid provider message at ${path}: expected content array`);
+    }
+}
+export function serializeOpenAIChatStructuredOutput(options) {
+    return {
+        type: "json_schema",
+        json_schema: {
+            name: options.name,
+            schema: options.schema,
+            ...(options.strict === undefined ? {} : { strict: options.strict }),
+        },
+    };
+}
+export function serializeOpenAIResponsesStructuredOutput(options) {
+    return {
+        format: {
+            type: "json_schema",
+            name: options.name,
+            schema: options.schema,
+            ...(options.strict === undefined ? {} : { strict: options.strict }),
+        },
+    };
+}
+export function applyOpenAIChatStructuredOutput(body, structuredOutput) {
+    if (!structuredOutput)
+        return;
+    body.response_format = serializeOpenAIChatStructuredOutput(structuredOutput);
+}
+export function applyOpenAIResponsesStructuredOutput(body, structuredOutput) {
+    if (!structuredOutput)
+        return;
+    body.text = serializeOpenAIResponsesStructuredOutput(structuredOutput);
+}
+export function serializeOpenAITool(tool) {
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters ?? { type: "object" },
+        },
+    };
+}
+export function serializeOpenAIChatMessage(message, capabilities = {}) {
+    if (message.role === "tool") {
+        const result = message.content.find((part) => part.type === "tool_result");
+        return {
+            role: "tool",
+            tool_call_id: result?.toolCallId ?? "",
+            content: result ? JSON.stringify(result.result ?? result.error ?? null) : "",
+        };
+    }
+    if (message.role === "assistant") {
+        const toolCalls = message.content.filter((part) => part.type === "tool_call");
+        const textParts = message.content.filter((part) => part.type === "text" || part.type === "thinking");
+        if (toolCalls.length > 0) {
+            return {
+                role: "assistant",
+                content: textParts.map((part) => part.text).join("\n") || null,
+                tool_calls: toolCalls.map((call) => ({
+                    id: call.id,
+                    type: "function",
+                    function: { name: call.name, arguments: JSON.stringify(call.arguments) },
+                })),
+            };
+        }
+    }
+    const content = [];
+    for (const part of message.content) {
+        if (part.type === "text" || part.type === "thinking") {
+            content.push({ type: "text", text: part.text });
+        }
+        else if (part.type === "image") {
+            if (!capabilities.input?.includes("image")) {
+                throw new Error(`Provider ${message.role} message includes image but model does not declare image input capability`);
+            }
+            content.push(serializeOpenAIImage(part));
+        }
+        else if (part.type === "audio" || part.type === "file" || part.type === "document") {
+            throw new Error(`OpenAI Chat Completions does not support ${part.type} content blocks`);
+        }
+        else if (part.type === "tool_call") {
+            throw new Error("Provider assistant tool_call blocks must be the only content on the message");
+        }
+        else if (part.type === "tool_result") {
+            throw new Error("Provider tool_result blocks must appear in role=tool messages");
+        }
+    }
+    if (content.length === 1 && content[0].type === "text") {
+        return { role: message.role, content: content[0].text };
+    }
+    return { role: message.role, content };
+}
+function serializeOpenAIImage(part) {
+    const url = part.url ?? (part.data ? `data:${part.mimeType ?? "image/png"};base64,${part.data}` : undefined);
+    if (!url)
+        throw new Error("Provider image block missing url or data");
+    return { type: "image_url", image_url: { url } };
+}
+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) {
+        return undefined;
+    }
+    return {
+        inputTokens: wire.prompt_tokens,
+        outputTokens: wire.completion_tokens,
+        totalTokens: wire.total_tokens,
+        cacheReadTokens: wire.prompt_tokens_details?.cached_tokens ?? wire.prompt_cache_hit_tokens,
+        cacheWriteTokens: wire.prompt_tokens_details?.cache_write_tokens,
+    };
+}
+//# sourceMappingURL=openai-primitives.js.map

package/dist/providers/transport.d.ts

@@ -0,0 +1,40 @@
+import type { JsonObject } from "../contracts.js";
+export declare const DEFAULT_MAX_EVENT_BYTES = 262144;
+export declare const DEFAULT_MAX_BUFFER_BYTES = 524288;
+export declare const DEFAULT_MAX_RESPONSE_BODY_BYTES = 65536;
+export declare const DEFAULT_MAX_ARGUMENT_BYTES = 262144;
+export interface BoundedStreamLimits {
+    readonly maxEventBytes?: number;
+    readonly maxBufferBytes?: number;
+    readonly maxResponseBodyBytes?: number;
+}
+export interface SseEvent {
+    readonly id?: string;
+    readonly event?: string;
+    readonly data: string;
+    readonly comments?: readonly string[];
+}
+export type ProviderTransportErrorCode = "sse_buffer_overflow" | "sse_event_overflow" | "response_body_overflow" | "aborted" | "invalid_json_arguments";
+export declare class ProviderTransportError extends Error {
+    readonly code: ProviderTransportErrorCode;
+    readonly limitBytes?: number;
+    constructor(code: ProviderTransportErrorCode, message: string, limitBytes?: number);
+}
+export interface ReadSseEventsOptions extends BoundedStreamLimits {
+    readonly signal?: AbortSignal;
+}
+export interface ReadBoundedResponseTextOptions extends BoundedStreamLimits {
+    readonly secrets?: readonly (string | undefined)[];
+}
+export interface ParseJsonObjectArgumentsOptions {
+    readonly toolName?: string;
+    readonly maxBytes?: number;
+}
+/** Incremental O(bytes) SSE parser with finite buffer/event limits. */
+export declare function readSseEvents(body: ReadableStream<Uint8Array>, options?: ReadSseEventsOptions): AsyncGenerator<SseEvent>;
+/** Yields joined `data:` payloads for each SSE event (migration helper over {@link readSseEvents}). */
+export declare function readSseData(body: ReadableStream<Uint8Array>, options?: ReadSseEventsOptions): AsyncGenerator<string>;
+/** Read a response body with a hard byte ceiling; redacts optional secrets. */
+export declare function readBoundedResponseText(response: Response, options?: ReadBoundedResponseTextOptions): Promise<string>;
+/** Parse streamed tool arguments as a JSON object; throws {@link ProviderTransportError} on invalid input. */
+export declare function parseJsonObjectArguments(text: string, options?: ParseJsonObjectArgumentsOptions): JsonObject;