@openrouter/sdk 0.10.2 → 0.11.2

package/FUNCTIONS.md

@@ -33,7 +33,7 @@ const openRouter = new OpenRouterCore({
 
 async function run() {
   const res = await betaResponsesSend(openRouter, {
-    openResponsesRequest: {},
+    responsesRequest: {},
   });
   if (res.ok) {
     const { value: result } = res;

package/esm/funcs/betaResponsesSend.d.ts

@@ -17,14 +17,14 @@ import { Result } from "../types/fp.js";
  * Creates a streaming or non-streaming response using OpenResponses API format
  */
 export declare function betaResponsesSend(client: OpenRouterCore, request: operations.CreateResponsesRequest & {
-    openResponsesRequest: {
+    responsesRequest: {
         stream?: false;
     };
-}, options?: RequestOptions): APIPromise<Result<models.OpenResponsesNonStreamingResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+}, options?: RequestOptions): APIPromise<Result<models.OpenResponsesResult, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 export declare function betaResponsesSend(client: OpenRouterCore, request: operations.CreateResponsesRequest & {
-    openResponsesRequest: {
+    responsesRequest: {
         stream: true;
     };
-}, options?: RequestOptions): APIPromise<Result<EventStream<models.OpenResponsesStreamEvent>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+}, options?: RequestOptions): APIPromise<Result<EventStream<models.StreamEvents>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 export declare function betaResponsesSend(client: OpenRouterCore, request: operations.CreateResponsesRequest, options?: RequestOptions): APIPromise<Result<operations.CreateResponsesResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=betaResponsesSend.d.ts.map

package/esm/funcs/betaResponsesSend.js

@@ -20,13 +20,11 @@ async function $do(client, request, options) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
-    const body = encodeJSON("body", payload.OpenResponsesRequest, {
-        explode: true,
-    });
+    const body = encodeJSON("body", payload.ResponsesRequest, { explode: true });
     const path = pathToFunc("/responses")();
     const headers = new Headers(compactMap({
         "Content-Type": "application/json",
-        Accept: request?.openResponsesRequest?.stream
+        Accept: request?.responsesRequest?.stream
             ? "text/event-stream"
             : "application/json",
         "HTTP-Referer": encodeSimple("HTTP-Referer", payload["HTTP-Referer"] ?? client._options.httpReferer, { explode: false, charEncoding: "none" }),

package/esm/funcs/call-model.d.ts

@@ -19,7 +19,7 @@ export type { CallModelInput } from '../lib/async-params.js';
  * - `for await (const event of response.getToolStream())` - Stream tool events (incl. preliminary results)
  * - `for await (const toolCall of response.getToolCallsStream())` - Stream structured tool calls
  * - `await response.getToolCalls()` - Get all tool calls from completed response
- * - `for await (const msg of response.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const msg of response.getNewMessagesStream())` - Stream cumulative message snapshots
  * - `for await (const event of response.getFullResponsesStream())` - Stream all events (incl. tool preliminary)
  *
  * All consumption patterns can be used concurrently on the same response.

package/esm/funcs/call-model.js

@@ -14,7 +14,7 @@ import { convertToolsToAPIFormat } from '../lib/tool-executor.js';
  * - `for await (const event of response.getToolStream())` - Stream tool events (incl. preliminary results)
  * - `for await (const toolCall of response.getToolCallsStream())` - Stream structured tool calls
  * - `await response.getToolCalls()` - Get all tool calls from completed response
- * - `for await (const msg of response.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const msg of response.getNewMessagesStream())` - Stream cumulative message snapshots
  * - `for await (const event of response.getFullResponsesStream())` - Stream all events (incl. tool preliminary)
  *
  * All consumption patterns can be used concurrently on the same response.

package/esm/funcs/chatSend.d.ts

@@ -17,14 +17,14 @@ import { Result } from "../types/fp.js";
  * Sends a request for a model response for the given chat conversation. Supports both streaming and non-streaming modes.
  */
 export declare function chatSend(client: OpenRouterCore, request: operations.SendChatCompletionRequestRequest & {
-    chatGenerationParams: {
+    chatRequest: {
         stream?: false;
     };
-}, options?: RequestOptions): APIPromise<Result<models.ChatResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+}, options?: RequestOptions): APIPromise<Result<models.ChatResult, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 export declare function chatSend(client: OpenRouterCore, request: operations.SendChatCompletionRequestRequest & {
-    chatGenerationParams: {
+    chatRequest: {
         stream: true;
     };
-}, options?: RequestOptions): APIPromise<Result<EventStream<models.ChatStreamingResponseChunk>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+}, options?: RequestOptions): APIPromise<Result<EventStream<models.ChatStreamChunk>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 export declare function chatSend(client: OpenRouterCore, request: operations.SendChatCompletionRequestRequest, options?: RequestOptions): APIPromise<Result<operations.SendChatCompletionRequestResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.NotFoundResponseError | errors.RequestTimeoutResponseError | errors.PayloadTooLargeResponseError | errors.UnprocessableEntityResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=chatSend.d.ts.map

package/esm/funcs/chatSend.js

@@ -20,13 +20,11 @@ async function $do(client, request, options) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
-    const body = encodeJSON("body", payload.ChatGenerationParams, {
-        explode: true,
-    });
+    const body = encodeJSON("body", payload.ChatRequest, { explode: true });
     const path = pathToFunc("/chat/completions")();
     const headers = new Headers(compactMap({
         "Content-Type": "application/json",
-        Accept: request?.chatGenerationParams?.stream
+        Accept: request?.chatRequest?.stream
             ? "text/event-stream"
             : "application/json",
         "HTTP-Referer": encodeSimple("HTTP-Referer", payload["HTTP-Referer"] ?? client._options.httpReferer, { explode: false, charEncoding: "none" }),

package/esm/index.d.ts

@@ -1,23 +1,6 @@
-export { fromClaudeMessages, toClaudeMessage } from "./lib/anthropic-compat.js";
-export { hasAsyncFunctions, resolveAsyncFunctions } from "./lib/async-params.js";
-export type { CallModelInput, CallModelInputWithState, ResolvedCallModelInput } from "./lib/async-params.js";
-export { fromChatMessages, toChatMessage } from "./lib/chat-compat.js";
-export { ClaudeContentBlockType, NonClaudeMessageRole } from "./lib/claude-constants.js";
-export { isClaudeStyleMessages } from "./lib/claude-type-guards.js";
 export * from "./lib/config.js";
 export * as files from "./lib/files.js";
 export { HTTPClient } from "./lib/http.js";
 export type { Fetcher, HTTPClientOptions } from "./lib/http.js";
-export { applyNextTurnParamsToRequest, buildNextTurnParamsContext, executeNextTurnParamsFunctions } from "./lib/next-turn-params.js";
-export { finishReasonIs, hasToolCall, isStopConditionMet, maxCost, maxTokensUsed, stepCountIs } from "./lib/stop-conditions.js";
-export { extractUnsupportedContent, getUnsupportedContentSummary, hasUnsupportedContent } from "./lib/stream-transformers.js";
-export { tool } from "./lib/tool.js";
-export { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, isToolResultEvent, isTurnEndEvent, isTurnStartEvent, toolHasApprovalConfigured, ToolType, } from "./lib/tool-types.js";
-export type { ChatStreamEvent, ConversationState, ConversationStatus, ResponseStreamEvent, ResponseStreamEvent as EnhancedResponseStreamEvent, HasApprovalTools, InferToolEvent, InferToolEventsUnion, InferToolInput, InferToolOutput, InferToolOutputsUnion, ManualTool, NextTurnParamsContext, NextTurnParamsFunctions, ParsedToolCall, PartialResponse, StateAccessor, StepResult, StopCondition, StopWhen, Tool, ToolApprovalCheck, ToolExecutionResult, ToolExecutionResultUnion, ToolHasApproval, ToolPreliminaryResultEvent, ToolResultEvent, ToolStreamEvent, ToolWithExecute, ToolWithGenerator, TurnContext, TurnEndEvent, TurnStartEvent, TypedToolCall, TypedToolCallUnion, UnsentToolResult, Warning, } from "./lib/tool-types.js";
-export { buildTurnContext, normalizeInputToArray } from "./lib/turn-context.js";
-export { buildToolExecuteContext, ToolContextStore } from "./lib/tool-context.js";
-export type { ContextInput } from "./lib/tool-context.js";
-export { appendToMessages, createInitialState, createRejectedResult, createUnsentResult, generateConversationId, partitionToolCalls, toolRequiresApproval, updateState, } from "./lib/conversation-state.js";
-export { ToolEventBroadcaster } from "./lib/tool-event-broadcaster.js";
 export * from "./sdk/sdk.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/index.js

@@ -2,31 +2,8 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  * @generated-id: f7d15e20e3c5
  */
-// Message format compatibility helpers
-export { fromClaudeMessages, toClaudeMessage } from "./lib/anthropic-compat.js";
-export { hasAsyncFunctions, resolveAsyncFunctions } from "./lib/async-params.js";
-export { fromChatMessages, toChatMessage } from "./lib/chat-compat.js";
-// Claude constants and type guards
-export { ClaudeContentBlockType, NonClaudeMessageRole } from "./lib/claude-constants.js";
-export { isClaudeStyleMessages } from "./lib/claude-type-guards.js";
 export * from "./lib/config.js";
 export * as files from "./lib/files.js";
 export { HTTPClient } from "./lib/http.js";
-// Next turn params helpers
-export { applyNextTurnParamsToRequest, buildNextTurnParamsContext, executeNextTurnParamsFunctions } from "./lib/next-turn-params.js";
-// Stop condition helpers
-export { finishReasonIs, hasToolCall, isStopConditionMet, maxCost, maxTokensUsed, stepCountIs } from "./lib/stop-conditions.js";
-export { extractUnsupportedContent, getUnsupportedContentSummary, hasUnsupportedContent } from "./lib/stream-transformers.js";
-// Tool creation helpers
-export { tool } from "./lib/tool.js";
-export { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, isToolResultEvent, isTurnEndEvent, isTurnStartEvent, toolHasApprovalConfigured, ToolType, } from "./lib/tool-types.js";
-// Turn context helpers
-export { buildTurnContext, normalizeInputToArray } from "./lib/turn-context.js";
-// Tool context helpers
-export { buildToolExecuteContext, ToolContextStore } from "./lib/tool-context.js";
-// Conversation state helpers
-export { appendToMessages, createInitialState, createRejectedResult, createUnsentResult, generateConversationId, partitionToolCalls, toolRequiresApproval, updateState, } from "./lib/conversation-state.js";
-// Real-time tool event broadcasting
-export { ToolEventBroadcaster } from "./lib/tool-event-broadcaster.js";
 export * from "./sdk/sdk.js";
 //# sourceMappingURL=index.js.map

package/esm/lib/anthropic-compat.d.ts

@@ -26,11 +26,11 @@ import { convertToClaudeMessage } from './stream-transformers.js';
  * });
  * ```
  */
-export declare function fromClaudeMessages(messages: ClaudeMessageParam[]): models.OpenResponsesInputUnion;
+export declare function fromClaudeMessages(messages: ClaudeMessageParam[]): models.InputsUnion;
 /**
  * Convert an OpenResponses response to Anthropic Claude message format.
  *
- * This function transforms OpenResponsesNonStreamingResponse to ClaudeMessage
+ * This function transforms OpenResponsesResult to ClaudeMessage
  * (Anthropic SDK format) for compatibility with code expecting Claude responses.
  *
  * @example

package/esm/lib/anthropic-compat.js

@@ -1,17 +1,17 @@
-import { OpenResponsesEasyInputMessageRoleAssistant, OpenResponsesEasyInputMessageRoleUser, } from '../models/openresponseseasyinputmessage.js';
-import { OpenResponsesInputMessageItemRoleUser, OpenResponsesInputMessageItemRoleDeveloper } from '../models/openresponsesinputmessageitem.js';
+import { EasyInputMessageRoleAssistant, EasyInputMessageRoleUser, } from '../models/easyinputmessage.js';
+import { InputMessageItemRoleUser, InputMessageItemRoleDeveloper } from '../models/inputmessageitem.js';
 import { convertToClaudeMessage } from './stream-transformers.js';
 /**
  * Maps Claude role strings to OpenResponses role types
  */
 function mapClaudeRole(role) {
     if (role === 'user') {
-        return OpenResponsesEasyInputMessageRoleUser.User;
+        return EasyInputMessageRoleUser.User;
     }
-    return OpenResponsesEasyInputMessageRoleAssistant.Assistant;
+    return EasyInputMessageRoleAssistant.Assistant;
 }
 /**
- * Creates a properly typed OpenResponsesEasyInputMessage
+ * Creates a properly typed EasyInputMessage
  */
 function createEasyInputMessage(role, content) {
     return {
@@ -20,7 +20,7 @@ function createEasyInputMessage(role, content) {
     };
 }
 /**
- * Creates a properly typed OpenResponsesFunctionCallOutput
+ * Creates a properly typed FunctionCallOutputItem
  */
 function createFunctionCallOutput(callId, output) {
     return {
@@ -179,8 +179,8 @@ export function fromClaudeMessages(messages) {
                 result.push({
                     type: 'message',
                     role: role === 'user'
-                        ? OpenResponsesInputMessageItemRoleUser.User
-                        : OpenResponsesInputMessageItemRoleDeveloper.Developer,
+                        ? InputMessageItemRoleUser.User
+                        : InputMessageItemRoleDeveloper.Developer,
                     content: contentItems,
                 });
             }
@@ -201,7 +201,7 @@ export function fromClaudeMessages(messages) {
 /**
  * Convert an OpenResponses response to Anthropic Claude message format.
  *
- * This function transforms OpenResponsesNonStreamingResponse to ClaudeMessage
+ * This function transforms OpenResponsesResult to ClaudeMessage
  * (Anthropic SDK format) for compatibility with code expecting Claude responses.
  *
  * @example

package/esm/lib/anthropic-compat.test.js

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { fromClaudeMessages, toClaudeMessage } from "./anthropic-compat.js";
 /**
- * Creates a properly typed mock OpenResponsesNonStreamingResponse for testing.
+ * Creates a properly typed mock OpenResponsesResult for testing.
  * This factory provides all required fields with sensible defaults.
  */
 function createMockResponse(overrides) {
@@ -21,6 +21,7 @@ function createMockResponse(overrides) {
         metadata: null,
         tools: [],
         toolChoice: "auto",
+        instructions: null,
         parallelToolCalls: false,
         ...overrides,
     };

package/esm/lib/async-params.d.ts

@@ -1,6 +1,6 @@
 import type * as models from '../models/index.js';
 import type { ToolContextMapWithShared, ParsedToolCall, StateAccessor, StopWhen, Tool, TurnContext } from './tool-types.js';
-import type { OpenResponsesNonStreamingResponse } from '../models/index.js';
+import type { OpenResponsesResult } from '../models/index.js';
 import type { ContextInput } from './tool-context.js';
 export type { Tool } from './tool-types.js';
 /**
@@ -11,7 +11,7 @@ export type FieldOrAsyncFunction<T> = T | ((context: TurnContext) => T | Promise
  * Base input type for callModel without approval-related fields
  */
 type BaseCallModelInput<TTools extends readonly Tool[] = readonly Tool[], TShared extends Record<string, unknown> = Record<string, never>> = {
-    [K in keyof Omit<models.OpenResponsesRequest, 'stream' | 'tools'>]?: FieldOrAsyncFunction<models.OpenResponsesRequest[K]>;
+    [K in keyof Omit<models.ResponsesRequest, 'stream' | 'tools'>]?: FieldOrAsyncFunction<models.ResponsesRequest[K]>;
 } & {
     tools?: TTools;
     stopWhen?: StopWhen<TTools>;
@@ -31,7 +31,7 @@ type BaseCallModelInput<TTools extends readonly Tool[] = readonly Tool[], TShare
      * Callback invoked at the end of each tool execution turn
      * Receives the turn context and the completed response for that turn
      */
-    onTurnEnd?: (context: TurnContext, response: OpenResponsesNonStreamingResponse) => void | Promise<void>;
+    onTurnEnd?: (context: TurnContext, response: OpenResponsesResult) => void | Promise<void>;
 };
 /**
  * Approval params when state is provided (allows approve/reject)
@@ -73,7 +73,7 @@ export type CallModelInputWithState<TTools extends readonly Tool[] = readonly To
  * Resolved CallModelInput (all functions evaluated to values)
  * This is the type after all async functions have been resolved to their values
  */
-export type ResolvedCallModelInput = Omit<models.OpenResponsesRequest, 'stream' | 'tools'> & {
+export type ResolvedCallModelInput = Omit<models.ResponsesRequest, 'stream' | 'tools'> & {
     tools?: never;
 };
 /**

package/esm/lib/chat-compat.d.ts

@@ -21,11 +21,11 @@ import { extractMessageFromResponse } from "./stream-transformers.js";
  * });
  * ```
  */
-export declare function fromChatMessages(messages: models.Message[]): models.OpenResponsesInputUnion;
+export declare function fromChatMessages(messages: models.ChatMessages[]): models.InputsUnion;
 /**
  * Convert an OpenResponses response to OpenAI chat message format.
  *
- * This function transforms OpenResponsesNonStreamingResponse to AssistantMessage
+ * This function transforms OpenResponsesResult to ChatAssistantMessage
  * (OpenAI chat format) for compatibility with code expecting chat responses.
  *
  * @example

package/esm/lib/chat-compat.js

@@ -1,13 +1,13 @@
-import { OpenResponsesEasyInputMessageRoleUser, OpenResponsesEasyInputMessageRoleSystem, OpenResponsesEasyInputMessageRoleAssistant, OpenResponsesEasyInputMessageRoleDeveloper, } from "../models/openresponseseasyinputmessage.js";
+import { EasyInputMessageRoleUser, EasyInputMessageRoleSystem, EasyInputMessageRoleAssistant, EasyInputMessageRoleDeveloper, } from "../models/easyinputmessage.js";
 import { extractMessageFromResponse } from "./stream-transformers.js";
 /**
- * Type guard for ToolResponseMessage
+ * Type guard for ChatToolMessage
  */
 function isToolResponseMessage(msg) {
     return msg.role === "tool";
 }
 /**
- * Type guard for AssistantMessage
+ * Type guard for ChatAssistantMessage
  */
 function isAssistantMessage(msg) {
     return msg.role === "assistant";
@@ -18,13 +18,13 @@ function isAssistantMessage(msg) {
 function mapChatRole(role) {
     switch (role) {
         case "user":
-            return OpenResponsesEasyInputMessageRoleUser.User;
+            return EasyInputMessageRoleUser.User;
         case "system":
-            return OpenResponsesEasyInputMessageRoleSystem.System;
+            return EasyInputMessageRoleSystem.System;
         case "assistant":
-            return OpenResponsesEasyInputMessageRoleAssistant.Assistant;
+            return EasyInputMessageRoleAssistant.Assistant;
         case "developer":
-            return OpenResponsesEasyInputMessageRoleDeveloper.Developer;
+            return EasyInputMessageRoleDeveloper.Developer;
         default: {
             const exhaustiveCheck = role;
             throw new Error(`Unhandled role type: ${exhaustiveCheck}`);
@@ -90,7 +90,7 @@ export function fromChatMessages(messages) {
 /**
  * Convert an OpenResponses response to OpenAI chat message format.
  *
- * This function transforms OpenResponsesNonStreamingResponse to AssistantMessage
+ * This function transforms OpenResponsesResult to ChatAssistantMessage
  * (OpenAI chat format) for compatibility with code expecting chat responses.
  *
  * @example

package/esm/lib/chat-compat.test.js

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { fromChatMessages, toChatMessage } from "./chat-compat.js";
 /**
- * Creates a properly typed mock OpenResponsesNonStreamingResponse for testing.
+ * Creates a properly typed mock OpenResponsesResult for testing.
  * This factory provides all required fields with sensible defaults.
  */
 function createMockResponse(overrides) {
@@ -21,6 +21,7 @@ function createMockResponse(overrides) {
         metadata: null,
         tools: [],
         toolChoice: "auto",
+        instructions: null,
         parallelToolCalls: false,
         ...overrides,
     };
@@ -168,7 +169,7 @@ describe("fromChatMessages", () => {
 });
 describe("toChatMessage", () => {
     describe("basic message conversion", () => {
-        it("converts response with text output to AssistantMessage", () => {
+        it("converts response with text output to ChatAssistantMessage", () => {
             const response = createMockResponse({
                 id: "resp_123",
                 output: [

package/esm/lib/config.d.ts

@@ -49,8 +49,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.10.2";
-    readonly genVersion: "2.788.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.10.2 2.788.4 1.0.0 @openrouter/sdk";
+    readonly sdkVersion: "0.11.2";
+    readonly genVersion: "2.879.1";
+    readonly userAgent: "speakeasy-sdk/typescript 0.11.2 2.879.1 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -26,8 +26,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.10.2",
-    genVersion: "2.788.4",
-    userAgent: "speakeasy-sdk/typescript 0.10.2 2.788.4 1.0.0 @openrouter/sdk",
+    sdkVersion: "0.11.2",
+    genVersion: "2.879.1",
+    userAgent: "speakeasy-sdk/typescript 0.11.2 2.879.1 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/conversation-state.d.ts

@@ -18,7 +18,7 @@ export declare function updateState<TTools extends readonly Tool[] = readonly To
 /**
  * Append new items to the message history
  */
-export declare function appendToMessages(current: models.OpenResponsesInputUnion, newItems: models.OpenResponsesInputUnion1[]): models.OpenResponsesInputUnion;
+export declare function appendToMessages(current: models.InputsUnion, newItems: models.BaseInputsUnion[]): models.InputsUnion;
 /**
  * Check if a tool call requires approval
  * @param toolCall - The tool call to check
@@ -49,13 +49,13 @@ export declare function createRejectedResult<TTools extends readonly Tool[] = re
 /**
  * Convert unsent tool results to API format for sending to the model
  */
-export declare function unsentResultsToAPIFormat(results: UnsentToolResult[]): models.OpenResponsesFunctionCallOutput[];
+export declare function unsentResultsToAPIFormat(results: UnsentToolResult[]): models.FunctionCallOutputItem[];
 /**
  * Extract text content from a response
  */
-export declare function extractTextFromResponse(response: models.OpenResponsesNonStreamingResponse): string;
+export declare function extractTextFromResponse(response: models.OpenResponsesResult): string;
 /**
  * Extract tool calls from a response
  */
-export declare function extractToolCallsFromResponse<TTools extends readonly Tool[]>(response: models.OpenResponsesNonStreamingResponse): ParsedToolCall<TTools[number]>[];
+export declare function extractToolCallsFromResponse<TTools extends readonly Tool[]>(response: models.OpenResponsesResult): ParsedToolCall<TTools[number]>[];
 //# sourceMappingURL=conversation-state.d.ts.map

package/esm/lib/encodings.js

@@ -349,15 +349,30 @@ export const encodeFormQuery = queryEncoder(encodeForm);
 export const encodeSpaceDelimitedQuery = queryEncoder(encodeSpaceDelimited);
 export const encodePipeDelimitedQuery = queryEncoder(encodePipeDelimited);
 export const encodeDeepObjectQuery = queryEncoder(encodeDeepObject);
+function isBlobLike(val) {
+    if (val instanceof Blob) {
+        return true;
+    }
+    if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+        return false;
+    }
+    const tag = val[Symbol.toStringTag];
+    if (tag !== "Blob" && tag !== "File") {
+        return false;
+    }
+    return "stream" in val && typeof val.stream === "function";
+}
 export function appendForm(fd, key, value, fileName) {
     if (value == null) {
         return;
     }
-    else if (value instanceof Blob && fileName) {
-        fd.append(key, value, fileName);
-    }
-    else if (value instanceof Blob) {
-        fd.append(key, value);
+    else if (isBlobLike(value)) {
+        if (fileName) {
+            fd.append(key, value, fileName);
+        }
+        else {
+            fd.append(key, value);
+        }
     }
     else {
         fd.append(key, String(value));

package/esm/lib/event-streams.d.ts

@@ -1,11 +1,18 @@
+declare global {
+    interface ReadableStream<R = any> {
+        [Symbol.asyncIterator](): AsyncIterableIterator<R>;
+    }
+}
 export type SseMessage<T> = {
     data?: T | undefined;
-    event?: string | undefined;
-    id?: string | undefined;
-    retry?: number | undefined;
+    event?: string | null | undefined;
+    id?: string | null | undefined;
+    retry?: number | null | undefined;
 };
 export declare class EventStream<T> extends ReadableStream<T> {
-    constructor(responseBody: ReadableStream<Uint8Array>, parse: (x: SseMessage<string>) => IteratorResult<T, undefined>);
+    constructor(responseBody: ReadableStream<Uint8Array>, parse: (x: SseMessage<string>) => IteratorResult<T, undefined>, opts?: {
+        dataRequired?: boolean;
+    });
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
 }
 //# sourceMappingURL=event-streams.d.ts.map

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