import { describe, expect, test } from "bun:test"

import { Effect } from "effect"

import { ProviderTransform } from "@/provider/transform"

import { LLMRequestPrep } from "@/session/llm/request"

import { ProviderV2 } from "@opencode-ai/core/provider"

import { ModelV2 } from "@opencode-ai/core/model"

import { jsonSchema } from "ai"

describe("ProviderTransform.options - setCacheKey", () => {

const sessionID = "test-session-123"

const mockModel = {

id: "anthropic/claude-3-5-sonnet",

providerID: "anthropic",

api: {

id: "claude-3-5-sonnet-20241022",

url: "https://api.anthropic.com",

npm: "@ai-sdk/anthropic",

},

name: "Claude 3.5 Sonnet",

capabilities: {

temperature: true,

reasoning: false,

attachment: true,

toolcall: true,

input: { text: true, audio: false, image: true, video: false, pdf: true },

output: { text: true, audio: false, image: false, video: false, pdf: false },

interleaved: false,

},

cost: {

input: 0.003,

output: 0.015,

cache: { read: 0.0003, write: 0.00375 },

},

limit: {

context: 200000,

output: 8192,

},

status: "active",

options: {},

headers: {},

} as any

test("should set promptCacheKey when providerOptions.setCacheKey is true", () => {

const result = ProviderTransform.options({

model: mockModel,

sessionID,

providerOptions: { setCacheKey: true },

})

expect(result.promptCacheKey).toBe(sessionID)

})

test("should not set promptCacheKey when providerOptions.setCacheKey is false", () => {

const result = ProviderTransform.options({

model: mockModel,

sessionID,

providerOptions: { setCacheKey: false },

})

expect(result.promptCacheKey).toBeUndefined()

})

test("should not set promptCacheKey when providerOptions is undefined", () => {

const result = ProviderTransform.options({

model: mockModel,

sessionID,

providerOptions: undefined,

})

expect(result.promptCacheKey).toBeUndefined()

})

test("should not set promptCacheKey when providerOptions does not have setCacheKey", () => {

const result = ProviderTransform.options({ model: mockModel, sessionID, providerOptions: {} })

expect(result.promptCacheKey).toBeUndefined()

})

test("should set promptCacheKey for openai provider regardless of setCacheKey", () => {

const openaiModel = {

...mockModel,

providerID: "openai",

api: {

id: "gpt-4",

url: "https://api.openai.com",

npm: "@ai-sdk/openai",

},

}

const result = ProviderTransform.options({ model: openaiModel, sessionID, providerOptions: {} })

expect(result.promptCacheKey).toBe(sessionID)

})

test("should set store=false for openai provider", () => {

const openaiModel = {

...mockModel,

providerID: "openai",

api: {

id: "gpt-4",

url: "https://api.openai.com",

npm: "@ai-sdk/openai",

},

}

const result = ProviderTransform.options({

model: openaiModel,

sessionID,

providerOptions: {},

})

expect(result.store).toBe(false)

})

test("should set store=false for azure provider by default", () => {

const azureModel = {

...mockModel,

providerID: "azure",

api: {

id: "gpt-4",

url: "https://azure.com",

npm: "@ai-sdk/azure",

},

}

const result = ProviderTransform.options({

model: azureModel,

sessionID,

providerOptions: {},

})

expect(result.store).toBe(false)

})

})

describe("ProviderTransform.options - zai/zhipuai thinking", () => {

const sessionID = "test-session-123"

const createModel = (providerID: string) =>

({

id: `${providerID}/glm-4.6`,

providerID,

api: {

id: "glm-4.6",

url: "https://open.bigmodel.cn/api/paas/v4",

npm: "@ai-sdk/openai-compatible",

},

name: "GLM 4.6",

capabilities: {

temperature: true,

reasoning: true,

attachment: true,

toolcall: true,

input: { text: true, audio: false, image: true, video: false, pdf: true },

output: { text: true, audio: false, image: false, video: false, pdf: false },

interleaved: false,

},

cost: {

input: 0.001,

output: 0.002,

cache: { read: 0.0001, write: 0.0002 },

},

limit: {

context: 128000,

output: 8192,

},

status: "active",

options: {},

headers: {},

}) as any

for (const providerID of ["zai-coding-plan", "zai", "zhipuai-coding-plan", "zhipuai"]) {

test(`${providerID} should set thinking cfg`, () => {

const result = ProviderTransform.options({

model: createModel(providerID),

sessionID,

providerOptions: {},

})

expect(result.thinking).toEqual({

type: "enabled",

clear_thinking: false,

})

})

}

})

