API Reference

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

getText(): Promise<string>

getResponse(): Promise<OpenResponsesNonStreamingResponse>

getTextStream(): AsyncIterableIterator<string>

getReasoningStream(): AsyncIterableIterator<string>

getNewMessagesStream(): AsyncIterableIterator<ResponsesOutputMessage | OpenResponsesFunctionCallOutput>

getFullResponsesStream(): AsyncIterableIterator<EnhancedResponseStreamEvent>

getToolCalls(): Promise<ParsedToolCall[]>

getToolCallsStream(): AsyncIterableIterator<ParsedToolCall>

getToolStream(): AsyncIterableIterator<ToolStreamEvent>

getContextUpdates(): AsyncGenerator<ToolContextMap<TTools>>

cancel(): Promise<void>

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

type Tool =  | ToolWithExecute<ZodObject, ZodType>  | ToolWithGenerator<ZodObject, ZodType, ZodType>  | ManualTool<ZodObject, ZodType>  | HITLTool<ZodObject, ZodType>;

interface ToolWithExecute<  TInput, TOutput, TContext, TName> {  type: ToolType.Function;  function: {    name: TName;    description?: string;    inputSchema: TInput;    outputSchema?: TOutput;    contextSchema?: ZodObject;    execute: (      params: z.infer<TInput>,      context: ToolExecuteContext<TName, TContext>,    ) => Promise<z.infer<TOutput>>;  };}

interface ToolWithGenerator<  TInput, TEvent, TOutput, TContext, TName> {  type: ToolType.Function;  function: {    name: TName;    description?: string;    inputSchema: TInput;    eventSchema: TEvent;    outputSchema: TOutput;    contextSchema?: ZodObject;    execute: (      params: z.infer<TInput>,      context: ToolExecuteContext<TName, TContext>,    ) => AsyncGenerator<z.infer<TEvent>>;  };}

interface ManualTool<TInput, TOutput> {  type: ToolType.Function;  function: {    name: string;    description?: string;    inputSchema: TInput;    outputSchema?: TOutput;  };}

interface HITLToolFunction<  TInput, TOutput, TContext, TName> {  name: TName;  description?: string;  inputSchema: TInput;  outputSchema: TOutput;  contextSchema?: ZodObject;  onToolCalled: (    params: z.infer<TInput>,    context?: ToolExecuteContext<TName, TContext>,  ) => Promise<z.infer<TOutput> | null> | z.infer<TOutput> | null;  onResponseReceived?: (    rawResult: unknown,    context?: ToolExecuteContext<TName, TContext>,  ) => Promise<z.infer<TOutput>> | z.infer<TOutput>;  toModelOutput?: ToModelOutputFunction<    z.infer<TInput>,    z.infer<TOutput>  >;} type HITLTool<TInput, TOutput, TContext> = {  type: ToolType.Function;  function: HITLToolFunction<TInput, TOutput, TContext>;};

function isManualTool(tool: Tool): tool is ManualTool;function isHITLTool(tool: Tool): tool is HITLTool;function isAutoResolvableTool(  tool: Tool,): tool is ToolWithExecute | ToolWithGenerator | HITLTool;

interface TurnContext {  toolCall?: OpenResponsesFunctionToolCall;  numberOfTurns: number;  turnRequest?: OpenResponsesRequest;}

type ToolExecuteContext<TName, TContext> =  TurnContext & {    tools: {      readonly [K in TName]: Readonly<TContext>;    };    setContext(partial: Partial<TContext>): void;  };

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

type ContextInput<T> =  | T  | ((turn: TurnContext) => T)  | ((turn: TurnContext) => Promise<T>);

interface NextTurnParamsContext {  input: OpenResponsesInput;  model: string;  models: string[];  temperature: number | null;  maxOutputTokens: number | null;  topP: number | null;  topK?: number | undefined;  instructions: string | null;}

type EnhancedResponseStreamEvent =  | OpenResponsesStreamEvent  | ToolPreliminaryResultEvent;

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

interface ParsedToolCall {  id: string;  name: string;  arguments: unknown;}

interface ToolExecutionResult {  toolCallId: string;  toolName: string;  result: unknown;  preliminaryResults?: unknown[];  error?: Error;}

type StopWhen =  | StopCondition  | StopCondition[];

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

interface StopConditionContext {  steps: StepResult[];}

interface StepResult {  stepType: 'initial' | 'continue';  text: string;  toolCalls: TypedToolCallUnion[];  toolResults: ToolExecutionResultUnion[];  response: OpenResponsesNonStreamingResponse;  usage?: OpenResponsesUsage;  finishReason?: string;  warnings?: Warning[];  experimental_providerMetadata?: Record<string, unknown>;}

interface Warning {  type: string;  message: string;}

function fromChatMessages(messages: Message[]): OpenResponsesInput

function toChatMessage(response: OpenResponsesNonStreamingResponse): AssistantMessage

function fromClaudeMessages(messages: ClaudeMessageParam[]): OpenResponsesInput

function toClaudeMessage(response: OpenResponsesNonStreamingResponse): ClaudeMessage

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

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

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

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

// Agent clientexport { ModelGates } from '@modelgates/agent'; // Tool helpersexport {  tool,  ToolType,  isManualTool,  isHITLTool,  isAutoResolvableTool,} from '@modelgates/agent'; // Format helpersexport { fromChatMessages, toChatMessage, fromClaudeMessages, toClaudeMessage } from '@modelgates/agent'; // Stop condition helpersexport { stepCountIs, hasToolCall, maxTokensUsed, maxCost, finishReasonIs } from '@modelgates/agent'; // Context helpersexport {  buildToolExecuteContext,  ToolContextStore,} from '@modelgates/agent'; // Typesexport type {  CallModelInput,  ContextInput,  Tool,  ToolWithExecute,  ToolWithGenerator,  ManualTool,  HITLTool,  HITLToolFunction,  ToolExecuteContext,  ToolContextMap,  TurnContext,  ParsedToolCall,  ToolExecutionResult,  StopCondition,  StopWhen,  InferToolInput,  InferToolOutput,  InferToolEvent,} from '@modelgates/agent';