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
getContextUpdates(): AsyncGenerator<ToolContextMap<TTools>>

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>
5
  | HITLTool<ZodObject, ZodType>;

1
interface ToolWithExecute<
2
  TInput, TOutput, TContext, TName
3
> {
4
  type: ToolType.Function;
5
  function: {
6
    name: TName;
7
    description?: string;
8
    inputSchema: TInput;
9
    outputSchema?: TOutput;
10
    contextSchema?: ZodObject;
11
    execute: (
12
      params: z.infer<TInput>,
13
      context: ToolExecuteContext<TName, TContext>,
14
    ) => Promise<z.infer<TOutput>>;
15
  };
16
}

1
interface ToolWithGenerator<
2
  TInput, TEvent, TOutput, TContext, TName
3
> {
4
  type: ToolType.Function;
5
  function: {
6
    name: TName;
7
    description?: string;
8
    inputSchema: TInput;
9
    eventSchema: TEvent;
10
    outputSchema: TOutput;
11
    contextSchema?: ZodObject;
12
    execute: (
13
      params: z.infer<TInput>,
14
      context: ToolExecuteContext<TName, TContext>,
15
    ) => AsyncGenerator<z.infer<TEvent>>;
16
  };
17
}

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 HITLToolFunction<
2
  TInput, TOutput, TContext, TName
3
> {
4
  name: TName;
5
  description?: string;
6
  inputSchema: TInput;
7
  outputSchema: TOutput;
8
  contextSchema?: ZodObject;
9
  onToolCalled: (
10
    params: z.infer<TInput>,
11
    context?: ToolExecuteContext<TName, TContext>,
12
  ) => Promise<z.infer<TOutput> | null> | z.infer<TOutput> | null;
13
  onResponseReceived?: (
14
    rawResult: unknown,
15
    context?: ToolExecuteContext<TName, TContext>,
16
  ) => Promise<z.infer<TOutput>> | z.infer<TOutput>;
17
  toModelOutput?: ToModelOutputFunction<
18
    z.infer<TInput>,
19
    z.infer<TOutput>
20
  >;
21
}
22
23
type HITLTool<TInput, TOutput, TContext> = {
24
  type: ToolType.Function;
25
  function: HITLToolFunction<TInput, TOutput, TContext>;
26
};

1
function isManualTool(tool: Tool): tool is ManualTool;
2
function isHITLTool(tool: Tool): tool is HITLTool;
3
function isAutoResolvableTool(
4
  tool: Tool,
5
): tool is ToolWithExecute | ToolWithGenerator | HITLTool;

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

1
type ToolExecuteContext<TName, TContext> =
2
  TurnContext & {
3
    tools: {
4
      readonly [K in TName]: Readonly<TContext>;
5
    };
6
    setContext(partial: Partial<TContext>): void;
7
  };

1
type ToolContextMap<T extends readonly Tool[]> = {
2
  [K in T[number] as K['function']['name']]:
3
    InferToolContext<K>;
4
};

1
type ContextInput<T> =
2
  | T
3
  | ((turn: TurnContext) => T)
4
  | ((turn: TurnContext) => Promise<T>);

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
// Agent client
2
export { OpenRouter } from '@openrouter/agent';
3
4
// Tool helpers
5
export {
6
  tool,
7
  ToolType,
8
  isManualTool,
9
  isHITLTool,
10
  isAutoResolvableTool,
11
} from '@openrouter/agent';
12
13
// Format helpers
14
export { fromChatMessages, toChatMessage, fromClaudeMessages, toClaudeMessage } from '@openrouter/agent';
15
16
// Stop condition helpers
17
export { stepCountIs, hasToolCall, maxTokensUsed, maxCost, finishReasonIs } from '@openrouter/agent';
18
19
// Context helpers
20
export {
21
  buildToolExecuteContext,
22
  ToolContextStore,
23
} from '@openrouter/agent';
24
25
// Types
26
export type {
27
  CallModelInput,
28
  ContextInput,
29
  Tool,
30
  ToolWithExecute,
31
  ToolWithGenerator,
32
  ManualTool,
33
  HITLTool,
34
  HITLToolFunction,
35
  ToolExecuteContext,
36
  ToolContextMap,
37
  TurnContext,
38
  ParsedToolCall,
39
  ToolExecutionResult,
40
  StopCondition,
41
  StopWhen,
42
  InferToolInput,
43
  InferToolOutput,
44
  InferToolEvent,
45
} from '@openrouter/agent';