feat: add async function support for CallModelInput parameters

Adds support for making any CallModelInput field a dynamic async function that
computes values based on conversation context (TurnContext).

Key features:
- All API parameter fields can be functions (excluding tools/maxToolRounds)
- Functions receive TurnContext with numberOfTurns, messageHistory, model, models
- Resolved before EVERY turn (initial request + each tool execution round)
- Execution order: Async functions → Tool execution → nextTurnParams → API
- Fully type-safe with TypeScript support
- Backward compatible (accepts both static values and functions)

Changes:
- Created src/lib/async-params.ts with type definitions and resolution logic
- Updated callModel() to accept AsyncCallModelInput type
- Added async resolution in ModelResult.initStream() and multi-turn loop
- Exported new types and helper functions
- Added comprehensive JSDoc documentation with examples

Example usage:
```typescript
const result = callModel(client, {
  temperature: (ctx) => Math.min(ctx.numberOfTurns * 0.2, 1.0),
  model: (ctx) => ctx.numberOfTurns > 3 ? 'gpt-4' : 'gpt-3.5-turbo',
  input: [{ type: 'text', text: 'Hello' }],
});
```

Author: mattapperson

src/funcs/call-model.ts

@@ -1,4 +1,5 @@
 import type { OpenRouterCore } from '../core.js';
+import type { AsyncCallModelInput } from '../lib/async-params.js';
 import type { RequestOptions } from '../lib/sdks.js';
 import type { MaxToolRounds, Tool } from '../lib/tool-types.js';
 import type * as models from '../models/index.js';
@@ -14,6 +15,9 @@ export type CallModelInput = Omit<models.OpenResponsesRequest, 'stream' | 'tools
   maxToolRounds?: MaxToolRounds;
 };
 
