@openrouter/sdk 1.3.21 → 1.3.23

package/esm/funcs/workspacesListMembers.js

@@ -9,8 +9,8 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as operations from "../models/operations/index.js";
+import { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { ListWorkspaceMembersRequest$outboundSchema as operations_ListWorkspaceMembersRequest$outboundSchema, ListWorkspaceMembersResponse$inboundSchema as operations_ListWorkspaceMembersResponse$inboundSchema } from "../models/operations/listworkspacemembers.js";
 import { APIPromise } from "../types/async.js";
 import { createPageIterator, haltIterator, } from "../types/operations.js";
 /**
@@ -23,7 +23,7 @@ export function workspacesListMembers(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListWorkspaceMembersRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListWorkspaceMembersRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [haltIterator(parsed), { status: "invalid" }];
     }
@@ -99,9 +99,9 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result, raw] = await M.match(M.json(200, operations.ListWorkspaceMembersResponse$inboundSchema, {
+    const [result, raw] = await M.match(M.json(200, operations_ListWorkspaceMembersResponse$inboundSchema, {
         key: "Result",
-    }), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    }), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$inboundSchema), M.jsonErr(500, errors_InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [haltIterator(result), {
                 status: "complete",

package/esm/funcs/workspacesSetBudget.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { BadRequestResponseError$inboundSchema as errors_BadRequestResponseError$inboundSchema } from "../models/errors/badrequestresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { UpsertWorkspaceBudgetResponse$inboundSchema as models_UpsertWorkspaceBudgetResponse$inboundSchema } from "../models/upsertworkspacebudgetresponse.js";
+import { UpsertWorkspaceBudgetRequest$outboundSchema as operations_UpsertWorkspaceBudgetRequest$outboundSchema } from "../models/operations/upsertworkspacebudget.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Create or update a workspace budget
@@ -23,7 +23,7 @@ export function workspacesSetBudget(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.UpsertWorkspaceBudgetRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_UpsertWorkspaceBudgetRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -101,7 +101,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.UpsertWorkspaceBudgetResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_UpsertWorkspaceBudgetResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$inboundSchema), M.jsonErr(500, errors_InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/workspacesUpdate.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { BadRequestResponseError$inboundSchema as errors_BadRequestResponseError$inboundSchema } from "../models/errors/badrequestresponseerror.js"; import { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { UpdateWorkspaceResponse$inboundSchema as models_UpdateWorkspaceResponse$inboundSchema } from "../models/updateworkspaceresponse.js";
+import { UpdateWorkspaceRequest$outboundSchema as operations_UpdateWorkspaceRequest$outboundSchema } from "../models/operations/updateworkspace.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Update a workspace
@@ -23,7 +23,7 @@ export function workspacesUpdate(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.UpdateWorkspaceRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_UpdateWorkspaceRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -97,7 +97,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.UpdateWorkspaceResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_UpdateWorkspaceResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$inboundSchema), M.jsonErr(500, errors_InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

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

@@ -1,4 +1,4 @@
-import type * as models from '../models/index.js';
+import type { InputsUnion } from '../models/inputsunion.js';
 import type { ClaudeMessageParam } from '../models/claude-message.js';
 import { convertToClaudeMessage } from './stream-transformers.js';
 /**
@@ -26,7 +26,7 @@ import { convertToClaudeMessage } from './stream-transformers.js';
  * });
  * ```
  */
-export declare function fromClaudeMessages(messages: ClaudeMessageParam[]): models.InputsUnion;
+export declare function fromClaudeMessages(messages: ClaudeMessageParam[]): InputsUnion;
 /**
  * Convert an OpenResponses response to Anthropic Claude message format.
  *

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

@@ -1,6 +1,6 @@
-import type * as models from '../models/index.js';
+import type { OpenResponsesResult } from '../models/openresponsesresult.js';
+import type { ResponsesRequest } from '../models/responsesrequest.js';
 import type { ToolContextMapWithShared, ParsedToolCall, StateAccessor, StopWhen, Tool, TurnContext } from './tool-types.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.ResponsesRequest, 'stream' | 'tools'>]?: FieldOrAsyncFunction<models.ResponsesRequest[K]>;
+    [K in keyof Omit<ResponsesRequest, 'stream' | 'tools'>]?: FieldOrAsyncFunction<ResponsesRequest[K]>;
 } & {
     tools?: TTools;
     stopWhen?: StopWhen<TTools>;
@@ -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.ResponsesRequest, 'stream' | 'tools'> & {
+export type ResolvedCallModelInput = Omit<ResponsesRequest, 'stream' | 'tools'> & {
     tools?: never;
 };
 /**

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

@@ -1,4 +1,5 @@
-import type * as models from "../models/index.js";
+import type { ChatMessages } from "../models/chatmessages.js";
+import type { InputsUnion } from "../models/inputsunion.js";
 import { extractMessageFromResponse } from "./stream-transformers.js";
 /**
  * Convert OpenAI chat-style messages to OpenResponses input format.
@@ -21,7 +22,7 @@ import { extractMessageFromResponse } from "./stream-transformers.js";
  * });
  * ```
  */
-export declare function fromChatMessages(messages: models.ChatMessages[]): models.InputsUnion;
+export declare function fromChatMessages(messages: ChatMessages[]): InputsUnion;
 /**
  * Convert an OpenResponses response to OpenAI chat message format.
  *

package/esm/lib/config.d.ts

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

package/esm/lib/config.js

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

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

@@ -1,4 +1,6 @@
-import type * as models from '../models/index.js';
+import type { FunctionCallOutputItem } from '../models/functioncalloutputitem.js';
+import type { InputsUnion, InputsUnion1 } from '../models/inputsunion.js';
+import type { OpenResponsesResult } from '../models/openresponsesresult.js';
 import type { ConversationState, ParsedToolCall, Tool, TurnContext, UnsentToolResult } from './tool-types.js';
 /**
  * Generate a unique ID for a conversation
@@ -18,7 +20,7 @@ export declare function updateState<TTools extends readonly Tool[] = readonly To
 /**
  * Append new items to the message history
  */
-export declare function appendToMessages(current: models.InputsUnion, newItems: models.InputsUnion1[]): models.InputsUnion;
+export declare function appendToMessages(current: InputsUnion, newItems: InputsUnion1[]): InputsUnion;
 /**
  * Check if a tool call requires approval
  * @param toolCall - The tool call to check
@@ -49,13 +51,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.FunctionCallOutputItem[];
+export declare function unsentResultsToAPIFormat(results: UnsentToolResult[]): FunctionCallOutputItem[];
 /**
  * Extract text content from a response
  */
-export declare function extractTextFromResponse(response: models.OpenResponsesResult): string;
+export declare function extractTextFromResponse(response: OpenResponsesResult): string;
 /**
  * Extract tool calls from a response
  */
-export declare function extractToolCallsFromResponse<TTools extends readonly Tool[]>(response: models.OpenResponsesResult): ParsedToolCall<TTools[number]>[];
+export declare function extractToolCallsFromResponse<TTools extends readonly Tool[]>(response: OpenResponsesResult): ParsedToolCall<TTools[number]>[];
 //# sourceMappingURL=conversation-state.d.ts.map

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

@@ -1,5 +1,8 @@
 import type { OpenRouterCore } from '../core.js';
-import type * as models from '../models/index.js';
+import type { FunctionCallOutputItem } from '../models/functioncalloutputitem.js';
+import type { OpenResponsesResult } from '../models/openresponsesresult.js';
+import type { OutputFunctionCallItem } from '../models/outputfunctioncallitem.js';
+import type { OutputMessage } from '../models/outputmessage.js';
 import type { CallModelInput } from './async-params.js';
 import type { RequestOptions } from './sdks.js';
 import type { $ZodObject, $ZodShape } from 'zod/v4/core';
@@ -27,7 +30,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.OpenResponsesResult) => void | Promise<void>;
+    onTurnEnd?: (context: TurnContext, response: OpenResponsesResult) => void | Promise<void>;
 }
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
@@ -267,7 +270,7 @@ export declare class ModelResult<TTools extends readonly Tool[], TShared extends
      * This will consume the stream until completion and execute any tools.
      * Returns the full OpenResponsesResult with usage data (inputTokens, outputTokens, cachedTokens, etc.)
      */
