fixes and improvements

Author: mattapperson

src/lib/anthropic-compat.ts

@@ -98,20 +98,21 @@ export function fromClaudeMessages(
     for (const block of content) {
       switch (block.type) {
         case 'text':
-          textBlocks.push(block as models.ClaudeTextBlockParam);
+          textBlocks.push(block);
           break;
         case 'image':
-          imageBlocks.push(block as models.ClaudeImageBlockParam);
+          imageBlocks.push(block);
           break;
         case 'tool_use':
-          toolUseBlocks.push(block as models.ClaudeToolUseBlockParam);
+          toolUseBlocks.push(block);
           break;
         case 'tool_result':
-          toolResultBlocks.push(block as models.ClaudeToolResultBlockParam);
+          toolResultBlocks.push(block);
           break;
         default: {
+          // Exhaustiveness check - TypeScript will error if we don't handle all block types
           const exhaustiveCheck: never = block;
-          throw new Error(`Unhandled content block type: ${exhaustiveCheck}`);
+          throw new Error(`Unhandled content block type: ${JSON.stringify(exhaustiveCheck)}`);
         }
       }
     }

src/lib/async-params.ts

@@ -2,15 +2,26 @@ import type * as models from '../models/index.js';
 import type { StopWhen, Tool, TurnContext } from './tool-types.js';
 
 /**
- * Type-safe Object.fromEntries that preserves key-value type relationships
+ * Type guard to check if a value is a parameter function
+ * Parameter functions take TurnContext and return a value or promise
  */
-const typeSafeObjectFromEntries = <
-  const T extends ReadonlyArray<readonly [PropertyKey, unknown]>
->(
-  entries: T
-): { [K in T[number] as K[0]]: K[1] } => {
-  return Object.fromEntries(entries) as { [K in T[number] as K[0]]: K[1] };
-};
+function isParameterFunction(
+  value: unknown
+): value is (context: TurnContext) => unknown | Promise<unknown> {
+  return typeof value === 'function';
+}
+
+/**
+ * Build a resolved request object from entries
+ * This validates the structure matches the expected ResolvedCallModelInput shape
+ */
+function buildResolvedRequest(
+  entries: ReadonlyArray<readonly [string, unknown]>
+): ResolvedCallModelInput {
+  const obj = Object.fromEntries(entries);
+
+  return obj satisfies ResolvedCallModelInput;
+}
 
 /**
  * A field can be either a value of type T or a function that computes T
@@ -73,13 +84,10 @@ export async function resolveAsyncFunctions(
       continue;
     }
 
-    if (typeof value === 'function') {
+    if (isParameterFunction(value)) {
       try {
         // Execute the function with context and store the result
-        // We've already filtered out stopWhen at line 73, so this is a parameter function
-        // that accepts TurnContext (not a StopCondition which needs steps)
-        const fn = value as (context: TurnContext) => unknown | Promise<unknown>;
-        const result = await Promise.resolve(fn(context));
+        const result = await Promise.resolve(value(context));
         resolvedEntries.push([key, result] as const);
       } catch (error) {
         // Wrap errors with context about which field failed
@@ -94,11 +102,7 @@ export async function resolveAsyncFunctions(
     }
   }
 
-  // Use type-safe fromEntries - the result type is inferred from the entries
-  // TypeScript can't prove that dynamic keys match the static type at compile time,
-  // but we know all keys come from the input object (minus stopWhen/tools)
-  // and all values are properly resolved through the function above
-  return typeSafeObjectFromEntries(resolvedEntries) as ResolvedCallModelInput;
+  return buildResolvedRequest(resolvedEntries);
 }
 
 /**

src/lib/model-result.ts

@@ -13,7 +13,11 @@ import type {
 } from './tool-types.js';
 
 import { betaResponsesSend } from '../funcs/betaResponsesSend.js';
-import { hasAsyncFunctions, resolveAsyncFunctions } from './async-params.js';
+import {
+  hasAsyncFunctions,
+  resolveAsyncFunctions,
+  type ResolvedCallModelInput,
+} from './async-params.js';
 import { ReusableReadableStream } from './reusable-stream.js';
 import {
   buildResponsesMessageStream,
@@ -83,9 +87,8 @@ function hasTypeProperty(item: unknown): item is {
 }
 
 export interface GetResponseOptions {
-  // Request can be a mix of sync and async fields
-  // The actual type will be narrowed during async function resolution
-  request: models.OpenResponsesRequest | CallModelInput | Record<string, unknown>;
+  // Request can have async functions that will be resolved before sending to API
+  request: CallModelInput;
   client: OpenRouterCore;
   options?: RequestOptions;
   tools?: Tool[];
@@ -122,6 +125,8 @@ export class ModelResult {
     toolCalls: ParsedToolCall[];
     response: models.OpenResponsesNonStreamingResponse;
   }> = [];
+  // Track resolved request after async function resolution
+  private resolvedRequest: models.OpenResponsesRequest | null = null;
 
   constructor(options: GetResponseOptions) {
     this.options = options;
@@ -160,20 +165,30 @@ export class ModelResult {
       };
 
       // Resolve any async functions first
+      let baseRequest: ResolvedCallModelInput;
       if (hasAsyncFunctions(this.options.request)) {
-        const resolved = await resolveAsyncFunctions(
-          this.options.request as CallModelInput,
+        baseRequest = await resolveAsyncFunctions(
+          this.options.request,
           initialContext,
         );
-        this.options.request = resolved as models.OpenResponsesRequest;
+      } else {
+        // Already resolved, extract non-function fields
+        // Since request is CallModelInput, we need to filter out tools/stopWhen
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { tools, stopWhen, ...rest } = this.options.request;
+        // Use satisfies to validate type compatibility while maintaining the target type
+        baseRequest = rest as ResolvedCallModelInput satisfies ResolvedCallModelInput;
       }
 
-      // Force stream mode
-      const request = {
-        ...(this.options.request as models.OpenResponsesRequest),
+      // Store resolved request with stream mode
+      this.resolvedRequest = {
+        ...baseRequest,
         stream: true as const,
       };
 
+      // Force stream mode for initial request
+      const request = this.resolvedRequest;
+
       // Create the stream promise
       this.streamPromise = betaResponsesSend(
         this.options.client,
@@ -183,7 +198,10 @@ export class ModelResult {
         if (!result.ok) {
           throw result.error;
         }
-        return result.value;
+        // When stream: true, the API returns EventStream
+        // TypeScript can't narrow the union type based on runtime parameter values,
+        // so we assert the type here based on our knowledge that stream=true
+        return result.value as EventStream<models.OpenResponsesStreamEvent>;
       });
 
       // Wait for the stream and create the reusable stream
@@ -277,10 +295,14 @@ export class ModelResult {
         // Resolve async functions for this turn
         if (hasAsyncFunctions(this.options.request)) {
           const resolved = await resolveAsyncFunctions(
-            this.options.request as CallModelInput,
+            this.options.request,
             turnContext,
           );
-          this.options.request = resolved as models.OpenResponsesRequest;
+          // Update resolved request with new values
+          this.resolvedRequest = {
+            ...resolved,
+            stream: false, // Tool execution turns don't need streaming
+          };
         }
 
         // Execute all tool calls
@@ -314,16 +336,20 @@ export class ModelResult {
 
         // Execute nextTurnParams functions for tools that were called
         if (this.options.tools && currentToolCalls.length > 0) {
+          if (!this.resolvedRequest) {
+            throw new Error('Request not initialized');
+          }
+
           const computedParams = await executeNextTurnParamsFunctions(
             currentToolCalls,
             this.options.tools,
-            this.options.request as models.OpenResponsesRequest
+            this.resolvedRequest
           );
 
-          // Apply computed parameters to the request for next turn
+          // Apply computed parameters to the resolved request for next turn
           if (Object.keys(computedParams).length > 0) {
-            this.options.request = applyNextTurnParamsToRequest(
-              this.options.request as models.OpenResponsesRequest,
+            this.resolvedRequest = applyNextTurnParamsToRequest(
+              this.resolvedRequest,
               computedParams
             );
           }
@@ -341,8 +367,12 @@ export class ModelResult {
         ];
 
         // Make new request with tool results
+        if (!this.resolvedRequest) {
+          throw new Error('Request not initialized');
+        }
+
         const newRequest: models.OpenResponsesRequest = {
-          ...(this.options.request as models.OpenResponsesRequest),
+          ...this.resolvedRequest,
           input: newInput,
           stream: false,
         };