ai-world-sdk 1.5.11 → 1.5.13

package/pacakges/ai-sdk-provider/e2e/gemini/reasoning-multiturn.test.ts

@@ -1,221 +0,0 @@
-/**
- * Test for Gemini multi-turn tool calls with reasoning/thinking enabled
- *
- * This test verifies that when using Gemini models with thinking enabled,
- * the reasoning_details (thoughtSignature) are properly preserved in tool calls
- * and can be sent back in multi-turn conversations.
- *
- * The providerOptions containing reasoning_details must be preserved when
- * passing response.messages from a first request to a second request,
- * otherwise Gemini will reject the continuation.
- */
-import { generateText, streamText, tool } from 'ai';
-import { describe, expect, it, vi } from 'vitest';
-import { z } from 'zod/v4';
-import { writeOutputJsonFile } from '@/e2e/utils';
-import { createOpenRouter } from '@/src';
-
-vi.setConfig({
-  testTimeout: 120_000,
-});
-
-const weatherTool = tool({
-  description: 'Gets the current weather for a location',
-  inputSchema: z.object({
-    location: z.string().describe('The city and state, e.g. San Francisco, CA'),
-  }),
-  execute: async () => {
-    return {
-      temperature: 72,
-      conditions: 'Sunny',
-    };
-  },
-});
-
-describe('Gemini multi-turn tool calls with reasoning', () => {
-  it('should preserve reasoning_details with streamText', async () => {
-    const openrouter = createOpenRouter({
-      apiKey: process.env.OPENROUTER_API_KEY,
-      baseUrl: `${process.env.OPENROUTER_API_BASE}/api/v1`,
-    });
-
-    const model = openrouter('google/gemini-3-flash-preview');
-
-    const firstResult = await streamText({
-      model,
-      system:
-        'You are a helpful weather assistant. Use the weatherTool to answer weather questions.',
-      prompt: 'What is the weather in San Francisco?',
-      tools: { weatherTool },
-      providerOptions: {
-        openrouter: {
-          includeReasoning: true,
-        },
-      },
-    });
-
-    const firstResponse = await firstResult.response;
-
-    await writeOutputJsonFile({
-      fileName: 'streamText-firstResponse.ignore.json',
-      fileData: {
-        messages: firstResponse.messages,
-        text: firstResult.text,
-      },
-      baseUrl: import.meta.url,
-    });
-
-    const assistantMessage = firstResponse.messages.find(
-      (m) => m.role === 'assistant',
-    );
-    expect(assistantMessage).toBeDefined();
-
-    const assistantContent = assistantMessage?.content;
-    expect(Array.isArray(assistantContent)).toBe(true);
-
-    const contentArray = assistantContent as Array<{
-      type: string;
-      providerOptions?: Record<string, unknown>;
-    }>;
-    const toolCallContent = contentArray.find((c) => c.type === 'tool-call');
-    expect(toolCallContent).toBeDefined();
-
-    const toolCallProviderOptions = toolCallContent?.providerOptions as
-      | Record<string, Record<string, unknown>>
-      | undefined;
-
-    expect(toolCallProviderOptions).toBeDefined();
-
-    const reasoningDetails = toolCallProviderOptions?.openrouter
-      ?.reasoning_details as
-      | Array<{ type: string; data?: string; format?: string }>
-      | undefined;
-
-    expect(reasoningDetails).toBeDefined();
-    expect(Array.isArray(reasoningDetails)).toBe(true);
-    expect(reasoningDetails?.length).toBeGreaterThan(0);
-
-    const firstReasoningDetail = reasoningDetails?.[0];
-    expect(firstReasoningDetail?.type).toBe('reasoning.encrypted');
-    expect(firstReasoningDetail?.data).toBeDefined();
-    expect(firstReasoningDetail?.format).toBe('google-gemini-v1');
-
-    const secondResult = await streamText({
-      model,
-      system:
-        'You are a helpful weather assistant. Use the weatherTool to answer weather questions.',
-      messages: firstResponse.messages,
-      tools: { weatherTool },
-      providerOptions: {
-        openrouter: {
-          includeReasoning: true,
-        },
-      },
-    });
-
-    const secondText = await secondResult.text;
-
-    expect(secondText).toBeDefined();
-    expect(secondText.length).toBeGreaterThan(0);
-
-    const lowerText = secondText.toLowerCase();
-    const hasWeatherInfo =
-      lowerText.includes('72') ||
-      lowerText.includes('sunny') ||
-      lowerText.includes('weather') ||
-      lowerText.includes('san francisco');
-    expect(hasWeatherInfo).toBe(true);
-  });
-
-  it('should preserve reasoning_details with generateText', async () => {
-    const openrouter = createOpenRouter({
-      apiKey: process.env.OPENROUTER_API_KEY,
-      baseUrl: `${process.env.OPENROUTER_API_BASE}/api/v1`,
-    });
-
-    const model = openrouter('google/gemini-3-flash-preview');
-
-    const firstResult = await generateText({
-      model,
-      system:
-        'You are a helpful weather assistant. Use the weatherTool to answer weather questions.',
-      prompt: 'What is the weather in San Francisco?',
-      tools: { weatherTool },
-      providerOptions: {
-        openrouter: {
-          includeReasoning: true,
-        },
-      },
-    });
-
-    const firstResponse = await firstResult.response;
-
-    await writeOutputJsonFile({
-      fileName: 'generateText-firstResponse.ignore.json',
-      fileData: {
-        messages: firstResponse.messages,
-        text: firstResult.text,
-      },
-      baseUrl: import.meta.url,
-    });
-
-    const assistantMessage = firstResponse.messages.find(
-      (m) => m.role === 'assistant',
-    );
-    expect(assistantMessage).toBeDefined();
-
-    const assistantContent = assistantMessage?.content;
-    expect(Array.isArray(assistantContent)).toBe(true);
-
-    const contentArray = assistantContent as Array<{
-      type: string;
-      providerOptions?: Record<string, unknown>;
-    }>;
-    const toolCallContent = contentArray.find((c) => c.type === 'tool-call');
-    expect(toolCallContent).toBeDefined();
-
-    const toolCallProviderOptions = toolCallContent?.providerOptions as
-      | Record<string, Record<string, unknown>>
-      | undefined;
-
-    expect(toolCallProviderOptions).toBeDefined();
-
-    const reasoningDetails = toolCallProviderOptions?.openrouter
-      ?.reasoning_details as
-      | Array<{ type: string; data?: string; format?: string }>
-      | undefined;
-
-    expect(reasoningDetails).toBeDefined();
-    expect(Array.isArray(reasoningDetails)).toBe(true);
-    expect(reasoningDetails?.length).toBeGreaterThan(0);
-
-    const firstReasoningDetail = reasoningDetails?.[0];
-    expect(firstReasoningDetail?.type).toBe('reasoning.encrypted');
-    expect(firstReasoningDetail?.data).toBeDefined();
-    expect(firstReasoningDetail?.format).toBe('google-gemini-v1');
-
-    const secondResult = await generateText({
-      model,
-      system:
-        'You are a helpful weather assistant. Use the weatherTool to answer weather questions.',
-      messages: firstResponse.messages,
-      tools: { weatherTool },
-      providerOptions: {
-        openrouter: {
-          includeReasoning: true,
-        },
-      },
-    });
-
-    expect(secondResult.text).toBeDefined();
-    expect(secondResult.text.length).toBeGreaterThan(0);
-
-    const lowerText = secondResult.text.toLowerCase();
-    const hasWeatherInfo =
-      lowerText.includes('72') ||
-      lowerText.includes('sunny') ||
-      lowerText.includes('weather') ||
-      lowerText.includes('san francisco');
-    expect(hasWeatherInfo).toBe(true);
-  });
-});