describe("ProviderTransform.options - minimax m3 thinking", () => {

const createModel = (npm: string) =>

({

id: "minimax/minimax-m3",

providerID: "minimax",

api: {

id: "minimax-m3",

url: "https://api.minimax.com",

npm,

},

capabilities: { reasoning: true },

limit: { output: 64_000 },

}) as any

test("explicitly enables adaptive thinking with the anthropic SDK", () => {

expect(

ProviderTransform.options({

model: createModel("@ai-sdk/anthropic"),

sessionID: "test-session-123",

}).thinking,

).toEqual({ type: "adaptive" })

})

test("uses the native default with the openai-compatible SDK", () => {

expect(

ProviderTransform.options({

model: createModel("@ai-sdk/openai-compatible"),

sessionID: "test-session-123",

}).thinking,

).toBeUndefined()

})

})

describe("ProviderTransform.options - google thinkingConfig gating", () => {

const sessionID = "test-session-123"

const createGoogleModel = (reasoning: boolean, npm: "@ai-sdk/google" | "@ai-sdk/google-vertex") =>

({

id: `${npm === "@ai-sdk/google" ? "google" : "google-vertex"}/gemini-2.0-flash`,

providerID: npm === "@ai-sdk/google" ? "google" : "google-vertex",

api: {

id: "gemini-2.0-flash",

url: npm === "@ai-sdk/google" ? "https://generativelanguage.googleapis.com" : "https://vertexai.googleapis.com",

npm,

},

name: "Gemini 2.0 Flash",

capabilities: {

temperature: true,

reasoning,

attachment: true,

toolcall: true,

input: { text: true, audio: false, image: true, video: false, pdf: true },

output: { text: true, audio: false, image: false, video: false, pdf: false },

interleaved: false,

},

cost: {

input: 0.001,

output: 0.002,

cache: { read: 0.0001, write: 0.0002 },

},

limit: {

context: 1_000_000,

output: 8192,

},

status: "active",

options: {},

headers: {},

}) as any

test("does not set thinkingConfig for google models without reasoning capability", () => {

const result = ProviderTransform.options({

model: createGoogleModel(false, "@ai-sdk/google"),

sessionID,

providerOptions: {},

})

expect(result.thinkingConfig).toBeUndefined()

})

test("sets thinkingConfig for google models with reasoning capability", () => {

const result = ProviderTransform.options({

model: createGoogleModel(true, "@ai-sdk/google"),

sessionID,

providerOptions: {},

})

expect(result.thinkingConfig).toEqual({

includeThoughts: true,

})

})

test("does not set thinkingConfig for vertex models without reasoning capability", () => {

const result = ProviderTransform.options({

model: createGoogleModel(false, "@ai-sdk/google-vertex"),

sessionID,

providerOptions: {},

})

expect(result.thinkingConfig).toBeUndefined()

})

})

describe("ProviderTransform.options - gpt-5 textVerbosity", () => {

const sessionID = "test-session-123"

const createGpt5Model = (apiId: string) =>

({

id: `openai/${apiId}`,

providerID: "openai",

api: {

id: apiId,

url: "https://api.openai.com",

npm: "@ai-sdk/openai",

},

name: apiId,

capabilities: {

temperature: true,

reasoning: true,

attachment: true,

toolcall: true,

input: { text: true, audio: false, image: true, video: false, pdf: false },

output: { text: true, audio: false, image: false, video: false, pdf: false },

interleaved: false,

},

cost: { input: 0.03, output: 0.06, cache: { read: 0.001, write: 0.002 } },

limit: { context: 128000, output: 4096 },

status: "active",

options: {},

headers: {},

}) as any

test("gpt-5.2 should have textVerbosity set to low", () => {

const model = createGpt5Model("gpt-5.2")

const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })

expect(result.textVerbosity).toBe("low")

expect(result.include).toEqual(["reasoning.encrypted_content"])

})

test("Bedrock Mantle gpt-5.5 uses OpenAI Responses defaults", () => {

const model = {

...createGpt5Model("openai.gpt-5.5"),

id: "amazon-bedrock/openai.gpt-5.5",

providerID: "amazon-bedrock",

api: {

id: "openai.gpt-5.5",

url: "https://bedrock-mantle.us-east-2.api.aws/openai/v1",

npm: "@ai-sdk/amazon-bedrock/mantle",

},

}

const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })

expect(result.store).toBe(false)

