@veryfront/ext-llm-openai 0.1.1185 → 0.1.1189

package/esm/openai-sse-buffer.d.ts

@@ -0,0 +1,8 @@
+import { MAX_PROVIDER_SSE_BUFFER_CODE_UNITS, parseSseChunk } from "veryfront/provider/shared";
+type InvalidStreamFactory = (issue: string) => Error;
+export { MAX_PROVIDER_SSE_BUFFER_CODE_UNITS as MAX_OPENAI_SSE_BUFFER_CODE_UNITS };
+export declare const MAX_OPENAI_SSE_RAW_CHUNK_BYTES: number;
+export declare function appendOpenAISseChunk(decoder: TextDecoder, buffer: string, chunk: Uint8Array, invalid: InvalidStreamFactory): string;
+export declare function finishOpenAISseDecoding(decoder: TextDecoder, buffer: string, invalid: InvalidStreamFactory): string;
+export declare function parseOpenAISseBuffer(buffer: string, invalid: InvalidStreamFactory, trailing?: boolean): ReturnType<typeof parseSseChunk>;
+//# sourceMappingURL=openai-sse-buffer.d.ts.map

package/esm/openai-sse-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-sse-buffer.d.ts","sourceRoot":"","sources":["../src/openai-sse-buffer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kCAAkC,EAElC,aAAa,EACd,MAAM,2BAA2B,CAAC;AAEnC,KAAK,oBAAoB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC;AAErD,OAAO,EAAE,kCAAkC,IAAI,gCAAgC,EAAE,CAAC;AAClF,eAAO,MAAM,8BAA8B,QAA6C,CAAC;AAEzF,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,oBAAoB,GAC5B,MAAM,CA2BR;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,oBAAoB,GAC5B,MAAM,CAaR;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,UAAQ,GACf,UAAU,CAAC,OAAO,aAAa,CAAC,CAQlC"}

package/esm/openai-sse-buffer.js

@@ -0,0 +1,47 @@
+import { MAX_PROVIDER_SSE_BUFFER_CODE_UNITS, parseFinalSseChunk, parseSseChunk, } from "veryfront/provider/shared";
+export { MAX_PROVIDER_SSE_BUFFER_CODE_UNITS as MAX_OPENAI_SSE_BUFFER_CODE_UNITS };
+export const MAX_OPENAI_SSE_RAW_CHUNK_BYTES = MAX_PROVIDER_SSE_BUFFER_CODE_UNITS * 3 + 3;
+export function appendOpenAISseChunk(decoder, buffer, chunk, invalid) {
+    if (!(chunk instanceof Uint8Array)) {
+        throw invalid("stream chunk was not binary data");
+    }
+    const remainingCodeUnits = MAX_PROVIDER_SSE_BUFFER_CODE_UNITS - buffer.length;
+    // Valid UTF-8 needs at most three bytes per UTF-16 code unit. The extra
+    // three bytes cover an incomplete sequence retained by the decoder.
+    if (chunk.byteLength > MAX_OPENAI_SSE_RAW_CHUNK_BYTES ||
+        chunk.byteLength > remainingCodeUnits * 3 + 3) {
+        throw invalid(`SSE buffer exceeded ${MAX_PROVIDER_SSE_BUFFER_CODE_UNITS} code units`);
+    }
+    let decoded;
+    try {
+        decoded = decoder.decode(chunk, { stream: true });
+    }
+    catch {
+        throw invalid("stream contained invalid UTF-8");
+    }
+    if (decoded.length > MAX_PROVIDER_SSE_BUFFER_CODE_UNITS - buffer.length) {
+        throw invalid(`SSE buffer exceeded ${MAX_PROVIDER_SSE_BUFFER_CODE_UNITS} code units`);
+    }
+    return buffer + decoded;
+}
+export function finishOpenAISseDecoding(decoder, buffer, invalid) {
+    let decoded;
+    try {
+        decoded = decoder.decode();
+    }
+    catch {
+        throw invalid("stream contained invalid UTF-8");
+    }
+    if (decoded.length > MAX_PROVIDER_SSE_BUFFER_CODE_UNITS - buffer.length) {
+        throw invalid(`SSE buffer exceeded ${MAX_PROVIDER_SSE_BUFFER_CODE_UNITS} code units`);
+    }
+    return buffer + decoded;
+}
+export function parseOpenAISseBuffer(buffer, invalid, trailing = false) {
+    try {
+        return trailing ? parseFinalSseChunk(buffer) : parseSseChunk(buffer);
+    }
+    catch {
+        throw invalid(trailing ? "trailing SSE event was malformed" : "SSE event framing was malformed");
+    }
+}

