API Reference

1
function callModel(request: CallModelInput, options?: RequestOptions): ModelResult

1
getText(): Promise<string>

1
getResponse(): Promise<OpenResponsesNonStreamingResponse>

1
getTextStream(): AsyncIterableIterator<string>

1
getReasoningStream(): AsyncIterableIterator<string>

1
getNewMessagesStream(): AsyncIterableIterator<ResponsesOutputMessage | OpenResponsesFunctionCallOutput>

1
getFullResponsesStream(): AsyncIterableIterator<EnhancedResponseStreamEvent>

1
getToolCalls(): Promise<ParsedToolCall[]>

1
getToolCallsStream(): AsyncIterableIterator<ParsedToolCall>

1
getToolStream(): AsyncIterableIterator<ToolStreamEvent>

1
cancel(): Promise<void>

1
function tool<TInput, TOutput>(config: ToolConfig): Tool

1
type Tool =
2
  | ToolWithExecute<ZodObject, ZodType>
3
  | ToolWithGenerator<ZodObject, ZodType, ZodType>
4
  | ManualTool<ZodObject, ZodType>;

1
interface ToolWithExecute<TInput, TOutput> {
2
  type: ToolType.Function;
3
  function: {
4
    name: string;
5
    description?: string;
6
    inputSchema: TInput;
7
    outputSchema?: TOutput;
8
    execute: (params: z.infer<TInput>, context?: TurnContext) => Promise<z.infer<TOutput>>;
9
  };
10
}

1
interface ToolWithGenerator<TInput, TEvent, TOutput> {
2
  type: ToolType.Function;
3
  function: {
4
    name: string;
5
    description?: string;
6
    inputSchema: TInput;
7
    eventSchema: TEvent;
8
    outputSchema: TOutput;
9
    execute: (params: z.infer<TInput>, context?: TurnContext) => AsyncGenerator<z.infer<TEvent>>;
10
  };
11
}

1
interface ManualTool<TInput, TOutput> {
2
  type: ToolType.Function;
3
  function: {
4
    name: string;
5
    description?: string;
6
    inputSchema: TInput;
7
    outputSchema?: TOutput;
8
  };
9
}

1
interface TurnContext {
2
  toolCall?: OpenResponsesFunctionToolCall;
3
  numberOfTurns: number;
4
  turnRequest?: OpenResponsesRequest;
5
}

1
interface NextTurnParamsContext {
2
  input: OpenResponsesInput;
3
  model: string;
4
  models: string[];
5
  temperature: number | null;
6
  maxOutputTokens: number | null;
7
  topP: number | null;
8
  topK?: number | undefined;
9
  instructions: string | null;
10
}

1
type EnhancedResponseStreamEvent =
2
  | OpenResponsesStreamEvent
3
  | ToolPreliminaryResultEvent;

1
type ToolStreamEvent =
2
  | { type: 'delta'; content: string }
3
  | { type: 'preliminary_result'; toolCallId: string; result: unknown };

1
interface ParsedToolCall {
2
  id: string;
3
  name: string;
4
  arguments: unknown;
5
}

1
interface ToolExecutionResult {
2
  toolCallId: string;
3
  toolName: string;
4
  result: unknown;
5
  preliminaryResults?: unknown[];
6
  error?: Error;
7
}

1
type StopWhen =
2
  | StopCondition
3
  | StopCondition[];

1
type StopCondition = (context: StopConditionContext) => boolean | Promise<boolean>;

1
interface StopConditionContext {
2
  steps: StepResult[];
3
}

1
interface StepResult {
2
  stepType: 'initial' | 'continue';
3
  text: string;
4
  toolCalls: TypedToolCallUnion[];
5
  toolResults: ToolExecutionResultUnion[];
6
  response: OpenResponsesNonStreamingResponse;
7
  usage?: OpenResponsesUsage;
8
  finishReason?: string;
9
  warnings?: Warning[];
10
  experimental_providerMetadata?: Record<string, unknown>;
11
}

1
interface Warning {
2
  type: string;
3
  message: string;
4
}

1
function fromChatMessages(messages: Message[]): OpenResponsesInput

1
function toChatMessage(response: OpenResponsesNonStreamingResponse): AssistantMessage

1
function fromClaudeMessages(messages: ClaudeMessageParam[]): OpenResponsesInput

1
function toClaudeMessage(response: OpenResponsesNonStreamingResponse): ClaudeMessage

1
type InferToolInput<T> = T extends { function: { inputSchema: infer S } }
2
  ? S extends ZodType ? z.infer<S> : unknown
3
  : unknown;

1
type InferToolOutput<T> = T extends { function: { outputSchema: infer S } }
2
  ? S extends ZodType ? z.infer<S> : unknown
3
  : unknown;

1
type InferToolEvent<T> = T extends { function: { eventSchema: infer S } }
2
  ? S extends ZodType ? z.infer<S> : never
3
  : never;

1
type TypedToolCall<T extends Tool> = {
2
  id: string;
3
  name: T extends { function: { name: infer N } } ? N : string;
4
  arguments: InferToolInput<T>;
5
};

1
// Main SDK
2
export { OpenRouter } from '@openrouter/sdk';
3
4
// Tool helpers
5
export { tool, ToolType } from '@openrouter/sdk';
6
7
// Format helpers
8
export { fromChatMessages, toChatMessage, fromClaudeMessages, toClaudeMessage } from '@openrouter/sdk';
9
10
// Stop condition helpers
11
export { stepCountIs, hasToolCall, maxTokensUsed, maxCost, finishReasonIs } from '@openrouter/sdk';
12
13
// Types
14
export type {
15
  CallModelInput,
16
  Tool,
17
  ToolWithExecute,
18
  ToolWithGenerator,
19
  ManualTool,
20
  TurnContext,
21
  ParsedToolCall,
22
  ToolExecutionResult,
23
  StopCondition,
24
  StopWhen,
25
  MaxToolRounds,
26
  InferToolInput,
27
  InferToolOutput,
28
  InferToolEvent,
29
} from '@openrouter/sdk';