expect(result.reasoningEffort).toBe("medium")

expect(result.reasoningSummary).toBe("auto")

expect(result.include).toEqual(["reasoning.encrypted_content"])

expect(result.textVerbosity).toBe("low")

})

test("openai-compatible gpt-5 models omit Responses-only reasoningSummary", () => {

const model = {

...createGpt5Model("gpt-5.4"),

id: "cortecs/gpt-5.4",

providerID: "cortecs",

api: {

id: "gpt-5.4",

url: "https://api.cortecs.ai/v1",

npm: "@ai-sdk/openai-compatible",

},

}

const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })

expect(result.reasoningEffort).toBe("medium")

expect(result.reasoningSummary).toBeUndefined()

expect(result.include).toBeUndefined()

})

test("azure chat completions omit Responses-only reasoning options after variants merge", async () => {

const model = {

...createGpt5Model("gpt-5.4"),

id: "azure/gpt-5.4",

providerID: "azure",

api: {

id: "gpt-5.4",

url: "https://azure.com",

npm: "@ai-sdk/azure",

},

variants: {

high: {

reasoningEffort: "high",

reasoningSummary: "auto",

include: ["reasoning.encrypted_content"],

},

},

}

const result = await Effect.runPromise(

LLMRequestPrep.prepare({

user: {

id: "msg_user-test",

sessionID,

role: "user",

time: { created: Date.now() },

agent: "test",

model: { providerID: "azure", modelID: "gpt-5.4", variant: "high" },

} as any,

sessionID,

model,

agent: {

name: "test",

mode: "primary",

options: {},

permission: [],

} as any,

system: [],

messages: [{ role: "user", content: "Hello" }],

tools: {

lookup: {

description: "Look up a value",

inputSchema: jsonSchema({ type: "object", properties: {} }),

},

},

provider: { id: "azure", options: { useCompletionUrls: true } } as any,

auth: undefined,

plugin: {

trigger: (_name: string, _input: unknown, output: unknown) => Effect.succeed(output),

list: () => Effect.succeed([]),

init: () => Effect.void,

} as any,

flags: { outputTokenMax: 32_000, client: "test" } as any,

isWorkflow: false,

}),

)

expect(result.params.options.reasoningEffort).toBe("high")

expect(result.params.options.reasoningSummary).toBeUndefined()

expect(result.params.options.include).toBeUndefined()

expect(result.tools.lookup.strict).toBe(false)

})

test("gpt-5.1 should have textVerbosity set to low", () => {

const model = createGpt5Model("gpt-5.1")

const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })

expect(result.textVerbosity).toBe("low")

})

test("gpt-5.2-chat-latest should NOT have textVerbosity set (only supports medium)", () => {

const model = createGpt5Model("gpt-5.2-chat-latest")

const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })

expect(result.textVerbosity).toBeUndefined()

})

test("gpt-5.1-chat-latest should NOT have textVerbosity set (only supports medium)", () => {

const model = createGpt5Model("gpt-5.1-chat-latest")

const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })

expect(result.textVerbosity).toBeUndefined()

})

test("gpt-5.2-chat should NOT have textVerbosity set", () => {

const model = createGpt5Model("gpt-5.2-chat")

const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })

expect(result.textVerbosity).toBeUndefined()

})

test("gpt-5-chat should NOT have textVerbosity set", () => {

const model = createGpt5Model("gpt-5-chat")

const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })

expect(result.textVerbosity).toBeUndefined()

})

test("gpt-5.2-codex should NOT have textVerbosity set (codex models excluded)", () => {

const model = createGpt5Model("gpt-5.2-codex")

const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })

expect(result.textVerbosity).toBeUndefined()

})

})

describe("ProviderTransform.options - gpt-5 reasoningEffort", () => {

const sessionID = "test-session-123"

const createModel = (apiId: string) =>

({

id: `azure/${apiId}`,

providerID: "azure",

api: {

id: apiId,

url: "https://azure.com",

npm: "@ai-sdk/azure",

},

name: apiId,

capabilities: {

temperature: true,

reasoning: true,

attachment: true,

toolcall: true,

input: {

text: true,

audio: false,

image: true,

video: false,

pdf: false,

},

output: {

text: true,

audio: false,

image: false,

video: false,

pdf: false,

},

interleaved: false,

},

cost: {

input: 0.03,

output: 0.06,

cache: { read: 0.001, write: 0.002 },

},

limit: {

context: 128000,

output: 4096,

},

status: "active",

options: {},

headers: {},

}) as any

test("gpt-5-chat should NOT set reasoningEffort", () => {

const result = ProviderTransform.options({

model: createModel("gpt-5-chat"),

sessionID,

providerOptions: {},

})

expect(result.reasoningEffort).toBeUndefined()

})

test("gpt-5.5 should NOT set reasoningEffort", () => {

const result = ProviderTransform.options({

model: createModel("gpt-5.5"),

sessionID,

providerOptions: {},

})

expect(result.reasoningEffort).toBeUndefined()

})

})