+// Re-export AsyncCallModelInput for convenience
+export type { AsyncCallModelInput } from '../lib/async-params.js';
+
 /**
  * Get a response with multiple consumption patterns
  *
@@ -36,10 +40,61 @@ export type CallModelInput = Omit<models.OpenResponsesRequest, 'stream' | 'tools
  * For message format conversion, use the helper functions:
  * - `fromChatMessages()` / `toChatMessage()` for OpenAI chat format
  * - `fromClaudeMessages()` / `toClaudeMessage()` for Anthropic Claude format
+ *
+ * **Async Function Support:**
+ *
+ * Any field in CallModelInput can be a function that computes the value dynamically
+ * based on the conversation context. Functions are resolved before EVERY turn, allowing
+ * parameters to adapt as the conversation progresses.
+ *
+ * @example
+ * ```typescript
+ * // Increase temperature over turns
+ * const result = callModel(client, {
+ *   model: 'gpt-4',
+ *   temperature: (ctx) => Math.min(ctx.numberOfTurns * 0.2, 1.0),
+ *   input: [{ type: 'text', text: 'Hello' }],
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Switch models based on conversation length
+ * const result = callModel(client, {
+ *   model: (ctx) => ctx.numberOfTurns > 3 ? 'gpt-4' : 'gpt-3.5-turbo',
+ *   input: [{ type: 'text', text: 'Complex question' }],
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use async functions to fetch dynamic values
+ * const result = callModel(client, {
+ *   model: 'gpt-4',
+ *   instructions: async (ctx) => {
+ *     const userPrefs = await fetchUserPreferences();
+ *     return `You are a helpful assistant. User preferences: ${userPrefs}`;
+ *   },
+ *   input: [{ type: 'text', text: 'Help me' }],
+ * });
+ * ```
+ *
+ * Async functions receive `TurnContext` with:
+ * - `numberOfTurns`: Current turn number (0-indexed, 0 = initial request)
+ * - `messageHistory`: Current conversation messages
+ * - `model`: Current model selection (if set)
+ * - `models`: Current models array (if set)
+ *
+ * **Execution Order:**
+ * Functions are resolved at the START of each turn in this order:
+ * 1. Async functions (parallel resolution)
+ * 2. Tool execution (if tools called by model)
+ * 3. nextTurnParams functions (if defined on tools)
+ * 4. API request with resolved values
  */
 export function callModel(
   client: OpenRouterCore,
-  request: CallModelInput,
+  request: CallModelInput | AsyncCallModelInput,
   options?: RequestOptions,
 ): ModelResult {
   const { tools, maxToolRounds, ...apiRequest } = request;
@@ -48,12 +103,13 @@ export function callModel(
   const apiTools = tools ? convertToolsToAPIFormat(tools) : undefined;
 
   // Build the request with converted tools
-  const finalRequest: models.OpenResponsesRequest = {
+  // Note: async functions are resolved later in ModelResult.executeToolsIfNeeded()
+  const finalRequest: models.OpenResponsesRequest | AsyncCallModelInput = {
     ...apiRequest,
     ...(apiTools !== undefined && {
       tools: apiTools,
     }),
-  };
+  } as any;
 
   return new ModelResult({
     client,

src/index.ts

@@ -2,89 +2,96 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-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 * from "./sdk/sdk.js";
-
-// Message format compatibility helpers
-export { fromClaudeMessages, toClaudeMessage } from "./lib/anthropic-compat.js";
-export { fromChatMessages, toChatMessage } from "./lib/chat-compat.js";
-export { extractUnsupportedContent, hasUnsupportedContent, getUnsupportedContentSummary } from "./lib/stream-transformers.js";
-
+// Async params support
+export type {
+  AsyncCallModelInput,
+  FieldOrAsyncFunction,
+  ResolvedAsyncCallModelInput,
+} from './lib/async-params.js';
+export type { Fetcher, HTTPClientOptions } from './lib/http.js';
+// Tool types
+export type {
+  ChatStreamEvent,
+  EnhancedResponseStreamEvent,
+  InferToolEvent,
+  InferToolEventsUnion,
+  InferToolInput,
+  InferToolOutput,
+  ManualTool,
+  NextTurnParamsContext,
+  NextTurnParamsFunctions,
+  Tool,
+  ToolCallInfo,
+  ToolPreliminaryResultEvent,
+  ToolStreamEvent,
+  ToolWithExecute,
+  ToolWithGenerator,
+  TurnContext,
+  TypedToolCall,
+  TypedToolCallUnion,
+} from './lib/tool-types.js';
+export type { BuildTurnContextOptions } from './lib/turn-context.js';
 // Claude message types
 export type {
-  ClaudeMessage,
-  ClaudeMessageParam,
+  ClaudeBase64ImageSource,
+  ClaudeCacheControl,
+  ClaudeCitationCharLocation,
+  ClaudeCitationContentBlockLocation,
+  ClaudeCitationPageLocation,
+  ClaudeCitationSearchResultLocation,
+  ClaudeCitationWebSearchResultLocation,
   ClaudeContentBlock,
   ClaudeContentBlockParam,
-  ClaudeTextBlock,
-  ClaudeThinkingBlock,
+  ClaudeImageBlockParam,
+  ClaudeMessage,
+  ClaudeMessageParam,
   ClaudeRedactedThinkingBlock,
-  ClaudeToolUseBlock,
   ClaudeServerToolUseBlock,
-  ClaudeTextBlockParam,
-  ClaudeImageBlockParam,
-  ClaudeToolUseBlockParam,
-  ClaudeToolResultBlockParam,
   ClaudeStopReason,
-  ClaudeUsage,
-  ClaudeCacheControl,
+  ClaudeTextBlock,
+  ClaudeTextBlockParam,
   ClaudeTextCitation,
-  ClaudeCitationCharLocation,
-  ClaudeCitationPageLocation,
-  ClaudeCitationContentBlockLocation,
-  ClaudeCitationWebSearchResultLocation,
-  ClaudeCitationSearchResultLocation,
-  ClaudeBase64ImageSource,
+  ClaudeThinkingBlock,
+  ClaudeToolResultBlockParam,
+  ClaudeToolUseBlock,
+  ClaudeToolUseBlockParam,
   ClaudeURLImageSource,
-} from "./models/claude-message.js";
+  ClaudeUsage,
+} from './models/claude-message.js';
 
+// 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';
+export {
+  extractUnsupportedContent,
+  getUnsupportedContentSummary,
+  hasUnsupportedContent,
+} from './lib/stream-transformers.js';
 // Tool creation helpers
-export { tool } from "./lib/tool.js";
-
-// Tool types
-export type {
-  Tool,
-  ToolWithExecute,
-  ToolWithGenerator,
-  ManualTool,
-  TurnContext,
-  InferToolInput,
-  InferToolOutput,
-  InferToolEvent,
-  InferToolEventsUnion,
-  TypedToolCall,
-  TypedToolCallUnion,
-  ToolStreamEvent,
-  ChatStreamEvent,
-  EnhancedResponseStreamEvent,
-  ToolPreliminaryResultEvent,
-  NextTurnParamsContext,
-  NextTurnParamsFunctions,
-  ToolCallInfo,
-} from "./lib/tool-types.js";
-
+export { tool } from './lib/tool.js';
 export {
-  ToolType,
   hasExecuteFunction,
   isGeneratorTool,
   isRegularExecuteTool,
   isToolPreliminaryResultEvent,
-} from "./lib/tool-types.js";
-
+  ToolType,
+} from './lib/tool-types.js';
 // Turn context helpers
-export { buildTurnContext, normalizeInputToArray } from "./lib/turn-context.js";
-export type { BuildTurnContextOptions } from "./lib/turn-context.js";
-
-// Next turn params helpers
-export {
-  buildNextTurnParamsContext,
-  executeNextTurnParamsFunctions,
-  applyNextTurnParamsToRequest,
-} from "./lib/next-turn-params.js";
-
-// Claude constants and type guards
-export { ClaudeContentBlockType, NonClaudeMessageRole } from "./lib/claude-constants.js";
-export { isClaudeStyleMessages } from "./lib/claude-type-guards.js";
+export { buildTurnContext, normalizeInputToArray } from './lib/turn-context.js';
+export * from './sdk/sdk.js';

src/lib/async-params.ts

@@ -0,0 +1,91 @@
+import type { CallModelInput } from '../funcs/call-model.js';
+import type { TurnContext } from './tool-types.js';
+
+/**
+ * A field can be either a value of type T or a function that computes T
+ */
+export type FieldOrAsyncFunction<T> = T | ((context: TurnContext) => T | Promise<T>);
+
+/**
+ * CallModelInput with async function support for API parameter fields
+ * Excludes tools and maxToolRounds which should not be dynamic
+ */
+export type AsyncCallModelInput = {
+  [K in keyof Omit<CallModelInput, 'tools' | 'maxToolRounds'>]: FieldOrAsyncFunction<
+    CallModelInput[K]
+  >;
+} & {
+  tools?: CallModelInput['tools'];
+  maxToolRounds?: CallModelInput['maxToolRounds'];
+};
+
+/**
+ * Resolved AsyncCallModelInput (all functions evaluated to values)
+ * This strips out the function types, leaving only the resolved value types
+ */
+export type ResolvedAsyncCallModelInput = Omit<CallModelInput, 'tools' | 'maxToolRounds'> & {
+  tools?: never;
+  maxToolRounds?: never;
+};
+
+/**
+ * Resolve all async functions in CallModelInput to their values
+ *
+ * @param input - Input with possible functions
+ * @param context - Turn context for function execution
+ * @returns Resolved input with all values (no functions)
+ *
+ * @example
+ * ```typescript
+ * const resolved = await resolveAsyncFunctions(
+ *   {
+ *     model: 'gpt-4',
+ *     temperature: (ctx) => ctx.numberOfTurns * 0.1,
+ *     input: 'Hello',
+ *   },
+ *   { numberOfTurns: 2, messageHistory: [] }
+ * );
+ * // resolved.temperature === 0.2
+ * ```
+ */
+export async function resolveAsyncFunctions(
+  input: AsyncCallModelInput,
+  context: TurnContext,
+): Promise<ResolvedAsyncCallModelInput> {
+  const resolved: Record<string, unknown> = {};
+
+  // Iterate over all keys in the input
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === 'function') {
+      try {
+        // Execute the function with context
+        resolved[key] = await Promise.resolve(value(context));
+      } catch (error) {
+        // Wrap errors with context about which field failed
+        throw new Error(
+          `Failed to resolve async function for field "${key}": ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+    } else {
+      // Not a function, use as-is
+      resolved[key] = value;
+    }
+  }
+
+  return resolved as ResolvedAsyncCallModelInput;
+}
+
+/**
+ * Check if input has any async functions that need resolution
+ *
+ * @param input - Input to check
+ * @returns True if any field is a function
+ */
+export function hasAsyncFunctions(input: any): boolean {
+  if (!input || typeof input !== 'object') {
+    return false;
+  }
+  return Object.values(input).some((value) => typeof value === 'function');
+}