@openrouter/sdk 0.10.2 → 0.12.0

package/esm/lib/event-streams.js

@@ -3,9 +3,11 @@
  * @generated-id: 3f731f808a79
  */
 export class EventStream extends ReadableStream {
-    constructor(responseBody, parse) {
+    constructor(responseBody, parse, opts) {
         const upstream = responseBody.getReader();
         let buffer = new Uint8Array();
+        const state = { eventId: undefined };
+        const dataRequired = opts?.dataRequired ?? true;
         super({
             async pull(downstream) {
                 try {
@@ -20,7 +22,7 @@ export class EventStream extends ReadableStream {
                         }
                         const message = buffer.slice(0, match.index);
                         buffer = buffer.slice(match.index + match.length);
-                        const item = parseMessage(message, parse);
+                        const item = parseMessage(message, parse, state, dataRequired);
                         if (item && !item.done)
                             return downstream.enqueue(item.value);
                         if (item?.done) {
@@ -74,25 +76,40 @@ function concatBuffer(a, b) {
     c.set(b, a.length);
     return c;
 }
-/** Finds the first (CR,LF,CR,LF) or (CR,CR) or (LF,LF) */
+const CR = 13;
+const LF = 10;
+const BOUNDARIES = [
+    [CR, LF, CR, LF], // \r\n\r\n
+    [CR, LF, CR], // \r\n\r
+    [CR, LF, LF], // \r\n\n
+    [CR, CR, LF], // \r\r\n
+    [LF, CR, LF], // \n\r\n
+    [CR, CR], // \r\r
+    [LF, CR], // \n\r
+    [LF, LF], // \n\n
+];
 function findBoundary(buf) {
     const len = buf.length;
     for (let i = 0; i < len; i++) {
-        if (i <= len - 4
-            && buf[i] === 13 && buf[i + 1] === 10 && buf[i + 2] === 13
-            && buf[i + 3] === 10) {
-            return { index: i, length: 4 };
-        }
-        if (i <= len - 2 && buf[i] === 13 && buf[i + 1] === 13) {
-            return { index: i, length: 2 };
-        }
-        if (i <= len - 2 && buf[i] === 10 && buf[i + 1] === 10) {
-            return { index: i, length: 2 };
+        if (buf[i] !== CR && buf[i] !== LF)
+            continue;
+        for (const boundary of BOUNDARIES) {
+            if (i + boundary.length > len)
+                continue;
+            let match = true;
+            for (let j = 0; j < boundary.length; j++) {
+                if (buf[i + j] !== boundary[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match)
+                return { index: i, length: boundary.length };
         }
     }
     return null;
 }
-function parseMessage(chunk, parse) {
+function parseMessage(chunk, parse, state, dataRequired) {
     const text = new TextDecoder().decode(chunk);
     const lines = text.split(/\r\n|\r|\n/);
     const dataLines = [];
@@ -103,24 +120,29 @@ function parseMessage(chunk, parse) {
             continue;
         ignore = false;
         const i = line.indexOf(":");
-        const field = line.slice(0, i);
-        const value = line[i + 1] === " " ? line.slice(i + 2) : line.slice(i + 1);
+        let field = line;
+        let value = "";
+        if (i > 0) {
+            field = line.slice(0, i);
+            value = line[i + 1] === " " ? line.slice(i + 2) : line.slice(i + 1);
+        }
         if (field === "data")
             dataLines.push(value);
         else if (field === "event")
             ret.event = value;
-        else if (field === "id")
-            ret.id = value;
-        else if (field === "retry") {
-            const n = Number(value);
-            if (!isNaN(n))
-                ret.retry = n;
+        else if (field === "id" && !value.includes("\0"))
+            state.eventId = value;
+        else if (field === "retry" && /^\d+$/.test(value)) {
+            ret.retry = Number(value);
         }
     }
     if (ignore)
         return;
+    ret.id = state.eventId;
     if (dataLines.length)
         ret.data = dataLines.join("\n");
+    else if (dataRequired)
+        return; // skip data-less events when data is required
     return parse(ret);
 }
 //# sourceMappingURL=event-streams.js.map

package/esm/lib/files.d.ts

@@ -10,4 +10,17 @@ export declare function readableStreamToArrayBuffer(readable: ReadableStream<Uin
  * Returns null if the extension is not recognized.
  */
 export declare function getContentTypeFromFileName(fileName: string): string | null;
+/**
+ * Creates a Blob from file content with the given MIME type.
+ *
+ * Node.js Buffers are Uint8Array subclasses that may share a pooled
+ * ArrayBuffer (byteOffset > 0, byteLength < buffer.byteLength). Passing
+ * such a Buffer directly to `new Blob([buf])` can include the entire
+ * underlying pool on some runtimes, producing a Blob with extra bytes
+ * that corrupts multipart uploads.
+ *
+ * Copying into a standalone Uint8Array ensures the Blob receives only the
+ * intended bytes regardless of runtime behaviour.
+ */
+export declare function bytesToBlob(content: Uint8Array<ArrayBufferLike> | ArrayBuffer | Blob | string, contentType: string): Blob;
 //# sourceMappingURL=files.d.ts.map

package/esm/lib/files.js

@@ -71,4 +71,22 @@ export function getContentTypeFromFileName(fileName) {
     };
     return mimeTypes[ext] || null;
 }
+/**
+ * Creates a Blob from file content with the given MIME type.
+ *
+ * Node.js Buffers are Uint8Array subclasses that may share a pooled
+ * ArrayBuffer (byteOffset > 0, byteLength < buffer.byteLength). Passing
+ * such a Buffer directly to `new Blob([buf])` can include the entire
+ * underlying pool on some runtimes, producing a Blob with extra bytes
+ * that corrupts multipart uploads.
+ *
+ * Copying into a standalone Uint8Array ensures the Blob receives only the
+ * intended bytes regardless of runtime behaviour.
+ */
+export function bytesToBlob(content, contentType) {
+    if (content instanceof Uint8Array) {
+        return new Blob([new Uint8Array(content)], { type: contentType });
+    }
+    return new Blob([content], { type: contentType });
+}
 //# sourceMappingURL=files.js.map

package/esm/lib/matchers.js

@@ -122,7 +122,6 @@ export function match(...matchers) {
                 raw = body;
                 break;
             default:
-                encoding;
                 throw new Error(`Unsupported response type: ${encoding}`);
         }
         if (matcher.enc === "fail") {

package/esm/lib/model-result.d.ts

@@ -27,7 +27,7 @@ export interface GetResponseOptions<TTools extends readonly Tool[], TShared exte
     /** Callback invoked at the start of each tool execution turn */
     onTurnStart?: (context: TurnContext) => void | Promise<void>;
     /** Callback invoked at the end of each tool execution turn */
-    onTurnEnd?: (context: TurnContext, response: models.OpenResponsesNonStreamingResponse) => void | Promise<void>;
+    onTurnEnd?: (context: TurnContext, response: models.OpenResponsesResult) => void | Promise<void>;
 }
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
@@ -36,7 +36,7 @@ export interface GetResponseOptions<TTools extends readonly Tool[], TShared exte
  * - `await result.getText()` - Get just the text
  * - `await result.getResponse()` - Get the full response object
  * - `for await (const delta of result.getTextStream())` - Stream text deltas
- * - `for await (const msg of result.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const msg of result.getNewMessagesStream())` - Stream cumulative message snapshots
  * - `for await (const event of result.getFullResponsesStream())` - Stream all response events
  *
  * For message format conversion, use the helper functions:
@@ -203,11 +203,6 @@ export declare class ModelResult<TTools extends readonly Tool[], TShared extends
     /**
      * Make a follow-up API request with tool results.
      * Uses streaming and pipes events through the turn broadcaster when available.
-     *
-     * @param currentResponse - The response that contained tool calls
-     * @param toolResults - The results from executing those tools
-     * @param turnNumber - The turn number for this follow-up request
-     * @returns The new response from the API
      */
     private makeFollowupRequest;
     /**
@@ -270,9 +265,9 @@ export declare class ModelResult<TTools extends readonly Tool[], TShared extends
     /**
      * Get the complete response object including usage information.
      * This will consume the stream until completion and execute any tools.
-     * Returns the full OpenResponsesNonStreamingResponse with usage data (inputTokens, outputTokens, cachedTokens, etc.)
+     * Returns the full OpenResponsesResult with usage data (inputTokens, outputTokens, cachedTokens, etc.)
      */
-    getResponse(): Promise<models.OpenResponsesNonStreamingResponse>;
+    getResponse(): Promise<models.OpenResponsesResult>;
     /**
      * Stream all response events as they arrive across all turns.
      * Multiple consumers can iterate over this stream concurrently.
@@ -305,13 +300,13 @@ export declare class ModelResult<TTools extends readonly Tool[], TShared extends
      * while `getItemsStream()` streams all output item types (messages, function_calls,
      * reasoning, etc.) with cumulative updates.
      *
-     * Stream incremental message updates as content is added in responses format.
+     * Stream cumulative message snapshots as content is added in responses format.
      * Each iteration yields an updated version of the message with new content.
-     * Also yields function_call items and OpenResponsesFunctionCallOutput after tool execution completes.
-     * Returns ResponsesOutputMessage, ResponsesOutputItemFunctionCall, or OpenResponsesFunctionCallOutput
+     * Also yields function_call items and FunctionCallOutputItem after tool execution completes.
+     * Returns OutputMessage, OutputFunctionCallItem, or FunctionCallOutputItem
      * compatible with OpenAI Responses API format.
      */
-    getNewMessagesStream(): AsyncIterableIterator<models.ResponsesOutputMessage | models.OpenResponsesFunctionCallOutput | models.ResponsesOutputItemFunctionCall>;
+    getNewMessagesStream(): AsyncIterableIterator<models.OutputMessage | models.FunctionCallOutputItem | models.OutputFunctionCallItem>;
     /**
      * Stream only reasoning deltas as they arrive from all turns.
      * This filters the full event stream to only yield reasoning content,

package/esm/lib/model-result.js

@@ -4,12 +4,12 @@ import { betaResponsesSend } from '../funcs/betaResponsesSend.js';
 import { hasAsyncFunctions, resolveAsyncFunctions, } from './async-params.js';
 import { appendToMessages, createInitialState, createRejectedResult, createUnsentResult, extractTextFromResponse as extractTextFromResponseState, partitionToolCalls, unsentResultsToAPIFormat, updateState, } from './conversation-state.js';
 import { ReusableReadableStream } from './reusable-stream.js';
-import { buildItemsStream, buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from './stream-transformers.js';
+import { buildItemsStream, buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, itemsStreamHandlers, streamTerminationEvents, } from './stream-transformers.js';
 import { executeTool } from './tool-executor.js';
 import { executeNextTurnParamsFunctions, applyNextTurnParamsToRequest } from './next-turn-params.js';
-import { hasExecuteFunction } from './tool-types.js';
+import { hasExecuteFunction, isToolCallOutputEvent } from './tool-types.js';
 import { isStopConditionMet, stepCountIs } from './stop-conditions.js';
-import { isOutputMessage, isFunctionCallItem, isReasoningOutputItem, isWebSearchCallOutputItem, isFileSearchCallOutputItem, isImageGenerationCallOutputItem, isResponseCompletedEvent, isResponseFailedEvent, isResponseIncompleteEvent, isOutputTextDeltaEvent, isReasoningDeltaEvent, hasTypeProperty, } from './stream-type-guards.js';
+import { isFunctionCallItem, isResponseCompletedEvent, isResponseFailedEvent, isResponseIncompleteEvent, isOutputTextDeltaEvent, isReasoningDeltaEvent, hasTypeProperty, } from './stream-type-guards.js';
 /**
  * Default maximum number of tool execution steps if no stopWhen is specified.
  * This prevents infinite loops in tool execution.
@@ -39,7 +39,7 @@ function isEventStream(value) {
  * - `await result.getText()` - Get just the text
  * - `await result.getResponse()` - Get the full response object
  * - `for await (const delta of result.getTextStream())` - Stream text deltas
- * - `for await (const msg of result.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const msg of result.getNewMessagesStream())` - Stream cumulative message snapshots
  * - `for await (const event of result.getFullResponsesStream())` - Stream all response events
  *
  * For message format conversion, use the helper functions:
@@ -503,11 +503,17 @@ export class ModelResult {
                     ? settled.reason.message
                     : String(settled.reason);
                 this.broadcastToolResult(originalToolCall.id, { error: errorMessage });
-                toolResults.push({
+                const rejectedOutput = {
                     type: 'function_call_output',
                     id: `output_${originalToolCall.id}`,
                     callId: originalToolCall.id,
                     output: JSON.stringify({ error: errorMessage }),
+                };
+                toolResults.push(rejectedOutput);
+                this.turnBroadcaster?.push({
+                    type: 'tool.call_output',
+                    output: rejectedOutput,
+                    timestamp: Date.now(),
                 });
                 continue;
             }
@@ -516,19 +522,30 @@ export class ModelResult {
                 continue;
             if (value.type === 'parse_error') {
                 toolResults.push(value.output);
+                this.turnBroadcaster?.push({
+                    type: 'tool.call_output',
+                    output: value.output,
+                    timestamp: Date.now(),
+                });
                 continue;
             }
             const toolResult = (value.result.error
                 ? { error: value.result.error.message }
                 : value.result.result);
             this.broadcastToolResult(value.toolCall.id, toolResult, value.preliminaryResultsForCall.length > 0 ? value.preliminaryResultsForCall : undefined);
-            toolResults.push({
+            const executedOutput = {
                 type: 'function_call_output',
                 id: `output_${value.toolCall.id}`,
                 callId: value.toolCall.id,
                 output: value.result.error
                     ? JSON.stringify({ error: value.result.error.message })
                     : JSON.stringify(value.result.result),
+            };
+            toolResults.push(executedOutput);
+            this.turnBroadcaster?.push({
+                type: 'tool.call_output',
+                output: executedOutput,
+                timestamp: Date.now(),
             });
         }
         return toolResults;
@@ -570,14 +587,8 @@ export class ModelResult {
     /**
      * Make a follow-up API request with tool results.
      * Uses streaming and pipes events through the turn broadcaster when available.
-     *
-     * @param currentResponse - The response that contained tool calls
-     * @param toolResults - The results from executing those tools
-     * @param turnNumber - The turn number for this follow-up request
-     * @returns The new response from the API
      */
     async makeFollowupRequest(currentResponse, toolResults, turnNumber) {
-        // Build new input preserving original conversation + tool results
         const originalInput = this.resolvedRequest?.input;
         const normalizedOriginalInput = Array.isArray(originalInput)
             ? originalInput
@@ -603,7 +614,7 @@ export class ModelResult {
             ...this.resolvedRequest,
             stream: true,
         };
-        const newResult = await betaResponsesSend(this.options.client, { openResponsesRequest: newRequest }, this.options.options);
+        const newResult = await betaResponsesSend(this.options.client, { responsesRequest: newRequest }, this.options.options);
         if (!newResult.ok) {
             throw newResult.error;
         }
@@ -768,7 +779,7 @@ export class ModelResult {
             // Force stream mode for initial request
             const request = this.resolvedRequest;
             // Make the API request
-            const apiResult = await betaResponsesSend(this.options.client, { openResponsesRequest: request }, this.options.options);
+            const apiResult = await betaResponsesSend(this.options.client, { responsesRequest: request }, this.options.options);
             if (!apiResult.ok) {
                 throw apiResult.error;
             }
@@ -892,7 +903,7 @@ export class ModelResult {
         };
         this.resolvedRequest = request;
         // Make the API request
-        const apiResult = await betaResponsesSend(this.options.client, { openResponsesRequest: request }, this.options.options);
+        const apiResult = await betaResponsesSend(this.options.client, { responsesRequest: request }, this.options.options);
         if (!apiResult.ok) {
             throw apiResult.error;
         }
@@ -1021,7 +1032,7 @@ export class ModelResult {
     /**
      * Get the complete response object including usage information.
      * This will consume the stream until completion and execute any tools.
-     * Returns the full OpenResponsesNonStreamingResponse with usage data (inputTokens, outputTokens, cachedTokens, etc.)
+     * Returns the full OpenResponsesResult with usage data (inputTokens, outputTokens, cachedTokens, etc.)
      */
     async getResponse() {
         await this.executeToolsIfNeeded();
@@ -1103,39 +1114,43 @@ export class ModelResult {
             if (!this.reusableStream && !this.finalResponse) {
                 throw new Error('Stream not initialized');
             }
-            // Stream all items from the API response cumulatively
-            if (this.reusableStream) {
-                yield* buildItemsStream(this.reusableStream);
+            // No tools — stream single turn directly (no broadcaster needed)
+            if (!this.options.tools?.length) {
+                if (this.reusableStream) {
+                    yield* buildItemsStream(this.reusableStream);
+                }
+                return;
             }
-            // Execute tools if needed
-            await this.executeToolsIfNeeded();
-            // Yield function calls and outputs for each tool round
-            for (const round of this.allToolExecutionRounds) {
-                // Round 0's function_calls already yielded via buildItemsStream
-                if (round.round > 0) {
-                    for (const item of round.response.output) {
-                        if (isFunctionCallItem(item)) {
-                            yield item;
-                        }
-                    }
+            // Use turnBroadcaster (same pattern as getTextStream/getFullResponsesStream).
+            // executeToolsIfNeeded() drives tool execution in the background while we
+            // passively consume events from the broadcaster in real-time.
+            const { consumer, executionPromise } = this.startTurnBroadcasterExecution();
+            const itemsInProgress = new Map();
+            for await (const event of consumer) {
+                // Tool call outputs → yield directly as function_call_output items
+                if (isToolCallOutputEvent(event)) {
+                    yield event.output;
+                    continue;
                 }
-                for (const toolResult of round.toolResults) {
-                    yield toolResult;
+                // Stream termination → reset items map for next turn
+                if ('type' in event && streamTerminationEvents.has(event.type)) {
+                    itemsInProgress.clear();
                 }
-            }
-            // If tools were executed, yield all items from the final response
-            if (this.finalResponse && this.allToolExecutionRounds.length > 0) {
-                for (const item of this.finalResponse.output) {
-                    if (isOutputMessage(item) ||
-                        isFunctionCallItem(item) ||
-                        isReasoningOutputItem(item) ||
-                        isWebSearchCallOutputItem(item) ||
-                        isFileSearchCallOutputItem(item) ||
-                        isImageGenerationCallOutputItem(item)) {
-                        yield item;
+                // API stream events → dispatch through item handlers
+                // Cast is necessary: TypeScript cannot narrow a union via Record key lookup,
+                // but `event.type in itemsStreamHandlers` guarantees the event is an
+                // StreamEvents whose type matches a handler key.
+                if ('type' in event && event.type in itemsStreamHandlers) {
+                    const handler = itemsStreamHandlers[event.type];
+                    if (handler) {
+                        const result = handler(event, itemsInProgress);
+                        if (result) {
+                            yield result;
+                        }
                     }
                 }
             }
+            await executionPromise;
         }.call(this);
     }
     /**
@@ -1143,10 +1158,10 @@ export class ModelResult {
      * while `getItemsStream()` streams all output item types (messages, function_calls,
      * reasoning, etc.) with cumulative updates.
      *
-     * Stream incremental message updates as content is added in responses format.
+     * Stream cumulative message snapshots as content is added in responses format.
      * Each iteration yields an updated version of the message with new content.
-     * Also yields function_call items and OpenResponsesFunctionCallOutput after tool execution completes.
-     * Returns ResponsesOutputMessage, ResponsesOutputItemFunctionCall, or OpenResponsesFunctionCallOutput
+     * Also yields function_call items and FunctionCallOutputItem after tool execution completes.
+     * Returns OutputMessage, OutputFunctionCallItem, or FunctionCallOutputItem
      * compatible with OpenAI Responses API format.
      */
     getNewMessagesStream() {

package/esm/lib/next-turn-params.d.ts

@@ -4,10 +4,10 @@ import type { NextTurnParamsContext, ParsedToolCall, Tool } from './tool-types.j
  * Build a NextTurnParamsContext from the current request
  * Extracts relevant fields that can be modified by nextTurnParams functions
  *
- * @param request - The current OpenResponsesRequest
+ * @param request - The current ResponsesRequest
  * @returns Context object with current parameter values
  */
-export declare function buildNextTurnParamsContext(request: models.OpenResponsesRequest): NextTurnParamsContext;
+export declare function buildNextTurnParamsContext(request: models.ResponsesRequest): NextTurnParamsContext;
 /**
  * Execute nextTurnParams functions for all called tools
  * Composes functions when multiple tools modify the same parameter
@@ -17,7 +17,7 @@ export declare function buildNextTurnParamsContext(request: models.OpenResponses
  * @param currentRequest - The current request
  * @returns Object with computed parameter values
  */
-export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall<Tool>[], tools: readonly Tool[], currentRequest: models.OpenResponsesRequest): Promise<Partial<NextTurnParamsContext>>;
+export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall<Tool>[], tools: readonly Tool[], currentRequest: models.ResponsesRequest): Promise<Partial<NextTurnParamsContext>>;
 /**
  * Apply computed nextTurnParams to the current request
  * Returns a new request object with updated parameters
@@ -26,5 +26,5 @@ export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall
  * @param computedParams - Computed parameter values from nextTurnParams functions
  * @returns New request with updated parameters
  */
-export declare function applyNextTurnParamsToRequest(request: models.OpenResponsesRequest, computedParams: Partial<NextTurnParamsContext>): models.OpenResponsesRequest;
+export declare function applyNextTurnParamsToRequest(request: models.ResponsesRequest, computedParams: Partial<NextTurnParamsContext>): models.ResponsesRequest;
 //# sourceMappingURL=next-turn-params.d.ts.map

package/esm/lib/next-turn-params.js

@@ -8,7 +8,7 @@ function isRecord(value) {
  * Build a NextTurnParamsContext from the current request
  * Extracts relevant fields that can be modified by nextTurnParams functions
  *
- * @param request - The current OpenResponsesRequest
+ * @param request - The current ResponsesRequest
  * @returns Context object with current parameter values
  */
 export function buildNextTurnParamsContext(request) {
@@ -121,9 +121,15 @@ function setNextTurnParam(target, key, value) {
  * @returns New request with updated parameters
  */
 export function applyNextTurnParamsToRequest(request, computedParams) {
+    // Strip null values to undefined so they're compatible with ResponsesRequest
+    // fields that may be typed as `number | undefined` (without null)
+    const sanitized = {};
+    for (const [key, value] of Object.entries(computedParams)) {
+        sanitized[key] = value === null ? undefined : value;
+    }
     return {
         ...request,
-        ...computedParams,
+        ...sanitized,
     };
 }
 //# sourceMappingURL=next-turn-params.js.map

package/esm/lib/sdks.js

@@ -67,12 +67,16 @@ export class ClientSDK {
         if (!base) {
             return ERR(new InvalidRequestError("No base URL provided for operation"));
         }
-        const reqURL = new URL(base);
-        const inputURL = new URL(path, reqURL);
+        const baseURL = new URL(base);
+        let reqURL;
         if (path) {
-            reqURL.pathname += reqURL.pathname.endsWith("/") ? "" : "/";
-            reqURL.pathname += inputURL.pathname.replace(/^\/+/, "");
+            baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
+            reqURL = new URL(path, baseURL);
         }
+        else {
+            reqURL = baseURL;
+        }
+        reqURL.hash = "";
         let finalQuery = query || "";
         const secQuery = [];
         for (const [k, v] of Object.entries(security?.queryParams || {})) {
@@ -186,8 +190,8 @@ export class ClientSDK {
     }
 }
 _ClientSDK_httpClient = new WeakMap(), _ClientSDK_hooks = new WeakMap(), _ClientSDK_logger = new WeakMap();
-const jsonLikeContentTypeRE = /(application|text)\/.*?\+*json.*/;
-const jsonlLikeContentTypeRE = /(application|text)\/(.*?\+*\bjsonl\b.*|.*?\+*\bx-ndjson\b.*)/;
+const jsonLikeContentTypeRE = /^(application|text)\/([^+]+\+)*json.*/;
+const jsonlLikeContentTypeRE = /^(application|text)\/([^+]+\+)*(jsonl|x-ndjson)\b.*/;
 async function logRequest(logger, req) {
     if (!logger) {
         return;

package/esm/lib/security.d.ts

@@ -77,7 +77,7 @@ type SecurityInputCustom = {
 };
 export type SecurityInput = SecurityInputBasic | SecurityInputBearer | SecurityInputAPIKey | SecurityInputOAuth2 | SecurityInputOAuth2ClientCredentials | SecurityInputOAuth2PasswordCredentials | SecurityInputOIDC | SecurityInputCustom;
 export declare function resolveSecurity(...options: SecurityInput[][]): SecurityState | null;
-export declare function resolveGlobalSecurity(security: Partial<models.Security> | null | undefined): SecurityState | null;
+export declare function resolveGlobalSecurity(security: Partial<models.Security> | null | undefined, allowedFields?: number[]): SecurityState | null;
 export declare function extractSecurity<T extends string | Record<string, unknown>>(sec: T | (() => Promise<T>) | undefined): Promise<T | undefined>;
 export {};
 //# sourceMappingURL=security.d.ts.map

package/esm/lib/security.js

@@ -96,8 +96,7 @@ export function resolveSecurity(...options) {
                 applyBearer(state, spec);
                 break;
             default:
-                spec;
-                throw SecurityError.unrecognizedType(type);
+                throw SecurityError.unrecognizedType((spec, type));
         }
     });
     return state;
@@ -120,14 +119,25 @@ function applyBearer(state, spec) {
         state.headers[spec.fieldName] = value;
     }
 }
-export function resolveGlobalSecurity(security) {
-    return resolveSecurity([
-        {
-            fieldName: "Authorization",
-            type: "http:bearer",
-            value: security?.apiKey ?? env().OPENROUTER_API_KEY,
-        },
-    ]);
+export function resolveGlobalSecurity(security, allowedFields) {
+    let inputs = [
+        [
+            {
+                fieldName: "Authorization",
+                type: "http:bearer",
+                value: security?.apiKey ?? env().OPENROUTER_API_KEY,
+            },
+        ],
+    ];
+    if (allowedFields) {
+        inputs = allowedFields.map((i) => {
+            if (i < 0 || i >= inputs.length) {
+                throw new RangeError(`invalid allowedFields index ${i}`);
+            }
+            return inputs[i];
+        });
+    }
+    return resolveSecurity(...inputs);
 }
 export async function extractSecurity(sec) {
     if (sec == null) {