describe("ProviderTransform.options - gateway", () => {

const sessionID = "test-session-123"

const createModel = (id: string) =>

({

id,

providerID: "vercel",

api: {

id,

url: "https://ai-gateway.vercel.sh/v3/ai",

npm: "@ai-sdk/gateway",

},

name: id,

capabilities: {

temperature: true,

reasoning: true,

attachment: true,

toolcall: true,

input: { text: true, audio: false, image: true, video: false, pdf: true },

output: { text: true, audio: false, image: false, video: false, pdf: false },

interleaved: false,

},

cost: {

input: 0.001,

output: 0.002,

cache: { read: 0.0001, write: 0.0002 },

},

limit: {

context: 200_000,

output: 8192,

},

status: "active",

options: {},

headers: {},

release_date: "2024-01-01",

}) as any

test("puts gateway defaults under gateway key", () => {

const model = createModel("anthropic/claude-sonnet-4")

const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })

expect(result).toEqual({

gateway: {

caching: "auto",

},

})

})

})

describe("ProviderTransform.providerOptions", () => {

const createModel = (overrides: Partial<any> = {}) =>

({

id: "test/test-model",

providerID: "test",

api: {

id: "test-model",

url: "https://api.test.com",

npm: "@ai-sdk/openai",

},

name: "Test Model",

capabilities: {

temperature: true,

reasoning: true,

attachment: true,

toolcall: true,

input: { text: true, audio: false, image: true, video: false, pdf: false },

output: { text: true, audio: false, image: false, video: false, pdf: false },

interleaved: false,

},

cost: {

input: 0.001,

output: 0.002,

cache: { read: 0.0001, write: 0.0002 },

},

limit: {

context: 200_000,

output: 64_000,

},

status: "active",

options: {},

headers: {},

release_date: "2024-01-01",

...overrides,

}) as any

test("uses sdk key for non-gateway models", () => {

const model = createModel({

providerID: "my-bedrock",

api: {

id: "anthropic.claude-sonnet-4",

url: "https://bedrock.aws",

npm: "@ai-sdk/amazon-bedrock",

},

})

expect(ProviderTransform.providerOptions(model, { cachePoint: { type: "default" } })).toEqual({

bedrock: { cachePoint: { type: "default" } },

})

})

test("forces reasoning for custom OpenAI package models with explicit effort", () => {

const model = createModel({

providerID: "meta",

api: {

id: "muse-spark",

url: "https://api.ai.meta.com/v1",

npm: "@ai-sdk/openai",

},

})

expect(ProviderTransform.providerOptions(model, { reasoningEffort: "xhigh", reasoningSummary: "auto" })).toEqual({

openai: { forceReasoning: true, reasoningEffort: "xhigh", reasoningSummary: "auto" },

})

})

test("forces reasoning for OpenAI package models marked reasoning-capable", () => {

expect(ProviderTransform.providerOptions(createModel(), { store: false })).toEqual({

openai: { forceReasoning: true, store: false },

})

})

test("forces reasoning for explicit effort even when model is not marked reasoning-capable", () => {

const model = createModel({

capabilities: {

temperature: true,

reasoning: false,

attachment: true,

toolcall: true,

input: { text: true, audio: false, image: true, video: false, pdf: false },

output: { text: true, audio: false, image: false, video: false, pdf: false },

interleaved: false,

},

})

expect(ProviderTransform.providerOptions(model, { reasoningEffort: "xhigh" })).toEqual({

openai: { forceReasoning: true, reasoningEffort: "xhigh" },

})

})

test("forces reasoning for Azure OpenAI models with explicit effort", () => {

const model = createModel({

providerID: "azure",

api: {

id: "custom-gpt-5-deployment",

url: "https://azure.openai.example.com/openai/v1",

npm: "@ai-sdk/azure",

},

})

expect(ProviderTransform.providerOptions(model, { reasoningEffort: "xhigh" })).toEqual({

openai: { forceReasoning: true, reasoningEffort: "xhigh" },

azure: { forceReasoning: true, reasoningEffort: "xhigh" },

})

})

test("forces reasoning for Bedrock Mantle OpenAI models with explicit effort", () => {

const model = createModel({

providerID: "amazon-bedrock",

api: {

id: "openai.gpt-5-custom",

url: "https://bedrock-mantle.us-east-2.api.aws/openai/v1",

npm: "@ai-sdk/amazon-bedrock/mantle",

},

})

expect(ProviderTransform.providerOptions(model, { reasoningEffort: "xhigh" })).toEqual({

openai: { forceReasoning: true, reasoningEffort: "xhigh" },

})

})

test("overrides forceReasoning false when reasoning should be forced", () => {

expect(

ProviderTransform.providerOptions(createModel(), { forceReasoning: false, reasoningEffort: "xhigh" }),

).toEqual({

openai: { forceReasoning: true, reasoningEffort: "xhigh" },

})

})

test("uses gateway model provider slug for gateway models", () => {

const model = createModel({

providerID: "vercel",

api: {

id: "anthropic/claude-sonnet-4",

url: "https://ai-gateway.vercel.sh/v3/ai",

npm: "@ai-sdk/gateway",

},

})

expect(ProviderTransform.providerOptions(model, { thinking: { type: "enabled", budgetTokens: 12_000 } })).toEqual({

anthropic: { thinking: { type: "enabled", budgetTokens: 12_000 } },

})

})

test("falls back to gateway key when gateway api id is unscoped", () => {

const model = createModel({

id: "anthropic/claude-sonnet-4",

providerID: "vercel",

api: {

id: "claude-sonnet-4",

url: "https://ai-gateway.vercel.sh/v3/ai",

npm: "@ai-sdk/gateway",

},

})

expect(ProviderTransform.providerOptions(model, { thinking: { type: "enabled", budgetTokens: 12_000 } })).toEqual({

gateway: { thinking: { type: "enabled", budgetTokens: 12_000 } },

})

})

test("splits gateway routing options from provider-specific options", () => {

const model = createModel({

providerID: "vercel",

api: {

id: "anthropic/claude-sonnet-4",

url: "https://ai-gateway.vercel.sh/v3/ai",

npm: "@ai-sdk/gateway",

},

})

expect(

ProviderTransform.providerOptions(model, {

gateway: { order: ["vertex", "anthropic"] },

thinking: { type: "enabled", budgetTokens: 12_000 },

}),

).toEqual({

gateway: { order: ["vertex", "anthropic"] },

anthropic: { thinking: { type: "enabled", budgetTokens: 12_000 } },

} as any)

})

test("falls back to gateway key when model id has no provider slug", () => {

const model = createModel({

id: "claude-sonnet-4",

providerID: "vercel",

api: {

id: "claude-sonnet-4",

url: "https://ai-gateway.vercel.sh/v3/ai",

npm: "@ai-sdk/gateway",

},

})

expect(ProviderTransform.providerOptions(model, { reasoningEffort: "high" })).toEqual({

gateway: { reasoningEffort: "high" },

})

})

test("maps amazon slug to bedrock for provider options", () => {

const model = createModel({

providerID: "vercel",

api: {

id: "amazon/nova-2-lite",

url: "https://ai-gateway.vercel.sh/v3/ai",

npm: "@ai-sdk/gateway",

},

})

expect(ProviderTransform.providerOptions(model, { reasoningConfig: { type: "enabled" } })).toEqual({

bedrock: { reasoningConfig: { type: "enabled" } },

})

})

test("maps Bedrock Mantle provider options to OpenAI namespace", () => {

const model = createModel({

providerID: "amazon-bedrock",

api: {

id: "openai.gpt-5.5",

url: "https://bedrock-mantle.us-east-2.api.aws/openai/v1",

npm: "@ai-sdk/amazon-bedrock/mantle",

},

})

expect(ProviderTransform.providerOptions(model, { reasoningEffort: "medium" })).toEqual({

openai: { forceReasoning: true, reasoningEffort: "medium" },

})

})

test("uses groq slug for groq models", () => {

const model = createModel({

providerID: "vercel",

api: {

id: "groq/llama-3.3-70b-versatile",

url: "https://ai-gateway.vercel.sh/v3/ai",

npm: "@ai-sdk/gateway",

},

})

expect(ProviderTransform.providerOptions(model, { reasoningFormat: "parsed" })).toEqual({

groq: { reasoningFormat: "parsed" },

})

})

})

