@proteinjs/conversation 2.7.2 → 3.0.0

package/src/OpenAi.ts

@@ -60,6 +60,7 @@ export const isToolInvocationFinishEvent = (event: ToolInvocationProgressEvent):
 
 export type ToolInvocationProgressEvent = ToolInvocationStartEvent | ToolInvocationFinishEvent;
 
+/** @deprecated Use `GenerateStreamParams` from `Conversation` instead. */
 export type GenerateResponseParams = {
   messages: (string | ChatCompletionMessageParam)[];
   model?: TiktokenModel;
@@ -69,6 +70,7 @@ export type GenerateResponseParams = {
   reasoningEffort?: OpenAIApi.Chat.Completions.ChatCompletionReasoningEffort;
 };
 
+/** @deprecated Use `GenerateResponseResult` from `Conversation` instead. */
 export type GenerateResponseReturn = {
   message: string;
   usagedata: UsageData;
@@ -76,6 +78,7 @@ export type GenerateResponseReturn = {
   toolInvocations: ToolInvocationResult[];
 };
 
+/** @deprecated Use `GenerateStreamParams` from `Conversation` instead. */
 export type GenerateStreamingResponseParams = GenerateResponseParams & {
   abortSignal?: AbortSignal;
   onUsageData?: (usageData: UsageData) => Promise<void>;
@@ -90,6 +93,7 @@ type GenerateResponseHelperParams = GenerateStreamingResponseParams & {
   toolInvocations?: ToolInvocationResult[];
 };
 
+/** @deprecated Use `ConversationParams` from `Conversation` instead. */
 export type OpenAiParams = {
   model?: TiktokenModel;
   history?: MessageHistory;
@@ -99,9 +103,25 @@ export type OpenAiParams = {
   logLevel?: LogLevel;
 };
 
+/** @deprecated Use `Conversation` with `defaultModel` instead. */
 export const DEFAULT_MODEL: TiktokenModel = 'gpt-4o';
+/** @deprecated Use `GenerateStreamParams.maxToolCalls` instead. */
 export const DEFAULT_MAX_FUNCTION_CALLS = 50;
 
+/**
+ * @deprecated Use the `Conversation` class instead.
+ *
+ * `Conversation` provides multi-provider support (OpenAI, Anthropic, Google, xAI)
+ * via the Vercel AI SDK, with streaming-first text generation (`generateStream`),
+ * structured object output (`generateObject`), and a non-streaming convenience
+ * method (`generateResponse`).
+ *
+ * Migration guide:
+ * - `new OpenAi({ model, functions })` → `new Conversation({ name, modules, defaultModel })`
+ * - `openAi.generateResponse({ messages })` → `conversation.generateResponse({ messages })`
+ * - `openAi.generateStreamingResponse({ messages })` → `conversation.generateStream({ messages })`
+ * - `openAi.generateList({ messages })` → `conversation.generateObject({ messages, schema })`
+ */
 export class OpenAi {
   private model: TiktokenModel;
   private history: MessageHistory;

package/src/OpenAiStreamProcessor.ts

@@ -4,15 +4,21 @@ import { Stream } from 'openai/streaming';
 import { Readable, Transform, TransformCallback, PassThrough } from 'stream';
 import { UsageData, UsageDataAccumulator } from './UsageData';
 
+/**
+ * @deprecated Use `StreamResult.textStream` from `Conversation.generateStream` instead.
+ * The AI SDK handles streaming natively.
+ */
 export interface AssistantResponseStreamChunk {
   content?: string;
   finishReason?: string;
 }
 
 /**
- * Processes streaming responses from OpenAI's `ChatCompletions` api.
- *   - When a tool call is received, it delegates processing to `onToolCalls`; this can happen recursively
- *   - When a response to the user is received, it writes to `outputStream`
+ * @deprecated Use `Conversation.generateStream` instead.
+ *
+ * The Vercel AI SDK handles streaming tool call loops internally via
+ * `streamText()` with `execute` functions on each tool. This class
+ * is only retained for backward compatibility with the legacy `OpenAi` class.
  */
 export class OpenAiStreamProcessor {
   private logger: Logger;

package/src/UsageData.ts

@@ -246,6 +246,31 @@ export const MODEL_API_COST_USD_PER_1M_TOKENS_STANDARD: Record<string, ModelApiC
 
   'gpt-5.1-codex-mini': { inputUsdPer1M: 0.25, cachedInputUsdPer1M: 0.025, outputUsdPer1M: 2.0 },
   'codex-mini-latest': { inputUsdPer1M: 1.5, cachedInputUsdPer1M: 0.375, outputUsdPer1M: 6.0 },
+
+  // ── Anthropic Claude models ──
+  'claude-opus-4.5': { inputUsdPer1M: 5.0, cachedInputUsdPer1M: 0.5, outputUsdPer1M: 25.0 },
+  'claude-opus-4-20250514': { inputUsdPer1M: 15.0, cachedInputUsdPer1M: 1.5, outputUsdPer1M: 75.0 },
+  'claude-opus-4.1': { inputUsdPer1M: 15.0, cachedInputUsdPer1M: 1.5, outputUsdPer1M: 75.0 },
+  'claude-sonnet-4.6': { inputUsdPer1M: 3.0, cachedInputUsdPer1M: 0.3, outputUsdPer1M: 15.0 },
+  'claude-sonnet-4.5': { inputUsdPer1M: 3.0, cachedInputUsdPer1M: 0.3, outputUsdPer1M: 15.0 },
+  'claude-sonnet-4-20250514': { inputUsdPer1M: 3.0, cachedInputUsdPer1M: 0.3, outputUsdPer1M: 15.0 },
+  'claude-haiku-4.5': { inputUsdPer1M: 1.0, cachedInputUsdPer1M: 0.1, outputUsdPer1M: 5.0 },
+  'claude-3-haiku-20240307': { inputUsdPer1M: 0.25, cachedInputUsdPer1M: 0.03, outputUsdPer1M: 1.25 },
+
+  // ── Google Gemini models ──
+  'gemini-3-pro-preview': { inputUsdPer1M: 2.0, outputUsdPer1M: 12.0 },
+  'gemini-3-flash': { inputUsdPer1M: 0.5, outputUsdPer1M: 3.0 },
+  'gemini-2.5-pro': { inputUsdPer1M: 1.25, cachedInputUsdPer1M: 0.125, outputUsdPer1M: 10.0 },
+  'gemini-2.5-flash': { inputUsdPer1M: 0.3, cachedInputUsdPer1M: 0.03, outputUsdPer1M: 2.5 },
+  'gemini-2.0-flash': { inputUsdPer1M: 0.1, outputUsdPer1M: 0.4 },
+  'gemini-2.0-flash-lite': { inputUsdPer1M: 0.1, outputUsdPer1M: 0.4 },
+
+  // ── xAI Grok models ──
+  'grok-4': { inputUsdPer1M: 3.0, outputUsdPer1M: 15.0 },
+  'grok-4-fast': { inputUsdPer1M: 0.2, outputUsdPer1M: 0.5 },
+  'grok-4.1-fast': { inputUsdPer1M: 0.2, outputUsdPer1M: 0.5 },
+  'grok-3': { inputUsdPer1M: 3.0, outputUsdPer1M: 15.0 },
+  'grok-3-mini': { inputUsdPer1M: 0.3, outputUsdPer1M: 0.5 },
 };
 
 export const MODEL_API_COST_USD_PER_1M_TOKENS_BATCH: Record<string, ModelApiCost> = {

package/src/code_template/Code.ts

@@ -31,7 +31,11 @@ export class Code {
       this.addImports(this.args.imports, this.args.conversation);
     }
 
-    return await this.args.conversation.generateCode({ description: this.args.description, model: 'gpt-4' });
+    const result = await this.args.conversation.generateResponse({
+      messages: this.args.description,
+      model: 'gpt-4',
+    });
+    return result.text;
   }
 
   private addImports(imports: Import[], conversation: Conversation) {

package/src/resolveModel.ts

@@ -0,0 +1,130 @@
+import type { LanguageModel } from 'ai';
+
+/**
+ * Known provider prefixes and their model factory functions.
+ *
+ * Each factory lazily imports the provider package and creates a model instance.
+ * This keeps imports optional: if a provider package is not installed, the
+ * factory simply throws a helpful error at call time.
+ */
+const PROVIDER_FACTORIES: Record<string, (modelId: string) => LanguageModel> = {
+  openai: (modelId) => {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { openai } = require('@ai-sdk/openai');
+    return openai(modelId);
+  },
+  anthropic: (modelId) => {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { anthropic } = require('@ai-sdk/anthropic');
+    return anthropic(modelId);
+  },
+  google: (modelId) => {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { google } = require('@ai-sdk/google');
+    return google(modelId);
+  },
+  xai: (modelId) => {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { xai } = require('@ai-sdk/xai');
+    return xai(modelId);
+  },
+};
+
+/**
+ * Model name patterns that map to a provider.
+ *
+ * Order matters: first match wins. Patterns are tested against the raw model
+ * string (case-insensitive).
+ */
+const MODEL_PROVIDER_PATTERNS: Array<{ test: RegExp; provider: string }> = [
+  // OpenAI models
+  { test: /^(gpt-|o[134]-|o[134]$|chatgpt|dall-e|computer-use|codex)/i, provider: 'openai' },
+
+  // Anthropic models
+  { test: /^claude/i, provider: 'anthropic' },
+
+  // Google models
+  { test: /^(gemini|gemma)/i, provider: 'google' },
+
+  // xAI models
+  { test: /^grok/i, provider: 'xai' },
+];
+
+/**
+ * Resolve a model identifier to a concrete `LanguageModel` instance.
+ *
+ * Accepted inputs:
+ * - A `LanguageModel` instance (returned as-is)
+ * - A prefixed string like `"openai:gpt-5"` or `"anthropic:claude-sonnet-4-20250514"`
+ * - A bare model name like `"gpt-5"`, `"claude-sonnet-4-20250514"`, `"gemini-2.5-pro"`, `"grok-3"`
+ *   (provider inferred from name patterns)
+ */
+export function resolveModel(model: LanguageModel | string): LanguageModel {
+  // Already a model instance
+  if (typeof model !== 'string') {
+    return model;
+  }
+
+  const raw = model.trim();
+  if (!raw) {
+    throw new Error('resolveModel: empty model string');
+  }
+
+  // Explicit provider prefix: "provider:model-id"
+  const colonIdx = raw.indexOf(':');
+  if (colonIdx > 0) {
+    const prefix = raw.slice(0, colonIdx).toLowerCase();
+    const modelId = raw.slice(colonIdx + 1);
+    const factory = PROVIDER_FACTORIES[prefix];
+    if (!factory) {
+      throw new Error(
+        `resolveModel: unknown provider prefix "${prefix}" in "${raw}". ` +
+          `Known providers: ${Object.keys(PROVIDER_FACTORIES).join(', ')}`
+      );
+    }
+    return factory(modelId);
+  }
+
+  // Infer provider from model name patterns
+  for (const { test, provider } of MODEL_PROVIDER_PATTERNS) {
+    if (test.test(raw)) {
+      return PROVIDER_FACTORIES[provider](raw);
+    }
+  }
+
+  // Default to OpenAI for unrecognized model names
+  // (OpenAI has the most model aliases and is the most common provider)
+  return PROVIDER_FACTORIES.openai(raw);
+}
+
+/**
+ * Extract the provider name from a model identifier string.
+ * Returns 'openai', 'anthropic', 'google', 'xai', or 'unknown'.
+ */
+export function inferProvider(model: LanguageModel | string): string {
+  if (typeof model !== 'string') {
+    // Try to extract from the model's provider property if available
+    const modelId = (model as any).modelId ?? '';
+    return inferProvider(modelId);
+  }
+
+  const raw = model.trim();
+
+  // Explicit prefix
+  const colonIdx = raw.indexOf(':');
+  if (colonIdx > 0) {
+    const prefix = raw.slice(0, colonIdx).toLowerCase();
+    if (PROVIDER_FACTORIES[prefix]) {
+      return prefix;
+    }
+  }
+
+  // Pattern match
+  for (const { test, provider } of MODEL_PROVIDER_PATTERNS) {
+    if (test.test(raw)) {
+      return provider;
+    }
+  }
+
+  return 'unknown';
+}

package/test/conversation/conversation.generateObject.test.ts

@@ -0,0 +1,132 @@
+import { Conversation } from '../../src/Conversation';
+import { z } from 'zod';
+
+/**
+ * Integration tests for Conversation.generateObject.
+ *
+ * These hit the real OpenAI API (requires OPENAI_API_KEY env var).
+ * They verify structured output generation, schema strictification,
+ * JSON repair, and usage data extraction.
+ */
+
+const hasApiKey = !!process.env.OPENAI_API_KEY;
+const describeIfKey = hasApiKey ? describe : describe.skip;
+
+const TEST_MODEL = 'gpt-4.1-nano';
+const TIMEOUT = 60_000;
+
+type CountryInfo = {
+  name: string;
+  population: number;
+  continent: string;
+};
+
+type ColorList = {
+  colors: string[];
+};
+
+type PersonProfile = {
+  person: {
+    firstName: string;
+    lastName: string;
+    age: number;
+  };
+  occupation: string;
+};
+
+describeIfKey('Conversation.generateObject', () => {
+  test(
+    'returns a typed object matching a Zod schema',
+    async () => {
+      const schema = z.object({
+        name: z.string(),
+        population: z.number(),
+        continent: z.string(),
+      });
+
+      const conversation = new Conversation({ name: 'test-object-zod' });
+      const result = await conversation.generateObject<CountryInfo>({
+        messages: [
+          'Give me info about France. Return the country name, population (approximate number), and continent.',
+        ],
+        model: TEST_MODEL,
+        schema,
+      });
+
+      expect(result.object).toBeDefined();
+      expect(typeof result.object.name).toBe('string');
+      expect(typeof result.object.population).toBe('number');
+      expect(typeof result.object.continent).toBe('string');
+      expect(result.object.name.toLowerCase()).toContain('france');
+      expect(result.object.population).toBeGreaterThan(1_000_000);
+
+      // Usage should be populated
+      expect(result.usage.totalTokenUsage.inputTokens).toBeGreaterThan(0);
+      expect(result.usage.totalTokenUsage.outputTokens).toBeGreaterThan(0);
+    },
+    TIMEOUT
+  );
+
+  test(
+    'returns a typed object matching a JSON Schema',
+    async () => {
+      const jsonSchema = {
+        type: 'object',
+        properties: {
+          colors: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+        },
+        required: ['colors'],
+      };
+
+      const conversation = new Conversation({ name: 'test-object-json-schema' });
+      const result = await conversation.generateObject<ColorList>({
+        messages: ['List the 3 primary colors (red, blue, yellow).'],
+        model: TEST_MODEL,
+        schema: jsonSchema,
+      });
+
+      expect(result.object).toBeDefined();
+      expect(Array.isArray(result.object.colors)).toBe(true);
+      expect(result.object.colors.length).toBe(3);
+
+      const lower = result.object.colors.map((c) => c.toLowerCase());
+      expect(lower).toContain('red');
+      expect(lower).toContain('blue');
+      expect(lower).toContain('yellow');
+    },
+    TIMEOUT
+  );
+
+  test(
+    'handles nested object schemas (strictification)',
+    async () => {
+      const schema = z.object({
+        person: z.object({
+          firstName: z.string(),
+          lastName: z.string(),
+          age: z.number(),
+        }),
+        occupation: z.string(),
+      });
+
+      const conversation = new Conversation({ name: 'test-object-nested' });
+      const result = await conversation.generateObject<PersonProfile>({
+        messages: [
+          'Create a fictional person profile. Use firstName "Ada", lastName "Lovelace", age 36, occupation "Mathematician".',
+        ],
+        model: TEST_MODEL,
+        schema,
+      });
+
+      expect(result.object.person).toBeDefined();
+      expect(result.object.person.firstName).toBe('Ada');
+      expect(result.object.person.lastName).toBe('Lovelace');
+      expect(result.object.person.age).toBe(36);
+      expect(result.object.occupation).toBe('Mathematician');
+    },
+    TIMEOUT
+  );
+});

package/test/conversation/conversation.generateResponse.test.ts

@@ -0,0 +1,132 @@
+import { Conversation } from '../../src/Conversation';
+import { ConversationModule } from '../../src/ConversationModule';
+import { Function } from '../../src/Function';
+import { MessageModerator } from '../../src/history/MessageModerator';
+
+/**
+ * Integration tests for Conversation.generateResponse (non-streaming convenience).
+ *
+ * These hit the real OpenAI API (requires OPENAI_API_KEY env var).
+ */
+
+const hasApiKey = !!process.env.OPENAI_API_KEY;
+const describeIfKey = hasApiKey ? describe : describe.skip;
+
+const TEST_MODEL = 'gpt-4.1-nano';
+const TIMEOUT = 60_000;
+
+function createTestModule(systemMessage: string, functions: Function[]): ConversationModule {
+  return {
+    getName: () => 'TestModule',
+    getSystemMessages: () => [systemMessage],
+    getFunctions: () => functions,
+    getMessageModerators: () => [] as MessageModerator[],
+  };
+}
+
+describeIfKey('Conversation.generateResponse', () => {
+  test(
+    'returns a complete text response with usage',
+    async () => {
+      const conversation = new Conversation({ name: 'test-response' });
+      const result = await conversation.generateResponse({
+        messages: ['Say "hello" and nothing else.'],
+        model: TEST_MODEL,
+      });
+
+      expect(result.text.toLowerCase()).toContain('hello');
+      expect(result.usage.totalTokenUsage.inputTokens).toBeGreaterThan(0);
+      expect(result.usage.totalTokenUsage.outputTokens).toBeGreaterThan(0);
+      expect(result.toolInvocations).toEqual([]);
+    },
+    TIMEOUT
+  );
+
+  test(
+    'accumulates usage across multiple tool call steps',
+    async () => {
+      const lookupCalls: string[] = [];
+
+      const lookupTool: Function = {
+        definition: {
+          name: 'lookupCapital',
+          description: 'Looks up the capital city of a country.',
+          parameters: {
+            type: 'object',
+            properties: {
+              country: { type: 'string', description: 'The country name' },
+            },
+            required: ['country'],
+          },
+        },
+        async call(args: { country: string }) {
+          lookupCalls.push(args.country);
+          const capitals: Record<string, string> = {
+            france: 'Paris',
+            japan: 'Tokyo',
+            brazil: 'Brasília',
+          };
+          return { capital: capitals[args.country.toLowerCase()] ?? 'Unknown' };
+        },
+      };
+
+      const conversation = new Conversation({
+        name: 'test-multi-tool',
+        modules: [
+          createTestModule(
+            'You are a geography assistant. Use lookupCapital for each country the user asks about. Make a separate call for each country.',
+            [lookupTool]
+          ),
+        ],
+      });
+
+      const result = await conversation.generateResponse({
+        messages: ['What are the capitals of France, Japan, and Brazil?'],
+        model: TEST_MODEL,
+      });
+
+      // Should have called the tool at least 2 times (ideally 3, but LLMs can batch)
+      expect(lookupCalls.length).toBeGreaterThanOrEqual(2);
+
+      // Response should mention the capitals
+      expect(result.text).toContain('Paris');
+      expect(result.text).toContain('Tokyo');
+
+      // Usage should reflect multiple steps
+      expect(result.usage.totalRequestsToAssistant).toBeGreaterThanOrEqual(2);
+      expect(result.usage.totalToolCalls).toBeGreaterThanOrEqual(2);
+      expect(result.usage.callsPerTool['lookupCapital']).toBeGreaterThanOrEqual(2);
+
+      // Total tokens should be substantial (multiple round trips)
+      expect(result.usage.totalTokenUsage.inputTokens).toBeGreaterThan(50);
+      expect(result.usage.totalTokenUsage.outputTokens).toBeGreaterThan(10);
+
+      // Cost should be calculated (gpt-4.1-nano is in our pricing table)
+      expect(result.usage.totalCostUsd.totalUsd).toBeGreaterThanOrEqual(0);
+    },
+    TIMEOUT
+  );
+
+  test(
+    'handles conversation modules with system messages',
+    async () => {
+      const conversation = new Conversation({
+        name: 'test-system-msg',
+        modules: [createTestModule('You are a pirate. Always respond in pirate speak.', [])],
+      });
+
+      const result = await conversation.generateResponse({
+        messages: ['Say hello.'],
+        model: TEST_MODEL,
+      });
+
+      // Should have pirate-ish language
+      const lower = result.text.toLowerCase();
+      const hasPirateWord = ['ahoy', 'matey', 'arr', 'ye', 'aye', 'avast', 'yarr', 'shiver'].some((w) =>
+        lower.includes(w)
+      );
+      expect(hasPirateWord).toBe(true);
+    },
+    TIMEOUT
+  );
+});

package/test/conversation/conversation.generateStream.test.ts

@@ -0,0 +1,173 @@
+import { Conversation } from '../../src/Conversation';
+import { ConversationModule } from '../../src/ConversationModule';
+import { Function } from '../../src/Function';
+import { MessageModerator } from '../../src/history/MessageModerator';
+
+/**
+ * Integration tests for Conversation.generateStream.
+ *
+ * These hit the real OpenAI API (requires OPENAI_API_KEY env var).
+ * They verify the full path through the AI SDK: message building,
+ * tool schema wiring, streaming, usage extraction, and tool invocation reporting.
+ */
+
+const hasApiKey = !!process.env.OPENAI_API_KEY;
+const describeIfKey = hasApiKey ? describe : describe.skip;
+
+const TEST_MODEL = 'gpt-4.1-nano';
+const TIMEOUT = 60_000;
+
+/** A simple tool that adds two numbers. */
+function createAddTool(): { fn: Function; calls: Array<{ a: number; b: number }> } {
+  const calls: Array<{ a: number; b: number }> = [];
+  const fn: Function = {
+    definition: {
+      name: 'addNumbers',
+      description: 'Adds two numbers together and returns the sum.',
+      parameters: {
+        type: 'object',
+        properties: {
+          a: { type: 'number', description: 'First number' },
+          b: { type: 'number', description: 'Second number' },
+        },
+        required: ['a', 'b'],
+      },
+    },
+    async call(args: { a: number; b: number }) {
+      calls.push(args);
+      return { sum: args.a + args.b };
+    },
+  };
+  return { fn, calls };
+}
+
+/** A tool with no parameters (the case that caused the type: "None" bug). */
+function createNoParamTool(): { fn: Function; callCount: number[] } {
+  const callCount = [0];
+  const fn: Function = {
+    definition: {
+      name: 'getServerTime',
+      description: 'Returns the current server time. Takes no parameters.',
+    },
+    async call() {
+      callCount[0]++;
+      return { time: new Date().toISOString() };
+    },
+  };
+  return { fn, callCount };
+}
+
+/** A simple module that provides a system message and a tool. */
+function createTestModule(systemMessage: string, functions: Function[]): ConversationModule {
+  return {
+    getName: () => 'TestModule',
+    getSystemMessages: () => [systemMessage],
+    getFunctions: () => functions,
+    getMessageModerators: () => [] as MessageModerator[],
+  };
+}
+
+describeIfKey('Conversation.generateStream', () => {
+  test(
+    'streams a text response and resolves usage data',
+    async () => {
+      const conversation = new Conversation({ name: 'test-stream' });
+
+      const result = await conversation.generateStream({
+        messages: ['What is 2+2? Reply with just the number.'],
+        model: TEST_MODEL,
+      });
+
+      // Collect streamed text
+      const chunks: string[] = [];
+      for await (const chunk of result.textStream) {
+        chunks.push(chunk);
+      }
+
+      // Should have streamed something
+      expect(chunks.length).toBeGreaterThan(0);
+
+      // Full text should resolve and contain "4"
+      const text = await result.text;
+      expect(text).toContain('4');
+
+      // Usage data should be populated with non-zero tokens
+      const usage = await result.usage;
+      expect(usage.totalTokenUsage.inputTokens).toBeGreaterThan(0);
+      expect(usage.totalTokenUsage.outputTokens).toBeGreaterThan(0);
+      expect(usage.totalTokenUsage.totalTokens).toBeGreaterThan(0);
+      expect(usage.model).toBeTruthy();
+    },
+    TIMEOUT
+  );
+
+  test(
+    'invokes a tool with parameters and reports tool invocations',
+    async () => {
+      const { fn: addTool, calls } = createAddTool();
+
+      const conversation = new Conversation({
+        name: 'test-tool-call',
+        modules: [createTestModule('You are a calculator. Use the addNumbers tool to compute sums.', [addTool])],
+      });
+
+      const result = await conversation.generateStream({
+        messages: ['What is 7 + 13?'],
+        model: TEST_MODEL,
+      });
+
+      // Consume the stream
+      const text = await result.text;
+      const usage = await result.usage;
+      const toolInvocations = await result.toolInvocations;
+
+      // The tool should have been called
+      expect(calls.length).toBeGreaterThan(0);
+      expect(calls[0].a + calls[0].b).toBe(20);
+
+      // The response should contain "20"
+      expect(text).toContain('20');
+
+      // Tool invocations should be reported
+      expect(toolInvocations.length).toBeGreaterThan(0);
+      expect(toolInvocations[0].name).toBe('addNumbers');
+
+      // Usage should reflect multiple steps (at least one tool call step + final response)
+      expect(usage.totalRequestsToAssistant).toBeGreaterThanOrEqual(2);
+      expect(usage.totalToolCalls).toBeGreaterThan(0);
+      expect(usage.callsPerTool['addNumbers']).toBeGreaterThan(0);
+    },
+    TIMEOUT
+  );
+
+  test(
+    'handles a tool with no parameters (the type: "None" regression)',
+    async () => {
+      const { fn: noParamTool, callCount } = createNoParamTool();
+
+      const conversation = new Conversation({
+        name: 'test-no-param-tool',
+        modules: [
+          createTestModule('You have access to a getServerTime tool. When the user asks for the time, call it.', [
+            noParamTool,
+          ]),
+        ],
+      });
+
+      const result = await conversation.generateStream({
+        messages: ['What time is it on the server?'],
+        model: TEST_MODEL,
+      });
+
+      // This should not throw — the old bug caused an API error here
+      const text = await result.text;
+      const toolInvocations = await result.toolInvocations;
+
+      // The tool should have been called
+      expect(callCount[0]).toBeGreaterThan(0);
+      expect(toolInvocations.length).toBeGreaterThan(0);
+      expect(toolInvocations[0].name).toBe('getServerTime');
+    },
+    TIMEOUT
+  );
+});