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

import { ProviderTransform } from "../../src/provider"

import { ModelID, ProviderID } from "../../src/provider/schema"

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=true 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(true)

})

})

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 - 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")

})

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 - 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("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("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 combiner nodes", () => {

const geminiModel = {

providerID: "google",

api: {

id: "gemini-3-pro",

},

} as any

const walk = (node: any, cb: (node: any, path: (string | number)[]) => void, path: (string | number)[] = []) => {

if (node === null || typeof node !== "object") {

return

}

if (Array.isArray(node)) {

node.forEach((item, i) => walk(item, cb, [...path, i]))

return

}

cb(node, path)

Object.entries(node).forEach(([key, value]) => walk(value, cb, [...path, key]))

}

test("keeps edits.items.anyOf without adding type", () => {

const schema = {

type: "object",

properties: {

edits: {

type: "array",

items: {

anyOf: [

{

type: "object",

properties: {

old_string: { type: "string" },

new_string: { type: "string" },

},

required: ["old_string", "new_string"],

},

{

type: "object",

properties: {

old_string: { type: "string" },

new_string: { type: "string" },

replace_all: { type: "boolean" },

},

required: ["old_string", "new_string"],

},

],

},

},

},

required: ["edits"],

} as any

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

expect(Array.isArray(result.properties.edits.items.anyOf)).toBe(true)

expect(result.properties.edits.items.type).toBeUndefined()

})

test("does not add sibling keys to combiner nodes during sanitize", () => {

const schema = {

type: "object",

properties: {

edits: {

type: "array",

items: {

anyOf: [{ type: "string" }, { type: "number" }],

},

},

value: {

oneOf: [{ type: "string" }, { type: "boolean" }],

},

meta: {

allOf: [

{

type: "object",

properties: { a: { type: "string" } },

},

{

type: "object",

properties: { b: { type: "string" } },

},

],

},

},

} as any

const input = JSON.parse(JSON.stringify(schema))

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

walk(result, (node, path) => {

const hasCombiner = Array.isArray(node.anyOf) || Array.isArray(node.oneOf) || Array.isArray(node.allOf)

if (!hasCombiner) {

return

}

const before = path.reduce((acc: any, key) => acc?.[key], input)

const added = Object.keys(node).filter((key) => !(key in before))

expect(added).toEqual([])

})

})

})

describe("ProviderTransform.schema - gemini non-object properties removal", () => {

const geminiModel = {

providerID: "google",

api: {

id: "gemini-3-pro",

},

} as any

test("removes properties from non-object types", () => {

const schema = {

type: "object",

properties: {

data: {

type: "string",

properties: { invalid: { type: "string" } },

},

},

} as any

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

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

expect(result.properties.data.properties).toBeUndefined()

})

test("removes required from non-object types", () => {

const schema = {

type: "object",

properties: {

data: {

type: "array",

items: { type: "string" },

required: ["invalid"],

},

},

} as any

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

expect(result.properties.data.type).toBe("array")

expect(result.properties.data.required).toBeUndefined()

})

test("removes properties and required from nested non-object types", () => {

const schema = {

type: "object",

properties: {

outer: {

type: "object",

properties: {

inner: {

type: "number",

properties: { bad: { type: "string" } },

required: ["bad"],

},

},

},

},

} as any

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

expect(result.properties.outer.properties.inner.type).toBe("number")

expect(result.properties.outer.properties.inner.properties).toBeUndefined()

expect(result.properties.outer.properties.inner.required).toBeUndefined()

})

test("keeps properties and required on object types", () => {

const schema = {

type: "object",

properties: {

data: {

type: "object",

properties: { name: { type: "string" } },

required: ["name"],

},

},

} as any

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

expect(result.properties.data.type).toBe("object")

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

expect(result.properties.data.required).toEqual(["name"])

})

test("does not affect non-gemini providers", () => {

const openaiModel = {

providerID: "openai",

api: {

id: "gpt-4",

},

} as any

const schema = {

type: "object",

properties: {

data: {

type: "string",

properties: { invalid: { type: "string" } },

},

},

} as any

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

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

})

})

describe("ProviderTransform.message - DeepSeek reasoning content", () => {

test("DeepSeek with tool calls includes reasoning_content in providerOptions", () => {

const msgs = [

{

role: "assistant",

content: [

{ type: "reasoning", text: "Let me think about this..." },

{

type: "tool-call",

toolCallId: "test",

toolName: "bash",

input: { command: "echo hello" },

},

],

},

] as any[]

const result = ProviderTransform.message(

msgs,

{

id: ModelID.make("deepseek/deepseek-chat"),

providerID: ProviderID.make("deepseek"),

api: {

id: "deepseek-chat",

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

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

},

name: "DeepSeek Chat",

capabilities: {

temperature: true,

reasoning: true,

attachment: false,

toolcall: true,

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

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

interleaved: {

field: "reasoning_content",

},

},

cost: {

input: 0.001,

output: 0.002,

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

},

limit: {

context: 128000,

output: 8192,

},

status: "active",

options: {},

headers: {},

release_date: "2023-04-01",

},

{},

)

expect(result).toHaveLength(1)

expect(result[0].content).toEqual([

{

type: "tool-call",

toolCallId: "test",

toolName: "bash",

input: { command: "echo hello" },

},

])

expect(result[0].providerOptions?.openaiCompatible?.reasoning_content).toBe("Let me think about this...")

})

test("Non-DeepSeek providers leave reasoning content unchanged", () => {

const msgs = [

{

role: "assistant",

content: [

{ type: "reasoning", text: "Should not be processed" },

{ type: "text", text: "Answer" },

],

},

] as any[]

const result = ProviderTransform.message(

msgs,

{

id: ModelID.make("openai/gpt-4"),

providerID: ProviderID.make("openai"),

api: {

id: "gpt-4",

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

npm: "@ai-sdk/openai",

},

name: "GPT-4",

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,

},

cost: {

input: 0.03,

output: 0.06,

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

},

limit: {

context: 128000,

output: 4096,

},

status: "active",

options: {},

headers: {},

release_date: "2023-04-01",

},

{},

)

expect(result[0].content).toEqual([

{ type: "reasoning", text: "Should not be processed" },

{ type: "text", text: "Answer" },

])

expect(result[0].providerOptions?.openaiCompatible?.reasoning_content).toBeUndefined()

})

})

describe("ProviderTransform.message - empty image handling", () => {

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,

},