@output.ai/llm 0.2.11 → 0.2.13-dev.pr306-3f50755

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/llm",
-  "version": "0.2.11",
+  "version": "0.2.13-dev.pr306-3f50755",
   "description": "Framework abstraction to interact with LLM models",
   "type": "module",
   "main": "src/index.js",

package/src/ai_sdk.js

@@ -51,6 +51,9 @@ const aiSdkOptionsFromPrompt = prompt => {
 
   if ( prompt.config.maxTokens ) {
     options.maxOutputTokens = prompt.config.maxTokens;
+  } else if ( prompt.config.provider === 'anthropic' ) {
+    // Override Anthropic SDK's low 4096 default - Claude models support up to 64k output tokens
+    options.maxOutputTokens = 64000;
   }
 
   const tools = loadTools( prompt );

package/src/ai_sdk.spec.js

@@ -221,6 +221,7 @@ describe( 'ai_sdk', () => {
     expect( aiFns.generateText ).toHaveBeenCalledWith( {
       model: 'MODEL',
       messages: promptWithProviderOptions.messages,
+      maxOutputTokens: 64000,
       providerOptions: {
         thinking: {
           type: 'enabled',
@@ -339,6 +340,7 @@ describe( 'ai_sdk', () => {
       enum: [ 'A', 'B', 'C' ],
       model: 'MODEL',
       messages: promptWithMixedOptions.messages,
+      maxOutputTokens: 64000,
       providerOptions: {
         thinking: {
           type: 'enabled',

package/src/generate_text_types.spec.ts

@@ -0,0 +1,163 @@
+/**
+ * Type-level tests for generateText multi-step options.
+ * These tests verify that TypeScript accepts the new options without casting to `any`.
+ */
+import { describe, it, expect, vi, expectTypeOf } from 'vitest';
+import type { ToolSet } from 'ai';
+import type { generateText, GenerateTextResult } from './index.d.ts';
+
+// Mock generateText for type-checking tests
+const mockGenerateText = vi.fn() as unknown as typeof generateText;
+
+describe( 'generateText type definitions', () => {
+  describe( 'maxSteps option', () => {
+    it( 'should accept maxSteps as a valid option', () => {
+      // This function definition verifies TypeScript accepts maxSteps
+      const callWithMaxSteps = () =>
+        mockGenerateText( {
+          prompt: 'test-prompt',
+          maxSteps: 5
+        } );
+
+      expect( callWithMaxSteps ).toBeDefined();
+    } );
+
+    it( 'should accept maxSteps with tools', () => {
+      const callWithToolsAndMaxSteps = () =>
+        mockGenerateText( {
+          prompt: 'test-prompt',
+          tools: {} as ToolSet,
+          maxSteps: 5
+        } );
+
+      expect( callWithToolsAndMaxSteps ).toBeDefined();
+    } );
+
+    it( 'should accept maxSteps with variables and tools (user pattern)', () => {
+      // This test mimics the exact user pattern that was failing
+      const providerConfig = {
+        promptName: 'test-prompt',
+        tools: {} as ToolSet
+      };
+      const query = 'test query';
+      const input = {
+        successCriteria: 'Answer with relevant information',
+        sourceRequirements: '',
+        searchDepth: 'basic',
+        importance: 'low'
+      };
+      const previousFindings = '';
+      const iteration = 1;
+
+      const callWithUserPattern = () =>
+        mockGenerateText( {
+          prompt: providerConfig.promptName,
+          variables: {
+            query,
+            successCriteria: input.successCriteria || 'Answer with relevant information',
+            sourceRequirements: input.sourceRequirements || '',
+            searchDepth: input.searchDepth || 'basic',
+            priority: input.importance || 'low',
+            previousFindings: previousFindings || '',
+            iteration: String( iteration ),
+            currentDate: new Date().toISOString().split( 'T' )[0]
+          },
+          tools: providerConfig.tools,
+          maxSteps: 5 // Allow up to 5 tool execution rounds
+        } );
+
+      expect( callWithUserPattern ).toBeDefined();
+    } );
+  } );
+
+  describe( 'stopWhen option', () => {
+    it( 'should accept stopWhen callback', () => {
+      const callWithStopWhen = () =>
+        mockGenerateText( {
+          prompt: 'test-prompt',
+          tools: {} as ToolSet,
+          maxSteps: 10,
+          stopWhen: ( { steps } ) => steps.length >= 3
+        } );
+
+      expect( callWithStopWhen ).toBeDefined();
+    } );
+  } );
+
+  describe( 'onStepFinish callback', () => {
+    it( 'should accept onStepFinish callback', () => {
+      const callWithOnStepFinish = () =>
+        mockGenerateText( {
+          prompt: 'test-prompt',
+          tools: {} as ToolSet,
+          maxSteps: 5,
+          onStepFinish: async step => {
+            // step.text should be accessible
+            console.log( step.text );
+          }
+        } );
+
+      expect( callWithOnStepFinish ).toBeDefined();
+    } );
+  } );
+
+  describe( 'prepareStep callback', () => {
+    it( 'should accept prepareStep callback with correct parameters', () => {
+      const callWithPrepareStep = () =>
+        mockGenerateText( {
+          prompt: 'test-prompt',
+          tools: {} as ToolSet,
+          maxSteps: 5,
+          prepareStep: ( { steps, stepNumber } ) => {
+            // steps and stepNumber should be accessible
+            if ( stepNumber > 3 || steps.length > 2 ) {
+              return { toolChoice: 'none' as const };
+            }
+            return {};
+          }
+        } );
+
+      expect( callWithPrepareStep ).toBeDefined();
+    } );
+  } );
+
+  describe( 'GenerateTextResult type', () => {
+    it( 'should be generic over TOOLS', () => {
+      // Verify GenerateTextResult accepts a TOOLS type parameter
+      type Result = GenerateTextResult<ToolSet>;
+
+      // Result should have steps, text, and result properties
+      expectTypeOf<Result>().toHaveProperty( 'steps' );
+      expectTypeOf<Result>().toHaveProperty( 'text' );
+      expectTypeOf<Result>().toHaveProperty( 'result' );
+    } );
+
+    it( 'should have result as string alias for text', () => {
+      type Result = GenerateTextResult;
+      expectTypeOf<Result['result']>().toBeString();
+      expectTypeOf<Result['text']>().toBeString();
+    } );
+  } );
+
+  describe( 'combined multi-step options', () => {
+    it( 'should accept all multi-step options together', () => {
+      const callWithAllOptions = () =>
+        mockGenerateText( {
+          prompt: 'test-prompt',
+          variables: { topic: 'testing' },
+          tools: {} as ToolSet,
+          toolChoice: 'auto',
+          maxSteps: 5,
+          stopWhen: ( { steps } ) => steps.length >= 3,
+          onStepFinish: async step => {
+            console.log( 'Step:', step.text );
+          },
+          prepareStep: ( { stepNumber } ) => {
+            return stepNumber > 3 ? { toolChoice: 'required' as const } : {};
+          }
+        } );
+
+      expect( callWithAllOptions ).toBeDefined();
+    } );
+  } );
+} );

package/src/index.d.ts

@@ -4,7 +4,10 @@ import type {
   GenerateObjectResult as AIGenerateObjectResult,
   CallSettings,
   ToolSet,
-  ToolChoice
+  ToolChoice,
+  StopCondition,
+  GenerateTextOnStepFinishCallback,
+  PrepareStepFunction
 } from 'ai';
 
 /**
@@ -100,12 +103,20 @@ export type {
   CallSettings,
   ToolSet,
   ToolChoice,
-  Tool
+  Tool,
+  StopCondition,
+  StepResult,
+  GenerateTextOnStepFinishCallback,
+  PrepareStepFunction,
+  PrepareStepResult
 } from 'ai';
 
 // Re-export the tool helper function for creating tools
 export { tool } from 'ai';
 
+// Re-export stop condition helpers for multi-step workflows
+export { stepCountIs, hasToolCall } from 'ai';
+
 /**
  * Common AI SDK options that can be passed through to all generate functions.
  * These options are passed directly to the underlying AI SDK call.
@@ -113,7 +124,7 @@ export { tool } from 'ai';
 type AiSdkOptions = Partial<Omit<CallSettings, 'maxOutputTokens'>>;
 
 /**
- * AI SDK options specific to generateText, including tool calling support.
+ * AI SDK options specific to generateText, including tool calling and multi-step support.
  * @typeParam TOOLS - The tools available for the model to call
  */
 type GenerateTextAiSdkOptions<TOOLS extends ToolSet = ToolSet> = AiSdkOptions & {
@@ -123,14 +134,23 @@ type GenerateTextAiSdkOptions<TOOLS extends ToolSet = ToolSet> = AiSdkOptions &
   toolChoice?: ToolChoice<TOOLS>;
   /** Limit which tools are active without changing types */
   activeTools?: Array<keyof TOOLS>;
+  /** Maximum number of automatic tool execution rounds (multi-step) */
+  maxSteps?: number;
+  /** Custom stop conditions for multi-step execution */
+  stopWhen?: StopCondition<TOOLS> | StopCondition<TOOLS>[];
+  /** Callback after each step completes */
+  onStepFinish?: GenerateTextOnStepFinishCallback<TOOLS>;
+  /** Customize each step before execution */
+  prepareStep?: PrepareStepFunction<TOOLS>;
 };
 
 /**
  * Result from generateText including full AI SDK response metadata.
  * Extends AI SDK's GenerateTextResult with a unified `result` field.
+ * @typeParam TOOLS - The tools available for the model to call (preserves typing on steps)
  */
-export type GenerateTextResult =
-  AIGenerateTextResult<Record<string, never>, unknown> & {
+export type GenerateTextResult<TOOLS extends ToolSet = ToolSet> =
+  AIGenerateTextResult<TOOLS, unknown> & {
     /** Unified field name alias for 'text' - provides consistency across all generate* functions */
     result: string;
   };
@@ -177,7 +197,7 @@ export function generateText<TOOLS extends ToolSet = ToolSet>(
     prompt: string,
     variables?: Record<string, string | number | boolean>
   } & GenerateTextAiSdkOptions<TOOLS>
-): Promise<GenerateTextResult>;
+): Promise<GenerateTextResult<TOOLS>>;
 
 /**
  * Use an LLM model to generate an object with a fixed schema.