package/pacakges/ai-sdk-provider/e2e/issues/issue-160-toolcallid-uniqueness.test.ts

@@ -1,88 +0,0 @@
-/**
- * Regression test for GitHub issue #160
- * https://github.com/OpenRouterTeam/ai-sdk-provider/issues/160
- *
- * Reported error: toolCallId is not unique across models/providers, causing
- * tool result matching failures in multi-turn conversations. When tool call
- * IDs are empty, null, or duplicated, tool results get mismatched or lost.
- *
- * A comment from Sept 2025 noted that Gemini added random IDs, resolving
- * the issue at the API level. This test verifies that the SDK returns
- * unique tool call IDs for parallel tool calls across both streaming and
- * non-streaming paths.
- */
-import { generateText, streamText, tool } from 'ai';
-import { describe, expect, it, vi } from 'vitest';
-import { z } from 'zod/v4';
-import { createOpenRouter } from '@/src';
-
-vi.setConfig({
-  testTimeout: 60_000,
-});
-
-describe('Issue #160: toolCallId uniqueness for parallel tool calls', () => {
-  const openrouter = createOpenRouter({
-    apiKey: process.env.OPENROUTER_API_KEY,
-    baseUrl: `${process.env.OPENROUTER_API_BASE}/api/v1`,
-  });
-
-  // Use the model from the issue report (Gemini) which was known to
-  // return non-unique tool call IDs.
-  const model = openrouter('google/gemini-2.5-flash');
-
-  const weatherTool = tool({
-    description: 'Gets the weather for a given city',
-    inputSchema: z.object({
-      city: z.string().describe('The city to get the weather for'),
-    }),
-    execute: async ({ city }) => {
-      return { city, temperature: 22, conditions: 'sunny' };
-    },
-  });
-
-  it('should return unique toolCallIds for parallel tool calls (non-streaming)', async () => {
-    const response = await generateText({
-      model,
-      prompt:
-        'What is the weather in Tokyo, London, and Paris? Call the get_weather tool for each city in parallel.',
-      tools: { get_weather: weatherTool },
-      toolChoice: 'required',
-    });
-
-    const toolCalls = response.steps.flatMap((step) => step.toolCalls || []);
-    expect(toolCalls.length).toBeGreaterThanOrEqual(2);
-
-    // All tool call IDs must be unique and non-empty
-    const ids = toolCalls.map((tc) => tc.toolCallId);
-    expect(new Set(ids).size).toBe(ids.length);
-    for (const id of ids) {
-      expect(id).toBeTruthy();
-    }
-  });
-
-  it('should return unique toolCallIds for parallel tool calls (streaming)', async () => {
-    const response = await streamText({
-      model,
-      prompt:
-        'What is the weather in Tokyo, London, and Paris? Call the get_weather tool for each city in parallel.',
-      tools: { get_weather: weatherTool },
-      toolChoice: 'required',
-    });
-
-    const toolCalls: Array<{ toolCallId: string }> = [];
-    for await (const part of response.fullStream) {
-      if (part.type === 'tool-call') {
-        toolCalls.push({ toolCallId: part.toolCallId });
-      }
-    }
-
-    expect(toolCalls.length).toBeGreaterThanOrEqual(2);
-
-    // All tool call IDs must be unique and non-empty
-    const ids = toolCalls.map((tc) => tc.toolCallId);
-    expect(new Set(ids).size).toBe(ids.length);
-    for (const id of ids) {
-      expect(id).toBeTruthy();
-    }
-  });
-});