-    getResponse(): Promise<models.OpenResponsesResult>;
+    getResponse(): Promise<OpenResponsesResult>;
     /**
      * Stream all response events as they arrive across all turns.
      * Multiple consumers can iterate over this stream concurrently.
@@ -306,7 +309,7 @@ export declare class ModelResult<TTools extends readonly Tool[], TShared extends
      * Returns OutputMessage, OutputFunctionCallItem, or FunctionCallOutputItem
      * compatible with OpenAI Responses API format.
      */
-    getNewMessagesStream(): AsyncIterableIterator<models.OutputMessage | models.FunctionCallOutputItem | models.OutputFunctionCallItem>;
+    getNewMessagesStream(): AsyncIterableIterator<OutputMessage | FunctionCallOutputItem | 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/next-turn-params.d.ts

@@ -1,4 +1,4 @@
-import type * as models from '../models/index.js';
+import type { ResponsesRequest } from '../models/responsesrequest.js';
 import type { NextTurnParamsContext, ParsedToolCall, Tool } from './tool-types.js';
 /**
  * Build a NextTurnParamsContext from the current request
@@ -7,7 +7,7 @@ import type { NextTurnParamsContext, ParsedToolCall, Tool } from './tool-types.j
  * @param request - The current ResponsesRequest
  * @returns Context object with current parameter values
  */
