@arnilo/prism 0.0.2 → 0.0.4

package/dist/leases.js

@@ -0,0 +1,111 @@
+export const LEASE_CONFLICT_CODE = "ERR_PRISM_LEASE_CONFLICT";
+export class LeaseConflictError extends Error {
+    code = LEASE_CONFLICT_CODE;
+    constructor(message) {
+        super(message);
+        this.name = "LeaseConflictError";
+    }
+}
+/** In-process reference implementation. Durable adapters provide cross-process exclusion. */
+export function createMemoryLeaseStore() {
+    const records = new Map();
+    return {
+        async tryAcquireLease(input) {
+            validateAcquire(input);
+            const id = keyOf(input);
+            const current = records.get(id);
+            if (current)
+                assertOwnership(input, current);
+            const now = Date.now();
+            if (current && Date.parse(current.expiresAt) > now)
+                return null;
+            const timestamp = new Date(now).toISOString();
+            const record = {
+                namespace: input.namespace,
+                key: input.key,
+                ownerId: input.ownerId,
+                token: crypto.randomUUID(),
+                fencingToken: (current?.fencingToken ?? 0) + 1,
+                acquiredAt: timestamp,
+                expiresAt: new Date(now + input.ttlMs).toISOString(),
+                updatedAt: timestamp,
+                ...ownership(input),
+            };
+            records.set(id, record);
+            return record;
+        },
+        async renewLease(input) {
+            validateClaim(input, true);
+            const current = records.get(keyOf(input));
+            if (!current)
+                return null;
+            assertOwnership(input, current);
+            const now = Date.now();
+            if (current.ownerId !== input.ownerId || current.token !== input.token || Date.parse(current.expiresAt) <= now)
+                return null;
+            const record = {
+                ...current,
+                expiresAt: new Date(now + input.ttlMs).toISOString(),
+                updatedAt: new Date(now).toISOString(),
+            };
+            records.set(keyOf(input), record);
+            return record;
+        },
+        async releaseLease(input) {
+            validateClaim(input, false);
+            const current = records.get(keyOf(input));
+            if (!current)
+                return false;
+            assertOwnership(input, current);
+            if (current.ownerId !== input.ownerId || current.token !== input.token)
+                return false;
+            const now = new Date().toISOString();
+            records.set(keyOf(input), { ...current, expiresAt: now, updatedAt: now });
+            return true;
+        },
+        async getLease(input) {
+            throwIfAborted(input.signal);
+            const current = records.get(keyOf(input));
+            if (!current)
+                return null;
+            assertOwnership(input, current);
+            return Date.parse(current.expiresAt) > Date.now() ? current : null;
+        },
+    };
+}
+function keyOf(input) {
+    return `${input.namespace}\0${input.key}`;
+}
+function ownership(input) {
+    return {
+        ...(input.tenantId === undefined ? {} : { tenantId: input.tenantId }),
+        ...(input.accountId === undefined ? {} : { accountId: input.accountId }),
+        ...(input.userId === undefined ? {} : { userId: input.userId }),
+    };
+}
+function assertOwnership(expected, actual) {
+    if (expected.tenantId !== actual.tenantId || expected.accountId !== actual.accountId || expected.userId !== actual.userId) {
+        throw new LeaseConflictError("Lease ownership mismatch");
+    }
+}
+function validateKey(input) {
+    throwIfAborted(input.signal);
+    if (!input.namespace || !input.key)
+        throw new LeaseConflictError("Lease namespace and key are required");
+}
+function validateAcquire(input) {
+    validateKey(input);
+    if (!input.ownerId || !Number.isSafeInteger(input.ttlMs) || input.ttlMs < 1)
+        throw new LeaseConflictError("Lease ownerId and positive ttlMs are required");
+}
+function validateClaim(input, requireTtl) {
+    validateKey(input);
+    if (!input.ownerId || !input.token || (requireTtl && (!Number.isSafeInteger(input.ttlMs) || input.ttlMs < 1))) {
+        throw new LeaseConflictError("Lease ownerId, token, and positive ttlMs are required");
+    }
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+//# sourceMappingURL=leases.js.map

package/dist/node/agent-definitions.js

@@ -7,6 +7,7 @@ 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";
 const defaultInclude = {
     systemPrompt: true,
     agentPrompt: true,
@@ -329,7 +330,7 @@ async function listSubdirs(dir) {
         return out;
     }
     catch (error) {
-        if (isMissingFile(error))
+        if (isNodeErrorCode(error, "ENOENT"))
             return [];
         throw error;
     }
@@ -339,14 +340,11 @@ async function readOptional(read, path) {
         return await read(path);
     }
     catch (error) {
-        if (isMissingFile(error))
+        if (isNodeErrorCode(error, "ENOENT"))
             return undefined;
         throw error;
     }
 }
-function isMissingFile(error) {
-    return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
 const NAME_RE = /^[A-Za-z0-9 _-]+$/;
 function parentDirName(path) {
     const parts = path.split(/[/\\]+/).filter(Boolean);

package/dist/node/config.d.ts

@@ -7,3 +7,4 @@ export interface NodeConfigFile {
 export declare function defaultUserConfigPath(appName?: string): string;
 export declare function readConfigFile(path: string): Promise<ConfigLayer["config"]>;
 export declare function loadConfigFiles(files: readonly NodeConfigFile[]): Promise<ConfigLayer[]>;
+export declare function isNodeErrorCode(error: unknown, code: string): boolean;

package/dist/node/config.js

@@ -11,6 +11,8 @@ export async function readConfigFile(path) {
         text = await readFile(path, "utf8");
     }
     catch (error) {
+        if (isNodeErrorCode(error, "ENOENT"))
+            throw error;
         throw new Error(`Failed to read config ${path}: ${errorMessage(error)}`);
     }
     let parsed;
@@ -35,15 +37,15 @@ export async function loadConfigFiles(files) {
             layers.push({ name: file.name, config: await readConfigFile(file.path) });
         }
         catch (error) {
-            if (file.optional && isMissingFile(error))
+            if (file.optional && isNodeErrorCode(error, "ENOENT"))
                 continue;
             throw error;
         }
     }
     return layers;
 }
-function isMissingFile(error) {
-    return error instanceof Error && error.message.includes("ENOENT");
+export function isNodeErrorCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
 }
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);

package/dist/node/contribution-discovery.js

@@ -4,6 +4,7 @@ import { isJsonObject } from "../config.js";
 import { assertPermission } from "../security.js";
 import { isPathInsideReal } from "./trust.js";
 import { parseSkillFile } from "../contribution-parsing.js";
+import { isNodeErrorCode } from "./config.js";
 /**
  * Discover contributions on disk. Scans the workspace `.agents/` tree only;
  * no global root. One `readdir` per kind-root; no `import()`. Inert output —
@@ -34,7 +35,7 @@ async function scanKindRoot(root, kind, options) {
         names = await readdir(kindDir);
     }
     catch (error) {
-        if (isMissingFile(error))
+        if (isNodeErrorCode(error, "ENOENT"))
             return []; // missing kind root is normal
         throw error;
     }
@@ -46,7 +47,7 @@ async function scanKindRoot(root, kind, options) {
             isDir = (await stat(dir)).isDirectory();
         }
         catch (error) {
-            if (isMissingFile(error))
+            if (isNodeErrorCode(error, "ENOENT"))
                 continue;
             throw error;
         }
@@ -91,14 +92,13 @@ async function readManifestEntry(dir, fallbackName, kind, origin) {
     const declaration = parseManifestDeclaration(text, path, kind, fallbackName);
     return { kind, name: declaration.name, origin, path, declaration };
 }
-// ponytail: Phase 31 — exported so the system/project prompt file loader reuses the scanner's
-// ENOENT-tolerant read instead of duplicating it. isMissingFile stays private (only readOptionalFile needs it).
+// ponytail: Phase 31 — exported so the system/project prompt file loader reuses this ENOENT-tolerant read.
 export async function readOptionalFile(path) {
     try {
         return await readFile(path, "utf8");
     }
     catch (error) {
-        if (isMissingFile(error))
+        if (isNodeErrorCode(error, "ENOENT"))
             return undefined;
         throw error;
     }
@@ -106,9 +106,6 @@ export async function readOptionalFile(path) {
 // --- Internal helpers. ---
 // ponytail: parseSkillFile/parseAgentFile live in ../contribution-parsing.ts (core, fs-free); this
 // Node module owns directory walking + manifest.json parsing only.
-function isMissingFile(error) {
-    return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
 function parseManifestDeclaration(text, path, dirKind, fallbackName) {
     let parsed;
     try {

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,42 @@
+import type { AudioContent, ContentBlock, DocumentContent, FileContent, JsonObject, 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>;
+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,116 @@
+import { createHash } from "node:crypto";
+import { contentBlockInputModality, DEFAULT_MAX_MEDIA_ITEM_BYTES, resolveMediaContentBlock, 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);
+}
+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