package/pacakges/ai-sdk-provider/e2e/issues/issue-166-finish-reason-null.test.ts

@@ -1,129 +0,0 @@
-/**
- * Regression test for GitHub Issue #166 — finish_reason is null for some models
- * https://github.com/OpenRouterTeam/ai-sdk-provider/issues/166
- *
- * Reported error: Some models return `finish_reason: null` in streaming responses
- * even when tool calls are present. This causes the AI SDK to see finishReason as
- * 'other' instead of 'tool-calls', breaking agentic loops that rely on
- * finishReason === 'tool-calls' to continue iterating.
- *
- * Models mentioned: google/gemini-2.5-flash, various free-tier models.
- *
- * The fix: In both doGenerate and doStream, when tool calls are present but
- * finishReason maps to 'other' (which includes null/undefined/unrecognized values),
- * override finishReason to 'tool-calls' so agentic loops continue correctly.
- */
-import { generateText, stepCountIs, streamText, tool } from 'ai';
-import { describe, expect, it, vi } from 'vitest';
-import { z } from 'zod/v4';
-import { createOpenRouter } from '@/src';
-
-vi.setConfig({
-  testTimeout: 120_000,
-});
-
-const weatherTool = tool({
-  description: 'Get the current weather for a location',
-  inputSchema: z.object({
-    city: z.string().describe('The city to get weather for'),
-  }),
-  execute: async () => ({
-    temperature: 22,
-    condition: 'sunny',
-  }),
-});
-
-describe('Issue #166: finish_reason null should not break agentic loops', () => {
-  const provider = createOpenRouter({
-    apiKey: process.env.OPENROUTER_API_KEY,
-    baseUrl: `${process.env.OPENROUTER_API_BASE}/api/v1`,
-  });
-
-  it('should return tool-calls finishReason when streaming with tools (google/gemini-2.5-flash)', async () => {
-    const response = streamText({
-      model: provider('google/gemini-2.5-flash'),
-      messages: [
-        {
-          role: 'user',
-          content: 'What is the weather in Tokyo? Use the get_weather tool.',
-        },
-      ],
-      tools: {
-        get_weather: weatherTool,
-      },
-    });
-
-    await response.consumeStream();
-    const finishReason = await response.finishReason;
-    const toolCalls = await response.toolCalls;
-
-    // If the model made tool calls, finishReason must be 'tool-calls'
-    if (toolCalls && toolCalls.length > 0) {
-      expect(finishReason).toBe('tool-calls');
-    }
-  });
-
-  it('should return tool-calls finishReason when streaming with tools (openai/gpt-4o-mini)', async () => {
-    const response = streamText({
-      model: provider('openai/gpt-4o-mini'),
-      messages: [
-        {
-          role: 'user',
-          content: 'What is the weather in Tokyo? Use the get_weather tool.',
-        },
-      ],
-      tools: {
-        get_weather: weatherTool,
-      },
-    });
-
-    await response.consumeStream();
-    const finishReason = await response.finishReason;
-    const toolCalls = await response.toolCalls;
-
-    if (toolCalls && toolCalls.length > 0) {
-      expect(finishReason).toBe('tool-calls');
-    }
-  });
-
-  it('should return tool-calls finishReason in generateText with tools (google/gemini-2.5-flash)', async () => {
-    const result = await generateText({
-      model: provider('google/gemini-2.5-flash'),
-      messages: [
-        {
-          role: 'user',
-          content: 'What is the weather in Tokyo? Use the get_weather tool.',
-        },
-      ],
-      tools: {
-        get_weather: weatherTool,
-      },
-    });
-
-    if (result.toolCalls && result.toolCalls.length > 0) {
-      expect(result.finishReason).toBe('tool-calls');
-    }
-  });
-
-  it('should complete a full agentic loop without breaking (google/gemini-2.5-flash)', async () => {
-    const result = await generateText({
-      model: provider('google/gemini-2.5-flash'),
-      messages: [
-        {
-          role: 'user',
-          content: 'What is the weather in Tokyo?',
-        },
-      ],
-      tools: {
-        get_weather: weatherTool,
-      },
-      stopWhen: stepCountIs(3),
-    });
-
-    // The agentic loop should complete without errors.
-    // If finish_reason were incorrectly mapped, the loop would stop
-    // after the first tool call instead of continuing to produce a final answer.
-    expect(result.steps.length).toBeGreaterThanOrEqual(1);
-    expect(result.text.length).toBeGreaterThan(0);
-  });
-});

