fix: restore aisdk structured output options

Author: monadoid

packages/core/lib/v3/external_clients/aisdk.ts

@@ -14,6 +14,18 @@ import { CreateChatCompletionOptions, LLMClient } from "../llm/LLMClient.js";
 import { AvailableModel } from "../types/public/index.js";
 import { ChatCompletion } from "openai/resources";
 
+function getGenerationSettings(
+  options: CreateChatCompletionOptions["options"],
+) {
+  return {
+    temperature: options.temperature,
+    maxOutputTokens: options.maxOutputTokens,
+    topP: options.top_p,
+    frequencyPenalty: options.frequency_penalty,
+    presencePenalty: options.presence_penalty,
+  };
+}
+
 export class AISdkClient extends LLMClient {
   public type = "aisdk" as const;
   private model: LanguageModelV2;
@@ -86,6 +98,7 @@ export class AISdkClient extends LLMClient {
         model: this.model,
         messages: formattedMessages,
         schema: options.response_model.schema,
+        ...getGenerationSettings(options),
       });
 
       return {
@@ -102,7 +115,7 @@ export class AISdkClient extends LLMClient {
 
     const tools: Record<string, Tool> = {};
 
-    for (const rawTool of options.tools) {
+    for (const rawTool of options.tools ?? []) {
       tools[rawTool.name] = {
         description: rawTool.description,
         inputSchema: rawTool.parameters,
@@ -113,6 +126,7 @@ export class AISdkClient extends LLMClient {
       model: this.model,
       messages: formattedMessages,
       tools,
+      ...getGenerationSettings(options),
     });
 
     return {

packages/core/lib/v3/llm/aisdk.ts

@@ -174,11 +174,21 @@ export class AISdkClient extends LLMClient {
             : {}),
         };
         break;
+      case "azure":
+        providerOptions.azure = {
+          strictJsonSchema: true,
+        };
+        break;
       case "google":
         providerOptions.google = {
           structuredOutputs: true,
         };
         break;
+      case "vertex":
+        providerOptions.vertex = {
+          structuredOutputs: true,
+        };
+        break;
       case "anthropic":
         providerOptions.anthropic = {
           structuredOutputMode: "auto",
@@ -189,6 +199,11 @@ export class AISdkClient extends LLMClient {
           structuredOutputs: true,
         };
         break;
+      case "cerebras":
+        providerOptions.cerebras = {
+          strictJsonSchema: true,
+        };
+        break;
       case "mistral":
         providerOptions.mistral = {
           structuredOutputs: true,

packages/core/tests/unit/aisdk-clients.test.ts

@@ -0,0 +1,154 @@
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import { generateObject, generateText } from "ai";
+import { z } from "zod";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AISdkClient as ExternalAISdkClient } from "../../lib/v3/external_clients/aisdk.js";
+import { AISdkClient as LlmAISdkClient } from "../../lib/v3/llm/aisdk.js";
+
+vi.mock("ai", async () => {
+  const actual = await vi.importActual<typeof import("ai")>("ai");
+  return {
+    ...actual,
+    generateObject: vi.fn(),
+    generateText: vi.fn(),
+  };
+});
+
+const mockGenerateObject = vi.mocked(generateObject);
+const mockGenerateText = vi.mocked(generateText);
+
+function createModel(modelId = "openai/gpt-4.1") {
+  return {
+    modelId,
+    specificationVersion: "v2",
+  } as unknown as LanguageModelV2;
+}
+
+describe("AISdk clients", () => {
+  beforeEach(() => {
+    mockGenerateObject.mockReset();
+    mockGenerateText.mockReset();
+  });
+
+  it("external AISdkClient forwards generation settings to generateObject", async () => {
+    mockGenerateObject.mockResolvedValue({
+      object: { ok: true },
+      usage: {
+        inputTokens: 1,
+        outputTokens: 2,
+        reasoningTokens: 0,
+        cachedInputTokens: 0,
+        totalTokens: 3,
+      },
+    } as never);
+
+    const client = new ExternalAISdkClient({
+      model: createModel(),
+    });
+
+    await client.createChatCompletion({
+      options: {
+        messages: [{ role: "user", content: "hello" }],
+        response_model: {
+          name: "test",
+          schema: z.object({ ok: z.boolean() }),
+        },
+        temperature: 0.2,
+        maxOutputTokens: 50,
+        top_p: 0.8,
+        frequency_penalty: 0.1,
+        presence_penalty: 0.3,
+      },
+      logger: vi.fn(),
+    });
+
+    expect(mockGenerateObject).toHaveBeenCalledWith(
+      expect.objectContaining({
+        temperature: 0.2,
+        maxOutputTokens: 50,
+        topP: 0.8,
+        frequencyPenalty: 0.1,
+        presencePenalty: 0.3,
+      }),
+    );
+  });
+
+  it("external AISdkClient handles missing tools without throwing", async () => {
+    mockGenerateText.mockResolvedValue({
+      text: "ok",
+      usage: {
+        inputTokens: 1,
+        outputTokens: 1,
+        reasoningTokens: 0,
+        cachedInputTokens: 0,
+        totalTokens: 2,
+      },
+    } as never);
+
+    const client = new ExternalAISdkClient({
+      model: createModel(),
+    });
+
+    await expect(
+      client.createChatCompletion({
+        options: {
+          messages: [{ role: "user", content: "hello" }],
+        },
+        logger: vi.fn(),
+      }),
+    ).resolves.toEqual(
+      expect.objectContaining({
+        data: "ok",
+      }),
+    );
+
+    expect(mockGenerateText).toHaveBeenCalledWith(
+      expect.objectContaining({
+        tools: {},
+      }),
+    );
+  });
+
+  it.each([
+    ["azure", { azure: { strictJsonSchema: true } }],
+    ["vertex", { vertex: { structuredOutputs: true } }],
+    ["cerebras", { cerebras: { strictJsonSchema: true } }],
+  ])(
+    "main AISdkClient preserves structured provider options for %s",
+    async (providerName, providerOptions) => {
+      mockGenerateObject.mockResolvedValue({
+        object: { ok: true },
+        usage: {
+          inputTokens: 1,
+          outputTokens: 2,
+          reasoningTokens: 0,
+          cachedInputTokens: 0,
+          totalTokens: 3,
+        },
+      } as never);
+
+      const client = new LlmAISdkClient({
+        model: createModel(`${providerName}/model`),
+        providerName,
+        logger: vi.fn(),
+      });
+
+      await client.createChatCompletion({
+        options: {
+          messages: [{ role: "user", content: "hello" }],
+          response_model: {
+            name: "test",
+            schema: z.object({ ok: z.boolean() }),
+          },
+        },
+        logger: vi.fn(),
+      });
+
+      expect(mockGenerateObject).toHaveBeenCalledWith(
+        expect.objectContaining({
+          providerOptions,
+        }),
+      );
+    },
+  );
+});