describe("ProviderTransform.schema - gemini array items", () => {

test("adds missing items for array properties", () => {

const geminiModel = {

providerID: "google",

api: {

id: "gemini-3-pro",

},

} as any

const schema = {

type: "object",

properties: {

nodes: { type: "array" },

edges: { type: "array", items: { type: "string" } },

},

} as any

const result = ProviderTransform.schema(geminiModel, schema) as any

expect(result.properties.nodes.items).toBeDefined()

expect(result.properties.edges.items.type).toBe("string")

})

})

describe("ProviderTransform.schema - gemini nested array items", () => {

const geminiModel = {

providerID: "google",

api: {

id: "gemini-3-pro",

},

} as any

test("adds type to 2D array with empty inner items", () => {

const schema = {

type: "object",

properties: {

values: {

type: "array",

items: {

type: "array",

items: {}, // Empty items object

},

},

},

} as any

const result = ProviderTransform.schema(geminiModel, schema) as any

// Inner items should have a default type

expect(result.properties.values.items.items.type).toBe("string")

})

test("adds items and type to 2D array with missing inner items", () => {

const schema = {

type: "object",

properties: {

data: {

type: "array",

items: { type: "array" }, // No items at all

},

},

} as any

const result = ProviderTransform.schema(geminiModel, schema) as any

expect(result.properties.data.items.items).toBeDefined()

expect(result.properties.data.items.items.type).toBe("string")

})

test("handles deeply nested arrays (3D)", () => {

const schema = {

type: "object",

properties: {

matrix: {

type: "array",

items: {

type: "array",

items: {

type: "array",

// No items

},

},

},

},

} as any

const result = ProviderTransform.schema(geminiModel, schema) as any

expect(result.properties.matrix.items.items.items).toBeDefined()

expect(result.properties.matrix.items.items.items.type).toBe("string")

})

test("preserves existing item types in nested arrays", () => {

const schema = {

type: "object",

properties: {

numbers: {

type: "array",

items: {

type: "array",

items: { type: "number" }, // Has explicit type

},

},

},

} as any

const result = ProviderTransform.schema(geminiModel, schema) as any

// Should preserve the explicit type

expect(result.properties.numbers.items.items.type).toBe("number")

})

test("handles mixed nested structures with objects and arrays", () => {

const schema = {

type: "object",

properties: {

spreadsheetData: {

type: "object",

properties: {

rows: {

type: "array",

items: {

type: "array",

items: {}, // Empty items

},

},

},

},

},

} as any

const result = ProviderTransform.schema(geminiModel, schema) as any

expect(result.properties.spreadsheetData.properties.rows.items.items.type).toBe("string")

})

})