-export declare function buildNextTurnParamsContext(request: models.ResponsesRequest): NextTurnParamsContext;
+export declare function buildNextTurnParamsContext(request: 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.ResponsesRequ
  * @param currentRequest - The current request
  * @returns Object with computed parameter values
  */
-export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall<Tool>[], tools: readonly Tool[], currentRequest: models.ResponsesRequest): Promise<Partial<NextTurnParamsContext>>;
+export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall<Tool>[], tools: readonly Tool[], currentRequest: 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.ResponsesRequest, computedParams: Partial<NextTurnParamsContext>): models.ResponsesRequest;
+export declare function applyNextTurnParamsToRequest(request: ResponsesRequest, computedParams: Partial<NextTurnParamsContext>): ResponsesRequest;
 //# sourceMappingURL=next-turn-params.d.ts.map

package/esm/lib/stream-transformers.d.ts

@@ -1,30 +1,39 @@
-import type * as models from '../models/index.js';
+import type { ChatAssistantMessage } from '../models/chatassistantmessage.js';
+import type { FunctionCallOutputItem } from '../models/functioncalloutputitem.js';
+import type { OpenResponsesResult } from '../models/openresponsesresult.js';
+import type { OutputFileSearchCallItem } from '../models/outputfilesearchcallitem.js';
+import type { OutputFunctionCallItem } from '../models/outputfunctioncallitem.js';
+import type { OutputImageGenerationCallItem } from '../models/outputimagegenerationcallitem.js';
+import type { OutputMessage } from '../models/outputmessage.js';
+import type { OutputReasoningItem } from '../models/outputreasoningitem.js';
+import type { OutputWebSearchCallItem } from '../models/outputwebsearchcallitem.js';
+import type { StreamEvents } from '../models/streamevents.js';
 import type { ClaudeMessage, UnsupportedContent } from '../models/claude-message.js';
 import type { ReusableReadableStream } from './reusable-stream.js';
 import type { ParsedToolCall, Tool } from './tool-types.js';
 /**
  * Extract text deltas from responses stream events
  */