package/esm/openai-stream-metadata.d.ts

@@ -0,0 +1,6 @@
+export declare const MAX_OPENAI_STREAM_IDENTIFIER_BYTES = 512;
+export declare const MAX_OPENAI_STREAM_TOOL_NAME_BYTES = 256;
+export declare const MAX_OPENAI_STREAM_ITEM_TYPE_BYTES = 128;
+export declare const MAX_OPENAI_STREAM_CONTENT_PARTS = 4096;
+export declare function isBoundedOpenAIStreamString(value: unknown, maxBytes: number): value is string;
+//# sourceMappingURL=openai-stream-metadata.d.ts.map

package/esm/openai-stream-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-stream-metadata.d.ts","sourceRoot":"","sources":["../src/openai-stream-metadata.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kCAAkC,MAAM,CAAC;AACtD,eAAO,MAAM,iCAAiC,MAAM,CAAC;AACrD,eAAO,MAAM,iCAAiC,MAAM,CAAC;AACrD,eAAO,MAAM,+BAA+B,OAAQ,CAAC;AAIrD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM,GACf,KAAK,IAAI,MAAM,CAIjB"}

package/esm/openai-stream-metadata.js

@@ -0,0 +1,10 @@
+export const MAX_OPENAI_STREAM_IDENTIFIER_BYTES = 512;
+export const MAX_OPENAI_STREAM_TOOL_NAME_BYTES = 256;
+export const MAX_OPENAI_STREAM_ITEM_TYPE_BYTES = 128;
+export const MAX_OPENAI_STREAM_CONTENT_PARTS = 4_096;
+const encoder = new TextEncoder();
+export function isBoundedOpenAIStreamString(value, maxBytes) {
+    return typeof value === "string" &&
+        value.length > 0 &&
+        encoder.encode(value).byteLength <= maxBytes;
+}

package/esm/openai-tool-input.d.ts

@@ -0,0 +1,10 @@
+export declare const MAX_OPENAI_STREAM_TOOL_ARGUMENT_BYTES = 1048576;
+export declare const MAX_OPENAI_STREAM_TOOL_ARGUMENT_FRAGMENTS = 4096;
+export type OpenAIStreamToolArgumentBudget = {
+    bytes: number;
+    fragments: number;
+};
+export declare function appendOpenAIStreamToolArgument(budget: OpenAIStreamToolArgumentBudget, chunks: string[], fragment: string): "bytes" | "fragments" | undefined;
+export declare function joinOpenAIStreamToolArguments(chunks: readonly string[]): string;
+export declare function isJsonObjectText(value: string): boolean;
+//# sourceMappingURL=openai-tool-input.d.ts.map

package/esm/openai-tool-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-tool-input.d.ts","sourceRoot":"","sources":["../src/openai-tool-input.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qCAAqC,UAAY,CAAC;AAC/D,eAAO,MAAM,yCAAyC,OAAQ,CAAC;AAE/D,MAAM,MAAM,8BAA8B,GAAG;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAIF,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,8BAA8B,EACtC,MAAM,EAAE,MAAM,EAAE,EAChB,QAAQ,EAAE,MAAM,GACf,OAAO,GAAG,WAAW,GAAG,SAAS,CAgBnC;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAE/E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAOvD"}

