TOOLS -> TTools

Author: subtleGradient

src/funcs/call-model.ts

@@ -119,11 +119,11 @@ export type { CallModelInput } from '../lib/async-params.js';
  *
  * Default: `stepCountIs(5)` if not specified
  */
-export function callModel<TOOLS extends readonly Tool[]>(
+export function callModel<TTools extends readonly Tool[]>(
   client: OpenRouterCore,
-  request: CallModelInput<TOOLS>,
+  request: CallModelInput<TTools>,
   options?: RequestOptions,
-): ModelResult<TOOLS> {
+): ModelResult<TTools> {
   const { tools, stopWhen, ...apiRequest } = request;
 
   // Convert tools to API format - no cast needed now that convertToolsToAPIFormat accepts readonly
@@ -140,14 +140,14 @@ export function callModel<TOOLS extends readonly Tool[]>(
     finalRequest['tools'] = apiTools;
   }
 
-  return new ModelResult<TOOLS>({
+  return new ModelResult<TTools>({
     client,
     request: finalRequest,
     options: options ?? {},
-    // Preserve the exact TOOLS type instead of widening to Tool[]
-    tools: tools as TOOLS | undefined,
+    // Preserve the exact TTools type instead of widening to Tool[]
+    tools: tools as TTools | undefined,
     ...(stopWhen !== undefined && {
       stopWhen,
     }),
-  } as GetResponseOptions<TOOLS>);
+  } as GetResponseOptions<TTools>);
 }

src/lib/async-params.ts

@@ -31,15 +31,15 @@ export type FieldOrAsyncFunction<T> = T | ((context: TurnContext) => T | Promise
 /**
  * Input type for callModel function
  * Each field can independently be a static value or a function that computes the value
- * Generic over TOOLS to enable proper type inference for stopWhen conditions
+ * Generic over TTools to enable proper type inference for stopWhen conditions
  */
-export type CallModelInput<TOOLS extends readonly Tool[] = readonly Tool[]> = {
+export type CallModelInput<TTools extends readonly Tool[] = readonly Tool[]> = {
   [K in keyof Omit<models.OpenResponsesRequest, 'stream' | 'tools'>]?: FieldOrAsyncFunction<
     models.OpenResponsesRequest[K]
   >;
 } & {
-  tools?: TOOLS;
-  stopWhen?: StopWhen<TOOLS>;
+  tools?: TTools;
+  stopWhen?: StopWhen<TTools>;
 };
 
 /**

src/lib/model-result.ts

@@ -70,13 +70,13 @@ function hasTypeProperty(item: unknown): item is {
   );
 }
 
-export interface GetResponseOptions<TOOLS extends readonly Tool[]> {
+export interface GetResponseOptions<TTools extends readonly Tool[]> {
   // Request can have async functions that will be resolved before sending to API
-  request: CallModelInput<TOOLS>;
+  request: CallModelInput<TTools>;
   client: OpenRouterCore;
   options?: RequestOptions;
-  tools?: TOOLS;
-  stopWhen?: StopWhen<TOOLS>;
+  tools?: TTools;
+  stopWhen?: StopWhen<TTools>;
 }
 
 /**
@@ -96,13 +96,13 @@ export interface GetResponseOptions<TOOLS extends readonly Tool[]> {
  * All consumption patterns can be used concurrently thanks to the underlying
  * ReusableReadableStream implementation.
  *
- * @template TOOLS - The tools array type to enable typed tool calls and results
+ * @template TTools - The tools array type to enable typed tool calls and results
  */
-export class ModelResult<TOOLS extends readonly Tool[]> {
+export class ModelResult<TTools extends readonly Tool[]> {
   private reusableStream: ReusableReadableStream<models.OpenResponsesStreamEvent> | null = null;
   private streamPromise: Promise<EventStream<models.OpenResponsesStreamEvent>> | null = null;
   private textPromise: Promise<string> | null = null;
-  private options: GetResponseOptions<TOOLS>;
+  private options: GetResponseOptions<TTools>;
   private initPromise: Promise<void> | null = null;
   private toolExecutionPromise: Promise<void> | null = null;
   private finalResponse: models.OpenResponsesNonStreamingResponse | null = null;
@@ -116,7 +116,7 @@ export class ModelResult<TOOLS extends readonly Tool[]> {
   // Track resolved request after async function resolution
   private resolvedRequest: models.OpenResponsesRequest | null = null;
 
-  constructor(options: GetResponseOptions<TOOLS>) {
+  constructor(options: GetResponseOptions<TTools>) {
     this.options = options;
   }
 
@@ -482,8 +482,8 @@ export class ModelResult<TOOLS extends readonly Tool[]> {
    * Multiple consumers can iterate over this stream concurrently.
    * Includes preliminary tool result events after tool execution.
    */
-  getFullResponsesStream(): AsyncIterableIterator<ResponseStreamEvent<InferToolEventsUnion<TOOLS>>> {
-    return async function* (this: ModelResult<TOOLS>) {
+  getFullResponsesStream(): AsyncIterableIterator<ResponseStreamEvent<InferToolEventsUnion<TTools {
+    return async function* (this: ModelResult<TTools>) {
       await this.initStream();
       if (!this.reusableStream) {
         throw new Error('Stream not initialized');
@@ -505,7 +505,7 @@ export class ModelResult<TOOLS extends readonly Tool[]> {
           yield {
             type: 'tool.preliminary_result' as const,
             toolCallId,
-            result: result as InferToolEventsUnion<TOOLS>,
+            result: result as InferToolEventsUnion<TTools>,
             timestamp: Date.now(),
           };
         }
@@ -518,7 +518,7 @@ export class ModelResult<TOOLS extends readonly Tool[]> {
    * This filters the full event stream to only yield text content.
    */
   getTextStream(): AsyncIterableIterator<string> {
-    return async function* (this: ModelResult<TOOLS>) {
+    return async function* (this: ModelResult<TTools>) {
       await this.initStream();
       if (!this.reusableStream) {
         throw new Error('Stream not initialized');
@@ -537,7 +537,7 @@ export class ModelResult<TOOLS extends readonly Tool[]> {
   getNewMessagesStream(): AsyncIterableIterator<
     models.ResponsesOutputMessage | models.OpenResponsesFunctionCallOutput
   > {
-    return async function* (this: ModelResult<TOOLS>) {
+    return async function* (this: ModelResult<TTools>) {
       await this.initStream();
       if (!this.reusableStream) {
         throw new Error('Stream not initialized');
@@ -575,7 +575,7 @@ export class ModelResult<TOOLS extends readonly Tool[]> {
    * This filters the full event stream to only yield reasoning content.
    */
   getReasoningStream(): AsyncIterableIterator<string> {
-    return async function* (this: ModelResult<TOOLS>) {
+    return async function* (this: ModelResult<TTools>) {
       await this.initStream();
       if (!this.reusableStream) {
         throw new Error('Stream not initialized');
@@ -591,8 +591,8 @@ export class ModelResult<TOOLS extends readonly Tool[]> {
    * - Tool call argument deltas as { type: "delta", content: string }
    * - Preliminary results as { type: "preliminary_result", toolCallId, result }
    */
-  getToolStream(): AsyncIterableIterator<ToolStreamEvent<InferToolEventsUnion<TOOLS>>> {
-    return async function* (this: ModelResult<TOOLS>) {
+  getToolStream(): AsyncIterableIterator<ToolStreamEvent<InferToolEventsUnion<TTools>>> {
+    return async function* (this: ModelResult<TTools>) {
       await this.initStream();
       if (!this.reusableStream) {
         throw new Error('Stream not initialized');
@@ -615,7 +615,7 @@ export class ModelResult<TOOLS extends readonly Tool[]> {
           yield {
             type: 'preliminary_result' as const,
             toolCallId,
-            result: result as InferToolEventsUnion<TOOLS>,
+            result: result as InferToolEventsUnion<TTools>,
           };
         }
       }
@@ -628,28 +628,28 @@ export class ModelResult<TOOLS extends readonly Tool[]> {
    * and this will return the tool calls from the initial response.
    * Returns structured tool calls with parsed arguments.
    */
-  async getToolCalls(): Promise<ParsedToolCall<TOOLS[number]>[]> {
+  async getToolCalls(): Promise<ParsedToolCall<TTools[number]>[]> {
     await this.initStream();
     if (!this.reusableStream) {
       throw new Error('Stream not initialized');
     }
 
     const completedResponse = await consumeStreamForCompletion(this.reusableStream);
-    return extractToolCallsFromResponse(completedResponse) as ParsedToolCall<TOOLS[number]>[];
+    return extractToolCallsFromResponse(completedResponse) as ParsedToolCall<TTools[number]>[];
   }
 
   /**
    * Stream structured tool call objects as they're completed.
    * Each iteration yields a complete tool call with parsed arguments.
    */
-  getToolCallsStream(): AsyncIterableIterator<ParsedToolCall<TOOLS[number]>> {
-    return async function* (this: ModelResult<TOOLS>) {
+  getToolCallsStream(): AsyncIterableIterator<ParsedToolCall<TTools[number]>> {
+    return async function* (this: ModelResult<TTools>) {
       await this.initStream();
       if (!this.reusableStream) {
         throw new Error('Stream not initialized');
       }
 
-      yield* buildToolCallStream(this.reusableStream) as AsyncIterableIterator<ParsedToolCall<TOOLS[number]>>;
+      yield* buildToolCallStream(this.reusableStream) as AsyncIterableIterator<ParsedToolCall<TTools[number]>>;
     }.call(this);
   }
 

src/lib/stop-conditions.ts

@@ -46,15 +46,15 @@ export function hasToolCall(toolName: string): StopCondition {
  * });
  * ```
  */
-export async function isStopConditionMet<TOOLS extends readonly Tool[]>(options: {
-  readonly stopConditions: ReadonlyArray<StopCondition<TOOLS>>;
-  readonly steps: ReadonlyArray<StepResult<TOOLS>>;
+export async function isStopConditionMet<TTools extends readonly Tool[]>(options: {
+  readonly stopConditions: ReadonlyArray<StopCondition<TTools>>;
+  readonly steps: ReadonlyArray<StepResult<TTools>>;
 }): Promise<boolean> {
   const { stopConditions, steps } = options;
 
   // Evaluate all conditions in parallel
   const results = await Promise.all(
-    stopConditions.map((condition: StopCondition<TOOLS>) =>
+    stopConditions.map((condition: StopCondition<TTools>) =>
       Promise.resolve(
         condition({
           steps,

src/lib/tool-types.ts

@@ -294,11 +294,11 @@ export interface Warning {
  * Result of a single step in the tool execution loop
  * Compatible with Vercel AI SDK pattern
  */
-export interface StepResult<TOOLS extends readonly Tool[] = readonly Tool[]> {
+export interface StepResult<TTools extends readonly Tool[] = readonly Tool[]> {
   readonly stepType: 'initial' | 'continue';
   readonly text: string;
-  readonly toolCalls: TypedToolCallUnion<TOOLS>[];
-  readonly toolResults: ToolExecutionResultUnion<TOOLS>[];
+  readonly toolCalls: TypedToolCallUnion<TTools>[];
+  readonly toolResults: ToolExecutionResultUnion<TTools>[];
   readonly response: models.OpenResponsesNonStreamingResponse;
   readonly usage?: models.OpenResponsesUsage | undefined;
   readonly finishReason?: string | undefined;
@@ -311,24 +311,24 @@ export interface StepResult<TOOLS extends readonly Tool[] = readonly Tool[]> {
  * Returns true to STOP execution, false to CONTINUE
  * (Matches Vercel AI SDK semantics)
  */
-export type StopCondition<TOOLS extends readonly Tool[] = readonly Tool[]> = (options: {
-  readonly steps: ReadonlyArray<StepResult<TOOLS>>;
+export type StopCondition<TTools extends readonly Tool[] = readonly Tool[]> = (options: {
+  readonly steps: ReadonlyArray<StepResult<TTools>>;
 }) => boolean | Promise<boolean>;
 
 /**
  * Stop condition configuration
  * Can be a single condition or array of conditions
  */
-export type StopWhen<TOOLS extends readonly Tool[] = readonly Tool[]> =
-  | StopCondition<TOOLS>
-  | ReadonlyArray<StopCondition<TOOLS>>;
+export type StopWhen<TTools extends readonly Tool[] = readonly Tool[]> =
+  | StopCondition<TTools>
+  | ReadonlyArray<StopCondition<TTools>>;
 
 /**
  * Result of executeTools operation
  */
-export interface ExecuteToolsResult<TOOLS extends readonly Tool[]> {
-  finalResponse: ModelResult<TOOLS>;
-  allResponses: ModelResult<TOOLS>[];
+export interface ExecuteToolsResult<TTools extends readonly Tool[]> {
+  finalResponse: ModelResult<TTools>;
+  allResponses: ModelResult<TTools>[];
   toolResults: Map<
     string,
     {

src/sdk/sdk.ts

@@ -96,10 +96,10 @@ export class OpenRouter extends ClientSDK {
   }
 
   // #region sdk-class-body
-  callModel<TOOLS extends readonly Tool[]>(
-    request: CallModelInput<TOOLS>,
+  callModel<TTools extends readonly Tool[]>(
+    request: CallModelInput<TTools>,
     options?: RequestOptions,
-  ): ModelResult<TOOLS> {
+  ): ModelResult<TTools> {
     return callModelFunc(this, request, options);
   }
   // #endregion sdk-class-body