package/pacakges/ai-sdk-provider/e2e/issues/issue-171-cache-tool-key-ordering.test.ts

@@ -1,70 +0,0 @@
-/**
- * Regression test for GitHub issue #171
- * https://github.com/OpenRouterTeam/ai-sdk-provider/issues/171
- *
- * Issue: "Cache broken when using tools"
- *
- * When the AI SDK deserializes and re-serializes tool call arguments across
- * turns, the key insertion order may change (e.g., {"city":"Tokyo","unit":"celsius"}
- * becomes {"unit":"celsius","city":"Tokyo"}). This produces different strings
- * for semantically identical objects, which breaks prompt caching because the
- * cache key includes the serialized tool call arguments verbatim.
- *
- * This test verifies that tool call arguments are serialized deterministically
- * in a multi-turn conversation where tool results are sent back.
- */
-import { generateText, tool } from 'ai';
-import { describe, expect, it, vi } from 'vitest';
-import { z } from 'zod/v4';
-import { createOpenRouter } from '@/src';
-
-vi.setConfig({
-  testTimeout: 60_000,
-});
-
-describe('Issue #171: Cache broken when using tools - key ordering', () => {
-  const openrouter = createOpenRouter({
-    apiKey: process.env.OPENROUTER_API_KEY,
-    baseUrl: `${process.env.OPENROUTER_API_BASE}/api/v1`,
-  });
-
-  const model = openrouter('openai/gpt-4.1-mini');
-
-  it('should produce cache-friendly tool call arguments in a multi-turn tool conversation', async () => {
-    const getWeather = tool({
-      description:
-        'Get the current weather for a given city. Always provide both city and unit.',
-      inputSchema: z.object({
-        city: z.string().describe('The city name'),
-        unit: z.enum(['celsius', 'fahrenheit']).describe('Temperature unit'),
-      }),
-      execute: async ({ city, unit }) => {
-        return {
-          city,
-          unit,
-          temperature: unit === 'celsius' ? 22 : 72,
-          condition: 'sunny',
-        };
-      },
-    });
-
-    // First turn: model calls the tool
-    const response = await generateText({
-      model,
-      system:
-        'You are a weather assistant. When asked about weather, use the getWeather tool with both city and unit parameters.',
-      prompt:
-        'What is the weather in Tokyo in celsius? Use the getWeather tool.',
-      tools: { getWeather },
-      toolChoice: 'required',
-    });
-
-    expect(response.text).toBeDefined();
-    expect(response.finishReason).toBeDefined();
-
-    // Verify tool was called successfully
-    const toolCalls = response.steps.flatMap((step) => step.toolCalls || []);
-    expect(toolCalls.length).toBeGreaterThan(0);
-    expect(toolCalls[0]?.toolName).toBe('getWeather');
-  });
-});