package/esm/openai-tool-input.js

@@ -0,0 +1,30 @@
+export const MAX_OPENAI_STREAM_TOOL_ARGUMENT_BYTES = 1_048_576;
+export const MAX_OPENAI_STREAM_TOOL_ARGUMENT_FRAGMENTS = 4_096;
+const TOOL_ARGUMENT_ENCODER = new TextEncoder();
+export function appendOpenAIStreamToolArgument(budget, chunks, fragment) {
+    if (budget.fragments >= MAX_OPENAI_STREAM_TOOL_ARGUMENT_FRAGMENTS) {
+        return "fragments";
+    }
+    const fragmentBytes = TOOL_ARGUMENT_ENCODER.encode(fragment).byteLength;
+    if (fragmentBytes > MAX_OPENAI_STREAM_TOOL_ARGUMENT_BYTES - budget.bytes) {
+        return "bytes";
+    }
+    budget.fragments++;
+    budget.bytes += fragmentBytes;
+    if (fragment.length > 0) {
+        chunks.push(fragment);
+    }
+    return undefined;
+}
+export function joinOpenAIStreamToolArguments(chunks) {
+    return chunks.join("");
+}
+export function isJsonObjectText(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
+    }
+    catch {
+        return false;
+    }
+}

package/esm/openai-web-search.d.ts

@@ -0,0 +1,35 @@
+export declare const OPENAI_WEB_SEARCH_SOURCES_INCLUDE = "web_search_call.action.sources";
+export declare const OPENAI_REASONING_ENCRYPTED_CONTENT_INCLUDE = "reasoning.encrypted_content";
+export declare const MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES: number;
+export declare const MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS = 4096;
+export declare const MAX_OPENAI_WEB_SEARCH_TEXT_BYTES: number;
+export declare const MAX_OPENAI_WEB_SEARCH_URL_BYTES: number;
+export declare const MAX_OPENAI_WEB_SEARCH_VALUES = 256;
+type ProviderTool = {
+    type: "provider";
+    name: string;
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+};
+export type OpenAIWebSearchDescriptor = {
+    name: string;
+    requestTool: Record<string, unknown>;
+};
+export type OpenAIWebSearchResult = {
+    id: string;
+    input: string;
+    result: Record<string, unknown>;
+    isError: boolean;
+};
+export declare function resolveOpenAIWebSearchDescriptor(tools: ReadonlyArray<ProviderTool | {
+    type: "function";
+    name: string;
+    description?: string;
+    inputSchema: unknown;
+}> | undefined): OpenAIWebSearchDescriptor | undefined;
+export declare function normalizeOpenAIWebSearchCall(item: Record<string, unknown>, invalid: (issue: string) => Error): OpenAIWebSearchResult;
+export declare function validateOpenAIUrlCitation(value: unknown, invalid: (issue: string) => Error): Record<string, unknown>;
+export declare function createOpenAIRawResponseMetadata(outputItems: Array<Record<string, unknown>>): Record<string, unknown>;
+export declare function readOpenAIRawResponseOutputItems(providerMetadata: Record<string, unknown> | undefined): Array<Record<string, unknown>> | undefined;
+export {};
+//# sourceMappingURL=openai-web-search.d.ts.map

package/esm/openai-web-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-web-search.d.ts","sourceRoot":"","sources":["../src/openai-web-search.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,iCAAiC,mCAAmC,CAAC;AAClF,eAAO,MAAM,0CAA0C,gCAAgC,CAAC;AACxF,eAAO,MAAM,sCAAsC,QAAkB,CAAC;AACtE,eAAO,MAAM,oCAAoC,OAAQ,CAAC;AAC1D,eAAO,MAAM,gCAAgC,QAAY,CAAC;AAC1D,eAAO,MAAM,+BAA+B,QAAY,CAAC;AACzD,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAIhD,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AA2CF,wBAAgB,gCAAgC,CAC9C,KAAK,EACD,aAAa,CACX,YAAY,GACZ;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CACjF,GACC,SAAS,GACZ,yBAAyB,GAAG,SAAS,CA+CvC;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,GAChC,qBAAqB,CAuFvB;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmBzB;AAED,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC1C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMzB;AAoED,wBAAgB,gCAAgC,CAC9C,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GACpD,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CA6C5C"}