-export declare function extractTextDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
+export declare function extractTextDeltas(stream: ReusableReadableStream<StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Extract reasoning deltas from responses stream events
  */
-export declare function extractReasoningDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
+export declare function extractReasoningDeltas(stream: ReusableReadableStream<StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Extract tool call argument deltas from responses stream events
  */
-export declare function extractToolDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
+export declare function extractToolDeltas(stream: ReusableReadableStream<StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Build incremental message updates from responses stream events
  * Returns OutputMessage (assistant/responses format)
  */
-export declare function buildResponsesMessageStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<models.OutputMessage>;
+export declare function buildResponsesMessageStream(stream: ReusableReadableStream<StreamEvents>): AsyncIterableIterator<OutputMessage>;
 /**
  * Output item types that can be streamed from a response.
  * This is the union of all item types that appear in response output,
  * plus function_call_output for tool results.
  */
-export type StreamableOutputItem = models.OutputMessage | models.OutputFunctionCallItem | models.OutputReasoningItem | models.OutputWebSearchCallItem | models.OutputFileSearchCallItem | models.OutputImageGenerationCallItem | models.FunctionCallOutputItem;
+export type StreamableOutputItem = OutputMessage | OutputFunctionCallItem | OutputReasoningItem | OutputWebSearchCallItem | OutputFileSearchCallItem | OutputImageGenerationCallItem | FunctionCallOutputItem;
 /**
  * Discriminated union for tracking items in progress.
  * Each variant has only the fields relevant to that item type.
@@ -44,7 +53,7 @@ export type ItemInProgress = {
     id: string;
     reasoningContent: string;
 };
-type ItemsStreamHandler = (event: models.StreamEvents, itemsInProgress: Map<string, ItemInProgress>) => StreamableOutputItem | undefined;
+type ItemsStreamHandler = (event: StreamEvents, itemsInProgress: Map<string, ItemInProgress>) => StreamableOutputItem | undefined;
 export declare const itemsStreamHandlers: Record<string, ItemsStreamHandler>;
 export declare const streamTerminationEvents: Set<string>;
 /**
@@ -52,47 +61,47 @@ export declare const streamTerminationEvents: Set<string>;
  * Yields all item types cumulatively - same item may be emitted multiple times
  * with the same ID but progressively updated content as streaming progresses.
  */
-export declare function buildItemsStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<StreamableOutputItem>;
+export declare function buildItemsStream(stream: ReusableReadableStream<StreamEvents>): AsyncIterableIterator<StreamableOutputItem>;
 /**
  * Build incremental message updates from responses stream events
  * Returns ChatAssistantMessage (chat format) instead of OutputMessage
  */
-export declare function buildMessageStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<models.ChatAssistantMessage>;
+export declare function buildMessageStream(stream: ReusableReadableStream<StreamEvents>): AsyncIterableIterator<ChatAssistantMessage>;
 /**
  * Consume stream until completion and return the complete response
  */
-export declare function consumeStreamForCompletion(stream: ReusableReadableStream<models.StreamEvents>): Promise<models.OpenResponsesResult>;
+export declare function consumeStreamForCompletion(stream: ReusableReadableStream<StreamEvents>): Promise<OpenResponsesResult>;
 /**
  * Extract the first message from a completed response (chat format)
  */
-export declare function extractMessageFromResponse(response: models.OpenResponsesResult): models.ChatAssistantMessage;
+export declare function extractMessageFromResponse(response: OpenResponsesResult): ChatAssistantMessage;
 /**
  * Extract the first message from a completed response (responses format)
  */
-export declare function extractResponsesMessageFromResponse(response: models.OpenResponsesResult): models.OutputMessage;
+export declare function extractResponsesMessageFromResponse(response: OpenResponsesResult): OutputMessage;
 /**
  * Extract text from a response, either from outputText or by concatenating message content
  */
-export declare function extractTextFromResponse(response: models.OpenResponsesResult): string;
+export declare function extractTextFromResponse(response: OpenResponsesResult): string;
 /**
  * Extract all tool calls from a completed response
  * Returns parsed tool calls with arguments as objects (not JSON strings)
  */
-export declare function extractToolCallsFromResponse(response: models.OpenResponsesResult): ParsedToolCall<Tool>[];
+export declare function extractToolCallsFromResponse(response: OpenResponsesResult): ParsedToolCall<Tool>[];
 /**
  * Build incremental tool call updates from responses stream events
  * Yields structured tool call objects as they're built from deltas
  */
-export declare function buildToolCallStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<ParsedToolCall<Tool>>;
+export declare function buildToolCallStream(stream: ReusableReadableStream<StreamEvents>): AsyncIterableIterator<ParsedToolCall<Tool>>;
 /**
  * Check if a response contains any tool calls
  */
-export declare function responseHasToolCalls(response: models.OpenResponsesResult): boolean;
+export declare function responseHasToolCalls(response: OpenResponsesResult): boolean;
 /**
  * Convert OpenResponsesResult to ClaudeMessage format
  * Compatible with the Anthropic SDK BetaMessage type
  */
-export declare function convertToClaudeMessage(response: models.OpenResponsesResult): ClaudeMessage;
+export declare function convertToClaudeMessage(response: OpenResponsesResult): ClaudeMessage;
 /**
  * Extract unsupported content by original type
  */

package/esm/lib/stream-type-guards.d.ts

@@ -1,28 +1,48 @@
-import type * as models from '../models/index.js';
+import type { FileCitation } from '../models/filecitation.js';
+import type { FilePath } from '../models/filepath.js';
+import type { FunctionCallArgsDeltaEvent } from '../models/functioncallargsdeltaevent.js';
+import type { FunctionCallArgsDoneEvent } from '../models/functioncallargsdoneevent.js';
+import type { OpenAIResponsesRefusalContent } from '../models/openairesponsesrefusalcontent.js';
+import type { OutputFileSearchCallItem } from '../models/outputfilesearchcallitem.js';
+import type { OutputFunctionCallItem } from '../models/outputfunctioncallitem.js';
+import type { OutputImageGenerationCallItem } from '../models/outputimagegenerationcallitem.js';
+import type { OutputMessage } from '../models/outputmessage.js';
+import type { OutputReasoningItem } from '../models/outputreasoningitem.js';
+import type { OutputWebSearchCallItem } from '../models/outputwebsearchcallitem.js';
+import type { ReasoningDeltaEvent } from '../models/reasoningdeltaevent.js';
+import type { ResponseOutputText } from '../models/responseoutputtext.js';
+import type { StreamEvents } from '../models/streamevents.js';
+import type { StreamEventsResponseCompleted } from '../models/streameventsresponsecompleted.js';
+import type { StreamEventsResponseFailed } from '../models/streameventsresponsefailed.js';
+import type { StreamEventsResponseIncomplete } from '../models/streameventsresponseincomplete.js';
+import type { StreamEventsResponseOutputItemAdded } from '../models/streameventsresponseoutputitemadded.js';
+import type { StreamEventsResponseOutputItemDone } from '../models/streameventsresponseoutputitemdone.js';
+import type { TextDeltaEvent } from '../models/textdeltaevent.js';
+import type { URLCitation } from '../models/urlcitation.js';
 /**
  * Type guards for OpenResponses stream events
  * These enable proper TypeScript narrowing without type casts
  */
-export declare function isOutputTextDeltaEvent(event: models.StreamEvents): event is models.TextDeltaEvent;
-export declare function isReasoningDeltaEvent(event: models.StreamEvents): event is models.ReasoningDeltaEvent;
-export declare function isFunctionCallArgumentsDeltaEvent(event: models.StreamEvents): event is models.FunctionCallArgsDeltaEvent;
-export declare function isOutputItemAddedEvent(event: models.StreamEvents): event is models.StreamEventsResponseOutputItemAdded;
-export declare function isOutputItemDoneEvent(event: models.StreamEvents): event is models.StreamEventsResponseOutputItemDone;
-export declare function isResponseCompletedEvent(event: models.StreamEvents): event is models.StreamEventsResponseCompleted;
-export declare function isResponseFailedEvent(event: models.StreamEvents): event is models.StreamEventsResponseFailed;
-export declare function isResponseIncompleteEvent(event: models.StreamEvents): event is models.StreamEventsResponseIncomplete;
-export declare function isFunctionCallArgumentsDoneEvent(event: models.StreamEvents): event is models.FunctionCallArgsDoneEvent;
-export declare function isOutputMessage(item: unknown): item is models.OutputMessage;
-export declare function isFunctionCallItem(item: unknown): item is models.OutputFunctionCallItem;
-export declare function isReasoningOutputItem(item: unknown): item is models.OutputReasoningItem;
-export declare function isWebSearchCallOutputItem(item: unknown): item is models.OutputWebSearchCallItem;
-export declare function isFileSearchCallOutputItem(item: unknown): item is models.OutputFileSearchCallItem;
-export declare function isImageGenerationCallOutputItem(item: unknown): item is models.OutputImageGenerationCallItem;
-export declare function isOutputTextPart(part: unknown): part is models.ResponseOutputText;
-export declare function isRefusalPart(part: unknown): part is models.OpenAIResponsesRefusalContent;
-export declare function isFileCitationAnnotation(annotation: unknown): annotation is models.FileCitation;
-export declare function isURLCitationAnnotation(annotation: unknown): annotation is models.URLCitation;
-export declare function isFilePathAnnotation(annotation: unknown): annotation is models.FilePath;
+export declare function isOutputTextDeltaEvent(event: StreamEvents): event is TextDeltaEvent;
+export declare function isReasoningDeltaEvent(event: StreamEvents): event is ReasoningDeltaEvent;
+export declare function isFunctionCallArgumentsDeltaEvent(event: StreamEvents): event is FunctionCallArgsDeltaEvent;
+export declare function isOutputItemAddedEvent(event: StreamEvents): event is StreamEventsResponseOutputItemAdded;
+export declare function isOutputItemDoneEvent(event: StreamEvents): event is StreamEventsResponseOutputItemDone;
+export declare function isResponseCompletedEvent(event: StreamEvents): event is StreamEventsResponseCompleted;
+export declare function isResponseFailedEvent(event: StreamEvents): event is StreamEventsResponseFailed;
+export declare function isResponseIncompleteEvent(event: StreamEvents): event is StreamEventsResponseIncomplete;
+export declare function isFunctionCallArgumentsDoneEvent(event: StreamEvents): event is FunctionCallArgsDoneEvent;
+export declare function isOutputMessage(item: unknown): item is OutputMessage;
+export declare function isFunctionCallItem(item: unknown): item is OutputFunctionCallItem;
+export declare function isReasoningOutputItem(item: unknown): item is OutputReasoningItem;
+export declare function isWebSearchCallOutputItem(item: unknown): item is OutputWebSearchCallItem;
+export declare function isFileSearchCallOutputItem(item: unknown): item is OutputFileSearchCallItem;
+export declare function isImageGenerationCallOutputItem(item: unknown): item is OutputImageGenerationCallItem;
+export declare function isOutputTextPart(part: unknown): part is ResponseOutputText;
+export declare function isRefusalPart(part: unknown): part is OpenAIResponsesRefusalContent;
+export declare function isFileCitationAnnotation(annotation: unknown): annotation is FileCitation;
+export declare function isURLCitationAnnotation(annotation: unknown): annotation is URLCitation;
+export declare function isFilePathAnnotation(annotation: unknown): annotation is FilePath;
 export declare function hasTypeProperty(item: unknown): item is {
     type: string;
 };

package/esm/lib/tool-orchestrator.d.ts

@@ -1,4 +1,6 @@
-import type * as models from '../models/index.js';
+import type { InputsUnion } from '../models/inputsunion.js';
+import type { OpenResponsesResult } from '../models/openresponsesresult.js';
+import type { ResponsesRequest } from '../models/responsesrequest.js';
 import type { APITool, Tool, ToolExecutionResult } from './tool-types.js';
 /**
  * Options for tool execution
@@ -10,10 +12,10 @@ export interface ToolExecutionOptions {
  * Result of the tool execution loop
  */
 export interface ToolOrchestrationResult {
-    finalResponse: models.OpenResponsesResult;
-    allResponses: models.OpenResponsesResult[];
+    finalResponse: OpenResponsesResult;
+    allResponses: OpenResponsesResult[];
     toolExecutionResults: ToolExecutionResult<Tool>[];
-    conversationInput: models.InputsUnion;
+    conversationInput: InputsUnion;
 }
 /**
  * Execute tool calls and manage multi-turn conversations
@@ -27,7 +29,7 @@ export interface ToolOrchestrationResult {
  * @param options - Execution options
  * @returns Result containing final response and all execution data
  */
-export declare function executeToolLoop(sendRequest: (input: models.InputsUnion, tools: APITool[]) => Promise<models.OpenResponsesResult>, initialInput: models.InputsUnion, initialRequest: models.ResponsesRequest, tools: Tool[], apiTools: APITool[], options?: ToolExecutionOptions): Promise<ToolOrchestrationResult>;
+export declare function executeToolLoop(sendRequest: (input: InputsUnion, tools: APITool[]) => Promise<OpenResponsesResult>, initialInput: InputsUnion, initialRequest: ResponsesRequest, tools: Tool[], apiTools: APITool[], options?: ToolExecutionOptions): Promise<ToolOrchestrationResult>;
 /**
  * Convert tool execution results to a map for easy lookup
  */

package/esm/lib/tool-types.d.ts

@@ -1,6 +1,10 @@
 import type { $ZodObject, $ZodShape, $ZodType, infer as zodInfer } from 'zod/v4/core';
-import type * as models from '../models/index.js';
-import type { StreamEvents } from '../models/index.js';
+import type { FunctionCallItem } from '../models/functioncallitem.js';
+import type { FunctionCallOutputItem } from '../models/functioncalloutputitem.js';
+import type { InputsUnion } from '../models/inputsunion.js';
+import type { OpenResponsesResult, Usage } from '../models/openresponsesresult.js';
+import type { ResponsesRequest } from '../models/responsesrequest.js';
+import type { StreamEvents } from '../models/streamevents.js';
 import type { ModelResult } from './model-result.js';
 /**
  * Tool type enum for enhanced tools
@@ -14,11 +18,11 @@ export declare enum ToolType {
  */
 export interface TurnContext {
     /** The specific tool call being executed (only available during tool execution) */
-    toolCall?: models.FunctionCallItem;
+    toolCall?: FunctionCallItem;
     /** Number of tool execution turns so far (1-indexed: first turn = 1, 0 = initial request) */
     numberOfTurns: number;
     /** The full request being sent to the API (only available during tool execution) */
-    turnRequest?: models.ResponsesRequest;
+    turnRequest?: ResponsesRequest;
 }
 /**
  * Extract context schema type from a tool definition
@@ -83,7 +87,7 @@ export declare const SHARED_CONTEXT_KEY: "shared";
  */
 export type NextTurnParamsContext = {
     /** Current input (messages) */
-    input: models.InputsUnion;
+    input: InputsUnion;
     /** Current model selection */
     model: string;
     /** Current models array */
@@ -315,8 +319,8 @@ export interface StepResult<TTools extends readonly Tool[] = readonly Tool[]> {
     readonly text: string;
     readonly toolCalls: TypedToolCallUnion<TTools>[];
     readonly toolResults: ToolExecutionResultUnion<TTools>[];
-    readonly response: models.OpenResponsesResult;
-    readonly usage?: models.Usage | null | undefined;
+    readonly response: OpenResponsesResult;
+    readonly usage?: Usage | null | undefined;
     readonly finishReason?: string | undefined;
     readonly warnings?: Warning[] | undefined;
     readonly experimental_providerMetadata?: Record<string, unknown> | undefined;
@@ -388,7 +392,7 @@ export type ToolResultEvent<TResult = unknown, TPreliminaryResults = unknown> =
  */
 export type ToolCallOutputEvent = {
     type: 'tool.call_output';
-    output: models.FunctionCallOutputItem;
+    output: FunctionCallOutputItem;
     timestamp: number;
 };
 /**
@@ -459,7 +463,7 @@ export type ChatStreamEvent<TEvent = unknown> = {
     delta: string;
 } | {
     type: 'message.complete';
-    response: models.OpenResponsesResult;
+    response: OpenResponsesResult;
 } | {
     type: 'tool.preliminary_result';
     toolCallId: string;
@@ -505,7 +509,7 @@ export interface ConversationState<TTools extends readonly Tool[] = readonly Too
     /** Unique identifier for this conversation */
     id: string;
     /** Full message history */
-    messages: models.InputsUnion;
+    messages: InputsUnion;
     /** Previous response ID for chaining (OpenRouter server-side optimization) */
     previousResponseId?: string;
     /** Tool calls awaiting human approval */

package/esm/lib/turn-context.d.ts

@@ -1,4 +1,6 @@
-import * as models from '../models/index.js';
+import type { FunctionCallItem } from '../models/functioncallitem.js';
+import type { InputsUnion, InputsUnion1 } from '../models/inputsunion.js';
+import type { ResponsesRequest } from '../models/responsesrequest.js';
 import type { TurnContext } from './tool-types.js';
 /**
  * Options for building a turn context
@@ -7,9 +9,9 @@ export interface BuildTurnContextOptions {
     /** Number of turns so far (1-indexed for tool execution, 0 for initial request) */
     numberOfTurns: number;
     /** The specific tool call being executed (optional for initial/async resolution contexts) */
-    toolCall?: models.FunctionCallItem;
+    toolCall?: FunctionCallItem;
     /** The full request being sent to the API (optional for initial/async resolution contexts) */
-    turnRequest?: models.ResponsesRequest;
+    turnRequest?: ResponsesRequest;
 }
 /**
  * Build a turn context for tool execution or async parameter resolution
@@ -46,5 +48,5 @@ export declare function buildTurnContext(options: BuildTurnContextOptions): Turn
  * // Returns: [{ role: "user", content: "Hello!" }]
  * ```
  */
-export declare function normalizeInputToArray(input: models.InputsUnion): Array<models.InputsUnion1>;
+export declare function normalizeInputToArray(input: InputsUnion): Array<InputsUnion1>;
 //# sourceMappingURL=turn-context.d.ts.map

package/esm/lib/turn-context.js

@@ -1,4 +1,4 @@
-import * as models from '../models/index.js';
+import { EasyInputMessageRoleUser } from '../models/easyinputmessage.js';
 /**
  * Build a turn context for tool execution or async parameter resolution
  *
@@ -49,7 +49,7 @@ export function normalizeInputToArray(input) {
     if (typeof input === 'string') {
         // Construct object with all required fields - type is optional
         const message = {
-            role: models.EasyInputMessageRoleUser.User,
+            role: EasyInputMessageRoleUser.User,
             content: input,
         };
         return [message];