@arnilo/prism 0.0.2 → 0.0.4

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;

package/dist/providers/transport.js

@@ -0,0 +1,221 @@
+import { redactSecrets } from "../redaction.js";
+export const DEFAULT_MAX_EVENT_BYTES = 262_144;
+export const DEFAULT_MAX_BUFFER_BYTES = 524_288;
+export const DEFAULT_MAX_RESPONSE_BODY_BYTES = 65_536;
+export const DEFAULT_MAX_ARGUMENT_BYTES = 262_144;
+export class ProviderTransportError extends Error {
+    code;
+    limitBytes;
+    constructor(code, message, limitBytes) {
+        super(message);
+        this.name = "ProviderTransportError";
+        this.code = code;
+        this.limitBytes = limitBytes;
+    }
+}
+function resolveLimits(options) {
+    return {
+        maxEventBytes: options?.maxEventBytes ?? DEFAULT_MAX_EVENT_BYTES,
+        maxBufferBytes: options?.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES,
+        maxResponseBodyBytes: options?.maxResponseBodyBytes ?? DEFAULT_MAX_RESPONSE_BODY_BYTES,
+    };
+}
+function byteLength(text) {
+    return new TextEncoder().encode(text).length;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw new ProviderTransportError("aborted", "Transport operation aborted");
+    }
+}
+function parseSseEventBlock(block) {
+    const comments = [];
+    const dataLines = [];
+    let id;
+    let event;
+    for (const line of block.split(/\r?\n/)) {
+        if (!line)
+            continue;
+        if (line.startsWith(":")) {
+            comments.push(line.slice(1).trimStart());
+            continue;
+        }
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^\s/, "");
+        switch (field) {
+            case "data":
+                dataLines.push(value);
+                break;
+            case "id":
+                id = value;
+                break;
+            case "event":
+                event = value;
+                break;
+            default:
+                break;
+        }
+    }
+    const data = dataLines.join("\n");
+    if (!data && comments.length === 0)
+        return undefined;
+    return {
+        id,
+        event,
+        data,
+        ...(comments.length > 0 ? { comments } : {}),
+    };
+}
+function eventBlockBytes(block) {
+    return byteLength(block);
+}
+/** Incremental O(bytes) SSE parser with finite buffer/event limits. */
+export async function* readSseEvents(body, options) {
+    const limits = resolveLimits(options);
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const ensureBufferLimit = () => {
+        if (byteLength(buffer) > limits.maxBufferBytes) {
+            throw new ProviderTransportError("sse_buffer_overflow", `SSE buffer exceeded ${limits.maxBufferBytes} bytes`, limits.maxBufferBytes);
+        }
+    };
+    const yieldCompleteEvents = function* () {
+        while (true) {
+            const match = buffer.match(/\r?\n\r?\n/);
+            if (!match || match.index === undefined)
+                break;
+            const block = buffer.slice(0, match.index);
+            buffer = buffer.slice(match.index + match[0].length);
+            const parsed = parseSseEventBlock(block);
+            if (!parsed)
+                continue;
+            const size = eventBlockBytes(block);
+            if (size > limits.maxEventBytes) {
+                throw new ProviderTransportError("sse_event_overflow", `SSE event exceeded ${limits.maxEventBytes} bytes`, limits.maxEventBytes);
+            }
+            yield parsed;
+        }
+    };
+    try {
+        while (true) {
+            throwIfAborted(options?.signal);
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            ensureBufferLimit();
+            yield* yieldCompleteEvents();
+        }
+        buffer += decoder.decode();
+        ensureBufferLimit();
+        yield* yieldCompleteEvents();
+        const tail = buffer.trim();
+        if (tail) {
+            const parsed = parseSseEventBlock(tail);
+            if (parsed) {
+                const size = eventBlockBytes(tail);
+                if (size > limits.maxEventBytes) {
+                    throw new ProviderTransportError("sse_event_overflow", `SSE event exceeded ${limits.maxEventBytes} bytes`, limits.maxEventBytes);
+                }
+                yield parsed;
+            }
+        }
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // already released
+        }
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // stream may already be closed
+        }
+    }
+}
+/** Yields joined `data:` payloads for each SSE event (migration helper over {@link readSseEvents}). */
+export async function* readSseData(body, options) {
+    for await (const event of readSseEvents(body, options)) {
+        const data = event.data.trim();
+        if (data)
+            yield data;
+    }
+}
+/** Read a response body with a hard byte ceiling; redacts optional secrets. */
+export async function readBoundedResponseText(response, options) {
+    const limits = resolveLimits(options);
+    const secrets = options?.secrets ?? [];
+    if (!response.body) {
+        try {
+            const text = await response.text();
+            if (byteLength(text) > limits.maxResponseBodyBytes) {
+                throw new ProviderTransportError("response_body_overflow", `Response body exceeded ${limits.maxResponseBodyBytes} bytes`, limits.maxResponseBodyBytes);
+            }
+            return redactSecrets(text, secrets);
+        }
+        catch (error) {
+            if (error instanceof ProviderTransportError)
+                throw error;
+            return "";
+        }
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const parts = [];
+    let totalBytes = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            totalBytes += value.byteLength;
+            if (totalBytes > limits.maxResponseBodyBytes) {
+                throw new ProviderTransportError("response_body_overflow", `Response body exceeded ${limits.maxResponseBodyBytes} bytes`, limits.maxResponseBodyBytes);
+            }
+            parts.push(decoder.decode(value, { stream: true }));
+        }
+        parts.push(decoder.decode());
+        return redactSecrets(parts.join(""), secrets);
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // already released
+        }
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // stream may already be closed
+        }
+    }
+}
+/** Parse streamed tool arguments as a JSON object; throws {@link ProviderTransportError} on invalid input. */
+export function parseJsonObjectArguments(text, options) {
+    const maxBytes = options?.maxBytes ?? DEFAULT_MAX_ARGUMENT_BYTES;
+    const suffix = options?.toolName ? ` for tool ${options.toolName}` : "";
+    if (!text)
+        return {};
+    if (byteLength(text) > maxBytes) {
+        throw new ProviderTransportError("invalid_json_arguments", `Tool arguments${suffix} exceeded ${maxBytes} bytes`, maxBytes);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        throw new ProviderTransportError("invalid_json_arguments", `Invalid tool arguments JSON${suffix}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new ProviderTransportError("invalid_json_arguments", `Tool arguments${suffix} must be a JSON object`);
+    }
+    return parsed;
+}
+//# sourceMappingURL=transport.js.map

package/dist/redaction.js

@@ -22,10 +22,25 @@ export function redactSecrets(value, secrets) {
     if (needles.length === 0)
         return value;
     const redactString = (text) => needles.reduce((current, secret) => current.split(secret).join(REDACTED), text);
-    // ponytail: WeakSet cycle guard + leaf passthrough for Date/RegExp/ArrayBuffer/typed
-    // arrays. Map/Set are normalized to plain object/array so output stays JSON-shaped.
-    // Upgrade path: if callers need original Map/Set preserved, thread a mode flag.
-    const redact = (input, seen = new WeakSet()) => {
+    const redactKey = (key) => {
+        if (typeof key === "string")
+            return redactString(key);
+        return String(key);
+    };
+    const assignKey = (target, key, value) => {
+        if (!Object.prototype.hasOwnProperty.call(target, key)) {
+            target[key] = value;
+            return;
+        }
+        let suffix = 2;
+        while (Object.prototype.hasOwnProperty.call(target, `${key}__${suffix}`))
+            suffix += 1;
+        target[`${key}__${suffix}`] = value;
+    };
+    // ponytail: active-path WeakSet marks only ancestor cycles as [Circular]; shared
+    // references (diamonds) are visited again on separate branches. Map/Set normalize
+    // to JSON-shaped output; string keys are redacted like values.
+    const redact = (input, active = new WeakSet()) => {
         if (typeof input === "string")
             return redactString(input);
         if (input === null || typeof input !== "object")
@@ -34,16 +49,28 @@ export function redactSecrets(value, secrets) {
             return input;
         if (ArrayBuffer.isView(input) || input instanceof ArrayBuffer)
             return input;
-        if (seen.has(input))
+        if (active.has(input))
             return "[Circular]";
-        seen.add(input);
-        if (Array.isArray(input))
-            return input.map((item) => redact(item, seen));
-        if (input instanceof Map)
-            return Object.fromEntries([...input].map(([key, item]) => [key, redact(item, seen)]));
-        if (input instanceof Set)
-            return [...input].map((item) => redact(item, seen));
-        return Object.fromEntries(Object.entries(input).map(([key, item]) => [key, redact(item, seen)]));
+        active.add(input);
+        try {
+            if (Array.isArray(input))
+                return input.map((item) => redact(item, active));
+            if (input instanceof Map) {
+                const out = {};
+                for (const [key, item] of input)
+                    assignKey(out, redactKey(key), redact(item, active));
+                return out;
+            }
+            if (input instanceof Set)
+                return [...input].map((item) => redact(item, active));
+            const out = {};
+            for (const [key, item] of Object.entries(input))
+                assignKey(out, redactKey(key), redact(item, active));
+            return out;
+        }
+        finally {
+            active.delete(input);
+        }
     };
     return redact(value);
 }

package/dist/resources.d.ts

@@ -1,5 +1,10 @@
 import { type PrismManifest } from "./manifests.js";
 import type { JsonObject, ResourceLoader, ResourceLoadContext } from "./contracts.js";
+import { type MediaContentBounds } from "./content.js";
 export declare function loadTextResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<string>;
 export declare function loadJsonResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<JsonObject>;
 export declare function loadManifestResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<PrismManifest>;
+export interface LoadBinaryResourceOptions extends MediaContentBounds {
+    readonly signal?: AbortSignal;
+}
+export declare function loadBinaryResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext, options?: LoadBinaryResourceOptions): Promise<Uint8Array>;

package/dist/resources.js

@@ -1,5 +1,6 @@
 import { parsePrismManifest } from "./manifests.js";
 import { assertJsonObject } from "./config.js";
+import { DEFAULT_MAX_MEDIA_ITEM_BYTES, loadBoundedBinaryResource, } from "./content.js";
 import { assertPermission } from "./security.js";
 export async function loadTextResource(loader, uri, context) {
     await assertPermission(context?.permission, { kind: "resource", action: "load", target: uri, metadata: context?.metadata });
@@ -24,6 +25,9 @@ export async function loadJsonResource(loader, uri, context) {
 export async function loadManifestResource(loader, uri, context) {
     return parsePrismManifest(await loadJsonResource(loader, uri, context));
 }
+export async function loadBinaryResource(loader, uri, context, options) {
+    return loadBoundedBinaryResource(loader, uri, context, options?.maxItemBytes ?? DEFAULT_MAX_MEDIA_ITEM_BYTES, options?.signal ?? context?.signal);
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/structured-output.d.ts

@@ -0,0 +1,11 @@
+import type { AgentConfig, ModelCapabilities, ModelConfig, ProviderRequestOptions, RunOptions, StructuredOutputOptions } from "./contracts.js";
+export declare const DEFAULT_MAX_STRUCTURED_OUTPUT_SCHEMA_BYTES = 65536;
+export declare const DEFAULT_MAX_STRUCTURED_OUTPUT_NAME_LENGTH = 128;
+export declare class StructuredOutputError extends Error {
+    readonly code: "invalid_schema" | "unsupported_model" | "schema_too_large" | "invalid_name";
+    constructor(code: StructuredOutputError["code"], message: string);
+}
+export declare function modelSupportsStructuredOutput(capabilities?: ModelCapabilities): boolean;
+export declare function validateStructuredOutputOptions(options: StructuredOutputOptions): StructuredOutputOptions;
+export declare function assertStructuredOutputRequestSupported(model: ModelConfig, options?: ProviderRequestOptions): void;
+export declare function resolveRunProviderOptions(runOptions: Pick<RunOptions, "providerOptions" | "loop">, config: Pick<AgentConfig, "providerOptions" | "loop">): ProviderRequestOptions | undefined;

package/dist/structured-output.js

@@ -0,0 +1,59 @@
+import { assertJsonObject } from "./config.js";
+import { mergeProviderRequestOptions } from "./provider-request-policy.js";
+export const DEFAULT_MAX_STRUCTURED_OUTPUT_SCHEMA_BYTES = 65_536;
+export const DEFAULT_MAX_STRUCTURED_OUTPUT_NAME_LENGTH = 128;
+export class StructuredOutputError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "StructuredOutputError";
+        this.code = code;
+    }
+}
+export function modelSupportsStructuredOutput(capabilities) {
+    const mode = capabilities?.structuredOutput;
+    return mode === true || mode === "json_schema";
+}
+export function validateStructuredOutputOptions(options) {
+    const name = options.name.trim();
+    if (!name)
+        throw new StructuredOutputError("invalid_name", "structuredOutput.name is required");
+    if (name.length > DEFAULT_MAX_STRUCTURED_OUTPUT_NAME_LENGTH) {
+        throw new StructuredOutputError("invalid_name", `structuredOutput.name exceeded ${DEFAULT_MAX_STRUCTURED_OUTPUT_NAME_LENGTH} characters`);
+    }
+    try {
+        assertJsonObject(options.schema, "structuredOutput.schema");
+    }
+    catch (error) {
+        throw new StructuredOutputError("invalid_schema", error instanceof Error ? error.message : "structuredOutput.schema must be a JSON object");
+    }
+    const schemaBytes = new TextEncoder().encode(JSON.stringify(options.schema)).byteLength;
+    if (schemaBytes > DEFAULT_MAX_STRUCTURED_OUTPUT_SCHEMA_BYTES) {
+        throw new StructuredOutputError("schema_too_large", `structuredOutput.schema exceeded ${DEFAULT_MAX_STRUCTURED_OUTPUT_SCHEMA_BYTES} bytes`);
+    }
+    return { ...options, name, schema: options.schema };
+}
+export function assertStructuredOutputRequestSupported(model, options) {
+    if (!options?.structuredOutput)
+        return;
+    validateStructuredOutputOptions(options.structuredOutput);
+    if (!modelSupportsStructuredOutput(model.capabilities)) {
+        throw new StructuredOutputError("unsupported_model", `Model ${model.provider}/${model.model} does not declare structuredOutput capability; `
+            + `set loop.structuredOutputMode to "artifact-loop" or choose a capable model`);
+    }
+}
+function isGenerateValidateReviseLoopOptions(loop) {
+    return typeof loop === "object" && loop !== null && "strategy" in loop && loop.strategy === "generate-validate-revise";
+}
+export function resolveRunProviderOptions(runOptions, config) {
+    const merged = mergeProviderRequestOptions(config.providerOptions, runOptions.providerOptions);
+    const loop = runOptions.loop ?? config.loop;
+    if (!isGenerateValidateReviseLoopOptions(loop))
+        return merged;
+    if (loop.structuredOutputMode === "artifact-loop" || !loop.structuredOutput)
+        return merged;
+    return mergeProviderRequestOptions(merged, {
+        structuredOutput: validateStructuredOutputOptions(loop.structuredOutput),
+    });
+}
+//# sourceMappingURL=structured-output.js.map