describe("ProviderTransform.schema - gemini type arrays", () => {

// Mirrors @ai-sdk/google's convertJSONSchemaToOpenAPISchema: JSON Schema type

// arrays (e.g. `["number","string"]`, common in MCP tool schemas) become an

// `anyOf` of single-type schemas, with `null` lifted into `nullable`. Plain

// @ai-sdk/google rewrites these, but OpenAI-compatible transports such as

// GitHub Copilot (proxying to Gemini) forward them verbatim and the backend

// rejects the array form.

const geminiModel = {

providerID: "google",

api: {

id: "gemini-3-pro",

},

} as any

test("splits a multi-type array into anyOf and drops the type array", () => {

const schema = {

type: "object",

properties: {

status: { type: ["number", "string"], description: "status filter" },

},

} as any

const result = ProviderTransform.schema(geminiModel, schema) as any

expect(result.properties.status.type).toBeUndefined()

expect(result.properties.status.anyOf).toEqual([{ type: "number" }, { type: "string" }])

expect(result.properties.status.nullable).toBeUndefined()

// Sibling keywords stay alongside the generated anyOf.

expect(result.properties.status.description).toBe("status filter")

})

test("lifts null into nullable for a nullable type array", () => {

const schema = {

type: "object",

properties: {

maybe: { type: ["string", "null"], description: "nullable string" },

},

} as any

const result = ProviderTransform.schema(geminiModel, schema) as any

expect(result.properties.maybe.type).toBeUndefined()

expect(result.properties.maybe.anyOf).toEqual([{ type: "string" }])

expect(result.properties.maybe.nullable).toBe(true)

})

test("collapses an all-null type array to type null", () => {

const schema = {

type: "object",

properties: {

nothing: { type: ["null"] },

},

} as any

const result = ProviderTransform.schema(geminiModel, schema) as any