package/esm/openai-web-search.js

@@ -0,0 +1,369 @@
+import { readRecord, snapshotJsonValue, stringifyJsonValue } from "veryfront/provider/shared";
+import { isBoundedOpenAIStreamString, MAX_OPENAI_STREAM_IDENTIFIER_BYTES, MAX_OPENAI_STREAM_TOOL_NAME_BYTES, } from "./openai-stream-metadata.js";
+import { isJsonObjectText, MAX_OPENAI_STREAM_TOOL_ARGUMENT_BYTES } from "./openai-tool-input.js";
+const OPENAI_WEB_SEARCH_TYPES = new Set([
+    "web_search",
+    "web_search_2025_08_26",
+    "web_search_preview",
+    "web_search_preview_2025_03_11",
+]);
+export const OPENAI_WEB_SEARCH_SOURCES_INCLUDE = "web_search_call.action.sources";
+export const OPENAI_REASONING_ENCRYPTED_CONTENT_INCLUDE = "reasoning.encrypted_content";
+export const MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES = 8 * 1024 * 1024;
+export const MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS = 4_096;
+export const MAX_OPENAI_WEB_SEARCH_TEXT_BYTES = 64 * 1024;
+export const MAX_OPENAI_WEB_SEARCH_URL_BYTES = 16 * 1024;
+export const MAX_OPENAI_WEB_SEARCH_VALUES = 256;
+const textEncoder = new TextEncoder();
+function hasAsciiControlCharacter(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit <= 0x1f || codeUnit === 0x7f) {
+            return true;
+        }
+    }
+    return false;
+}
+function isHttpUrl(value) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.trim() !== value ||
+        hasAsciiControlCharacter(value) ||
+        textEncoder.encode(value).byteLength > MAX_OPENAI_WEB_SEARCH_URL_BYTES) {
+        return false;
+    }
+    try {
+        const url = new URL(value);
+        return (url.protocol === "http:" || url.protocol === "https:") &&
+            url.hostname.length > 0 &&
+            url.username.length === 0 &&
+            url.password.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function hasOnlyKeys(record, allowed) {
+    return Object.keys(record).every((key) => allowed.has(key));
+}
+function isBoundedText(value, allowEmpty = false) {
+    return typeof value === "string" &&
+        (allowEmpty || value.length > 0) &&
+        textEncoder.encode(value).byteLength <= MAX_OPENAI_WEB_SEARCH_TEXT_BYTES;
+}
+export function resolveOpenAIWebSearchDescriptor(tools) {
+    let resolved;
+    for (const tool of tools ?? []) {
+        if (tool.type !== "provider" ||
+            typeof tool.id !== "string" ||
+            !tool.id.startsWith("openai.")) {
+            continue;
+        }
+        const providerType = tool.id.slice("openai.".length);
+        if (!OPENAI_WEB_SEARCH_TYPES.has(providerType)) {
+            throw new TypeError(`Unsupported OpenAI provider tool: ${tool.id}`);
+        }
+        if (resolved) {
+            throw new TypeError("Only one OpenAI web-search provider tool is supported per request");
+        }
+        if (!isBoundedOpenAIStreamString(tool.name, MAX_OPENAI_STREAM_TOOL_NAME_BYTES)) {
+            throw new TypeError("OpenAI web-search tool name was malformed");
+        }
+        const args = readRecord(tool.args);
+        if (!args ||
+            !hasOnlyKeys(args, new Set(["searchContextSize"])) ||
+            (args.searchContextSize !== undefined &&
+                args.searchContextSize !== "low" &&
+                args.searchContextSize !== "medium" &&
+                args.searchContextSize !== "high")) {
+            throw new TypeError("OpenAI web-search tool arguments were unsupported");
+        }
+        resolved = {
+            name: tool.name,
+            requestTool: {
+                type: providerType,
+                ...(args.searchContextSize !== undefined
+                    ? { search_context_size: args.searchContextSize }
+                    : {}),
+            },
+        };
+    }
+    return resolved;
+}
+export function normalizeOpenAIWebSearchCall(item, invalid) {
+    if (!isBoundedOpenAIStreamString(item.id, MAX_OPENAI_STREAM_IDENTIFIER_BYTES) ||
+        item.type !== "web_search_call" ||
+        (item.status !== "completed" &&
+            item.status !== "failed" &&
+            item.status !== "incomplete")) {
+        throw invalid("web-search output item identity or status was malformed");
+    }
+    const action = readRecord(item.action);
+    if (!action || typeof action.type !== "string") {
+        throw invalid("web-search action was malformed");
+    }
+    let sources;
+    if (action.type === "search") {
+        if (!hasOnlyKeys(action, new Set(["type", "query", "queries", "sources"])) ||
+            (action.query !== undefined && !isBoundedText(action.query, true)) ||
+            (action.queries !== undefined &&
+                (!Array.isArray(action.queries) ||
+                    action.queries.length > MAX_OPENAI_WEB_SEARCH_VALUES ||
+                    action.queries.some((query) => !isBoundedText(query, true))))) {
+            throw invalid("web-search search action was malformed");
+        }
+        if (action.sources !== undefined) {
+            if (!Array.isArray(action.sources) ||
+                action.sources.length > MAX_OPENAI_WEB_SEARCH_VALUES) {
+                throw invalid("web-search sources were malformed");
+            }
+            sources = action.sources.map((source) => {
+                const record = readRecord(source);
+                if (!record ||
+                    !hasOnlyKeys(record, new Set(["type", "url"])) ||
+                    record.type !== "url" ||
+                    !isHttpUrl(record.url)) {
+                    throw invalid("web-search source was malformed");
+                }
+                return record;
+            });
+        }
+    }
+    else if (action.type === "open_page") {
+        if (!hasOnlyKeys(action, new Set(["type", "url"])) ||
+            (action.url !== undefined &&
+                action.url !== null &&
+                !isHttpUrl(action.url))) {
+            throw invalid("web-search open-page action was malformed");
+        }
+    }
+    else if (action.type === "find_in_page") {
+        if (!hasOnlyKeys(action, new Set(["type", "url", "pattern"])) ||
+            !isHttpUrl(action.url) ||
+            !isBoundedText(action.pattern)) {
+            throw invalid("web-search find-in-page action was malformed");
+        }
+    }
+    else {
+        throw invalid("web-search action type was unsupported");
+    }
+    const { sources: _sources, ...invocationAction } = action;
+    const input = stringifyJsonValue(invocationAction);
+    if (textEncoder.encode(input).byteLength >
+        MAX_OPENAI_STREAM_TOOL_ARGUMENT_BYTES) {
+        throw invalid("web-search action exceeded the tool-input limit");
+    }
+    return {
+        id: item.id,
+        input,
+        result: item.status === "completed"
+            ? {
+                status: "completed",
+                ...(sources !== undefined ? { sources } : {}),
+            }
+            : { status: item.status, action },
+        isError: item.status !== "completed",
+    };
+}
+export function validateOpenAIUrlCitation(value, invalid) {
+    const annotation = readRecord(value);
+    if (!annotation ||
+        !hasOnlyKeys(annotation, new Set(["type", "start_index", "end_index", "url", "title"])) ||
+        annotation.type !== "url_citation" ||
+        !Number.isSafeInteger(annotation.start_index) ||
+        annotation.start_index < 0 ||
+        !Number.isSafeInteger(annotation.end_index) ||
+        annotation.end_index <= annotation.start_index ||
+        !isHttpUrl(annotation.url) ||
+        !isBoundedText(annotation.title, true)) {
+        throw invalid("URL citation annotation was malformed");
+    }
+    return annotation;
+}
+export function createOpenAIRawResponseMetadata(outputItems) {
+    return {
+        openai: {
+            rawResponseOutputItems: snapshotOpenAIRawResponseOutputItems(outputItems),
+        },
+    };
+}
+function readOwnOpenAIMetadataValue(providerMetadata) {
+    let descriptor;
+    try {
+        descriptor = Object.getOwnPropertyDescriptor(providerMetadata, "openai");
+    }
+    catch {
+        throw new TypeError("OpenAI provider metadata could not be inspected");
+    }
+    if (descriptor === undefined)
+        return undefined;
+    if (!Object.hasOwn(descriptor, "value") || descriptor.enumerable !== true) {
+        throw new TypeError("OpenAI provider metadata was malformed");
+    }
+    return descriptor.value;
+}
+function readOwnRawOutputItemsValue(openaiMetadata) {
+    if (openaiMetadata === null ||
+        typeof openaiMetadata !== "object" ||
+        Array.isArray(openaiMetadata)) {
+        throw new TypeError("OpenAI raw response metadata was malformed");
+    }
+    let descriptor;
+    try {
+        descriptor = Object.getOwnPropertyDescriptor(openaiMetadata, "rawResponseOutputItems");
+    }
+    catch {
+        throw new TypeError("OpenAI raw response metadata could not be inspected");
+    }
+    if (descriptor === undefined)
+        return undefined;
+    if (!Object.hasOwn(descriptor, "value") || descriptor.enumerable !== true) {
+        throw new TypeError("OpenAI raw response metadata was malformed");
+    }
+    return descriptor.value;
+}
+function snapshotOpenAIRawResponseOutputItems(value) {
+    let snapshot;
+    try {
+        snapshot = snapshotJsonValue(value, {
+            maxBytes: MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES,
+        });
+    }
+    catch (error) {
+        if (error instanceof TypeError &&
+            error.message ===
+                `Provider JSON snapshot exceeded ${MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES} UTF-8 bytes`) {
+            throw new TypeError(`OpenAI raw response metadata exceeded ${MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES} UTF-8 bytes`);
+        }
+        throw new TypeError("OpenAI raw response metadata was not valid bounded JSON");
+    }
+    if (!Array.isArray(snapshot)) {
+        throw new TypeError("OpenAI raw response metadata was malformed");
+    }
+    return snapshot;
+}
+export function readOpenAIRawResponseOutputItems(providerMetadata) {
+    if (!providerMetadata)
+        return undefined;
+    const openaiMetadata = readOwnOpenAIMetadataValue(providerMetadata);
+    if (openaiMetadata === undefined)
+        return undefined;
+    const rawOutputItems = readOwnRawOutputItemsValue(openaiMetadata);
+    if (rawOutputItems === undefined)
+        return undefined;
+    const snapshot = snapshotOpenAIRawResponseOutputItems(rawOutputItems);
+    if (snapshot.length === 0) {
+        throw new TypeError("OpenAI raw response metadata contained no output items");
+    }
+    if (snapshot.length > MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS) {
+        throw new TypeError("OpenAI raw response metadata contained too many output items");
+    }
+    const seenIds = new Set();
+    for (let index = 0; index < snapshot.length; index += 1) {
+        const value = snapshot[index];
+        const item = readRecord(value);
+        if (!item ||
+            !isBoundedOpenAIStreamString(item.id, MAX_OPENAI_STREAM_IDENTIFIER_BYTES) ||
+            (item.type !== "message" &&
+                item.type !== "reasoning" &&
+                item.type !== "function_call" &&
+                item.type !== "web_search_call") ||
+            seenIds.has(item.id)) {
+            throw new TypeError("OpenAI raw response metadata item was malformed");
+        }
+        const validStatus = item.status === undefined ||
+            item.status === "completed" ||
+            item.status === "incomplete" ||
+            (item.type === "web_search_call" && item.status === "failed");
+        if (!validStatus) {
+            throw new TypeError("OpenAI raw response metadata item was malformed");
+        }
+        try {
+            validateRawOutputItem(item);
+        }
+        catch {
+            throw new TypeError("OpenAI raw response metadata item was malformed");
+        }
+        seenIds.add(item.id);
+    }
+    return snapshot;
+}
+function validateRawOutputItem(item) {
+    if (item.type === "web_search_call") {
+        normalizeOpenAIWebSearchCall(item, (issue) => new TypeError(issue));
+        return;
+    }
+    if (item.type === "function_call") {
+        if (!isBoundedOpenAIStreamString(item.call_id, MAX_OPENAI_STREAM_IDENTIFIER_BYTES) ||
+            !isBoundedOpenAIStreamString(item.name, MAX_OPENAI_STREAM_TOOL_NAME_BYTES) ||
+            typeof item.arguments !== "string" ||
+            textEncoder.encode(item.arguments).byteLength >
+                MAX_OPENAI_STREAM_TOOL_ARGUMENT_BYTES ||
+            !isJsonObjectText(item.arguments)) {
+            throw new TypeError("function call was malformed");
+        }
+        return;
+    }
+    if (item.type === "message") {
+        if (item.role !== "assistant" ||
+            !Array.isArray(item.content) ||
+            item.content.length > MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS) {
+            throw new TypeError("message was malformed");
+        }
+        for (const value of item.content) {
+            const part = readRecord(value);
+            if (!part)
+                throw new TypeError("message part was malformed");
+            if (part.type === "output_text") {
+                const annotations = part.annotations ?? [];
+                if (typeof part.text !== "string" ||
+                    !Array.isArray(annotations) ||
+                    annotations.length > MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS) {
+                    throw new TypeError("output text was malformed");
+                }
+                for (const annotation of annotations) {
+                    const citation = validateOpenAIUrlCitation(annotation, (issue) => new TypeError(issue));
+                    if (citation.end_index > part.text.length) {
+                        throw new TypeError("citation exceeded output text");
+                    }
+                }
+            }
+            else if (part.type === "refusal") {
+                if (typeof part.refusal !== "string" ||
+                    part.annotations !== undefined) {
+                    throw new TypeError("refusal was malformed");
+                }
+            }
+            else {
+                throw new TypeError("message part type was unsupported");
+            }
+        }
+        return;
+    }
+    if (item.type === "reasoning") {
+        validateRawReasoningParts(item.summary, "summary_text");
+        validateRawReasoningParts(item.content, "reasoning_text");
+        if (item.encrypted_content !== undefined &&
+            typeof item.encrypted_content !== "string") {
+            throw new TypeError("reasoning signature was malformed");
+        }
+    }
+}
+function validateRawReasoningParts(value, expectedType) {
+    if (value === undefined)
+        return;
+    if (!Array.isArray(value) ||
+        value.length > MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS) {
+        throw new TypeError("reasoning parts were malformed");
+    }
+    for (const rawPart of value) {
+        const part = readRecord(rawPart);
+        if (!part ||
+            part.type !== expectedType ||
+            typeof part.text !== "string" ||
+            (part.id !== undefined &&
+                !isBoundedOpenAIStreamString(part.id, MAX_OPENAI_STREAM_IDENTIFIER_BYTES))) {
+            throw new TypeError("reasoning part was malformed");
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-llm-openai",
-  "version": "0.1.1185",
+  "version": "0.1.1189",
   "description": "Veryfront first-party extension package for ext-llm-openai",
   "keywords": [
     "veryfront",
@@ -27,7 +27,7 @@
   },
   "scripts": {},
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.3.0"
   },
   "publishConfig": {
     "access": "public"
@@ -45,7 +45,7 @@
     "capabilities": []
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1185"
+    "veryfront": "^0.1.1189"
   },
   "type": "module",
   "types": "./esm/index.d.ts",