diff --git a/packages/ai/README.md b/packages/ai/README.md index 36c53c3b3e5..f45426dfe5d 100644 --- a/packages/ai/README.md +++ b/packages/ai/README.md @@ -47,7 +47,8 @@ await Effect.runPromise(program.pipe(Effect.provide(AIClient.layer))) ``` Run `ai.stream(...)` instead of `generate` when you want incremental `LLMEvent`s. Both accept input or a prebuilt -`ai.request(...)`. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, +`ai.request(...)`. Input takes either `prompt`, a single user message, or `messages`, the whole conversation, never +both; `system` goes with either. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment. ### Tool loop diff --git a/packages/ai/src/llm.ts b/packages/ai/src/llm.ts index 858f2704d66..7ba34141aaf 100644 --- a/packages/ai/src/llm.ts +++ b/packages/ai/src/llm.ts @@ -5,6 +5,7 @@ import { GenerationOptions, HttpOptions, InvalidProviderOutputError, + InvalidRequestError, AIError, LLMEvent, LLMRequest, @@ -24,14 +25,20 @@ import { tool, type ExecutableTool, type Tool, type ToolSchema } from "./tool.js import { ToolRuntime } from "./tool-runtime.js" /** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */ -export type RequestInput = Omit< +export type RequestInput = + RequestFields & PromptOrMessages + +/** Exactly one of `prompt`, a single user message, or `messages`, the full conversation. */ +export type PromptOrMessages = + | { readonly prompt: string | ContentPart | ReadonlyArray; readonly messages?: never } + | { readonly messages: ReadonlyArray; readonly prompt?: never } + +type RequestFields = Omit< ConstructorParameters[0], "model" | "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions" > & { readonly model: SelectedLanguageModel readonly system?: string | SystemPart | ReadonlyArray - readonly prompt?: string | ContentPart | ReadonlyArray - readonly messages?: ReadonlyArray /** Sent in array order. Pass `tool(...)` values or wire entries such as hosted provider tools. */ readonly tools?: ReadonlyArray readonly toolChoice?: ToolChoice.Input @@ -111,13 +118,14 @@ export function stream(input: Input, options?: StreamOptions) { } export type LoopInput = Omit< - RequestInput, + RequestFields, "tools" -> & { - readonly tools: ReadonlyArray - /** Called after each step that has tool calls; returning `true` ends the loop without running them. */ - readonly until?: (state: { readonly steps: ReadonlyArray }) => boolean -} +> & + PromptOrMessages & { + readonly tools: ReadonlyArray + /** Called after each step that has tool calls; returning `true` ends the loop without running them. */ + readonly until?: (state: { readonly steps: ReadonlyArray }) => boolean + } /** * Stream model calls, running the model's tool calls between them, until a step has no client-executed tool calls, @@ -264,10 +272,14 @@ export const request = ( http: requestHttp, ...rest } = input + if ((prompt === undefined) === (messages === undefined)) + throw new AIError({ + reason: new InvalidRequestError({ message: "Pass exactly one of `prompt` or `messages`, not both or neither" }), + }) return new LLMRequest({ ...rest, system: SystemPart.content(requestSystem), - messages: [...(messages?.map(Message.make) ?? []), ...(prompt === undefined ? [] : [Message.user(prompt)])], + messages: prompt === undefined ? (messages ?? []).map(Message.make) : [Message.user(prompt)], tools: tools?.map((item) => ("_definition" in item ? item._definition : ToolEntry.make(item))) ?? [], toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined, generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration), diff --git a/packages/ai/src/media-model.ts b/packages/ai/src/media-model.ts index ea4f0ecee21..f21dc7f1e6b 100644 --- a/packages/ai/src/media-model.ts +++ b/packages/ai/src/media-model.ts @@ -105,10 +105,12 @@ export const tryRequest = (make: () => A): Effect.Effect => Effect.try({ try: make, catch: (error) => - new AIError({ - reason: new InvalidRequestError({ - message: error instanceof Error ? error.message : String(error), - cause: error, - }), - }), + error instanceof AIError + ? error + : new AIError({ + reason: new InvalidRequestError({ + message: error instanceof Error ? error.message : String(error), + cause: error, + }), + }), }) diff --git a/packages/ai/test/cache-policy.test.ts b/packages/ai/test/cache-policy.test.ts index 1c35c582711..f7f85a6f47b 100644 --- a/packages/ai/test/cache-policy.test.ts +++ b/packages/ai/test/cache-policy.test.ts @@ -366,6 +366,7 @@ describe("applyCachePolicy", () => { const prepared = yield* compileRequest( ai.request({ model: anthropicModel, + prompt: "Hello", tools: [ duplicate("first"), duplicate("second"), @@ -452,6 +453,7 @@ describe("applyCachePolicy", () => { test("marks the final leaf inside a tool namespace", () => { const request = ai.request({ model: anthropicModel, + prompt: "Hello", tools: [ { type: "namespace", @@ -481,7 +483,9 @@ describe("applyCachePolicy", () => { expect(prepared.body).toMatchObject({ system: [{ type: "text", text: "Sys", cache_control: { type: "ephemeral", ttl: "1h" } }], - messages: [{ role: "user", content: [{ type: "text", text: "hi", cache_control: { type: "ephemeral", ttl: "1h" } }] }], + messages: [ + { role: "user", content: [{ type: "text", text: "hi", cache_control: { type: "ephemeral", ttl: "1h" } }] }, + ], }) }), ) diff --git a/packages/ai/test/compaction.test.ts b/packages/ai/test/compaction.test.ts index f0f6e004393..68d783fa9ab 100644 --- a/packages/ai/test/compaction.test.ts +++ b/packages/ai/test/compaction.test.ts @@ -13,10 +13,14 @@ test("runtime capability checks follow model and route updates", () => { expect(ai.canCompact(request)).toBe(true) expect(ai.canCompact(LLMRequest.update(request, { messages: [] }))).toBe(true) expect(ai.canCompact(LLMRequest.update(request, { model: unsupported }))).toBe(false) - expect(ai.canCompact(ai.request({ model: LanguageModel.update(supported, { route: unsupported.route }) }))).toBe( - false, - ) - expect(ai.canCompact(ai.request({ model: LanguageModel.update(supported, { route: undefined }) }))).toBe(true) + expect( + ai.canCompact( + ai.request({ model: LanguageModel.update(supported, { route: unsupported.route }), prompt: "Hello" }), + ), + ).toBe(false) + expect( + ai.canCompact(ai.request({ model: LanguageModel.update(supported, { route: undefined }), prompt: "Hello" })), + ).toBe(true) }) test("explicit compaction serializes a replacement window without a messages alias", () => { diff --git a/packages/ai/test/compile.test.ts b/packages/ai/test/compile.test.ts index 2c3d9693737..23802f71d91 100644 --- a/packages/ai/test/compile.test.ts +++ b/packages/ai/test/compile.test.ts @@ -1,14 +1,7 @@ import { describe, expect, test } from "bun:test" import { Effect, Ref, Schema } from "effect" import { HttpClientRequest, HttpClientResponse } from "effect/http" -import { - ai, - LLMRequest, - Message, - ToolCallPart, - ToolDefinition, - ToolNamespace, -} from "../src/effect.js" +import { ai, LLMRequest, Message, ToolCallPart, ToolDefinition, ToolNamespace } from "../src/effect.js" import { AnthropicMessages, OpenAIChat, OpenAIResponses } from "../src/protocols.js" import { Auth, LLMClient } from "../src/route.js" import { compileRequest } from "../src/route/client.js" @@ -119,6 +112,7 @@ describe("request option precedence", () => { const prepared = yield* compileRequest( ai.request({ model: OpenAIResponses.route.model({ id: "gpt-5.4" }), + prompt: "Hello", tools: [ ToolDefinition.make({ name: "crm", description: "Top-level CRM tool", inputSchema: {} }), ToolNamespace.make({ diff --git a/packages/ai/test/llm-option-types.types.ts b/packages/ai/test/llm-option-types.types.ts index 0a52494ab97..3d07732b5bf 100644 --- a/packages/ai/test/llm-option-types.types.ts +++ b/packages/ai/test/llm-option-types.types.ts @@ -115,3 +115,25 @@ void AI.ai.stream(AI.ai.request({ model, prompt: "Hello" })) void AI.ai.generate({ model, prompt: "Hello", providerOptions: { mode: "slow" } }) // @ts-expect-error Promise stream input keeps the selected model's provider option types. void AI.ai.stream({ model, prompt: "Hello", providerOptions: { mode: "slow" } }) + +ai.request({ model, system: "Be brief.", prompt: "Hello" }) +ai.request({ model, system: "Be brief.", messages: [] }) +// @ts-expect-error A request needs `prompt` or `messages`. +ai.request({ model }) +// @ts-expect-error A request takes `prompt` or `messages`, not both. +ai.request({ model, prompt: "Hello", messages: [] }) +// @ts-expect-error Effect generate needs `prompt` or `messages`. +ai.generate({ model, system: "Be brief." }) +// @ts-expect-error Effect stream takes `prompt` or `messages`, not both. +ai.stream({ model, prompt: "Hello", messages: [] }) +// @ts-expect-error Effect loop needs `prompt` or `messages`. +ai.loop({ model, tools: [] }) +// @ts-expect-error Effect structured output takes `prompt` or `messages`, not both. +ai.generate({ model, prompt: "Hello", messages: [], schema: Schema.String }) +// @ts-expect-error Promise generate needs `prompt` or `messages`. +void AI.ai.generate({ model }) +// @ts-expect-error Promise stream takes `prompt` or `messages`, not both. +AI.ai.stream({ model, prompt: "Hello", messages: [] }) +// @ts-expect-error Promise loop takes `prompt` or `messages`, not both. +AI.ai.loop({ model, prompt: "Hello", messages: [], tools: [] }) +AI.ai.loop({ model, messages: [], tools: [] }) diff --git a/packages/ai/test/llm.test.ts b/packages/ai/test/llm.test.ts index 10d4d6d0c4e..1a66cbb7647 100644 --- a/packages/ai/test/llm.test.ts +++ b/packages/ai/test/llm.test.ts @@ -24,6 +24,7 @@ describe("llm constructors", () => { test("normalizes recursive tool namespaces", () => { const request = ai.request({ model: LanguageModel.make({ id: "fake-model", provider: "fake", route: responsesRoute }), + prompt: "Hello", tools: [ { type: "namespace", diff --git a/packages/ai/test/loop.test.ts b/packages/ai/test/loop.test.ts index a6b63e3e8fe..c524041f7a4 100644 --- a/packages/ai/test/loop.test.ts +++ b/packages/ai/test/loop.test.ts @@ -175,4 +175,21 @@ describe("ai.loop", () => { expect(yield* client.requests()).toHaveLength(0) }), ) + + it.effect("fails untyped input that has neither or both of prompt and messages", () => + Effect.gen(function* () { + const client = yield* TestLLM.Test + const untyped = (input: object) => input as LLM.RequestInput + const message = "Pass exactly one of `prompt` or `messages`, not both or neither" + const neither = yield* ai.generate(untyped({ model })).pipe(Effect.flip) + const both = yield* ai + .loop({ ...untyped({ model, prompt: "Hi.", messages: [] }), tools: [read_file] }) + .pipe(Stream.runDrain, Effect.flip) + + expect(neither.reason).toMatchObject({ _tag: "InvalidRequest", message }) + expect(both.reason).toMatchObject({ _tag: "InvalidRequest", message }) + expect(() => ai.request(untyped({ model, system: "Be brief." }))).toThrow(message) + expect(yield* client.requests()).toHaveLength(0) + }), + ) }) diff --git a/packages/ai/test/provider-options/alibaba.types.ts b/packages/ai/test/provider-options/alibaba.types.ts index a35d3f856e6..b939bf0346f 100644 --- a/packages/ai/test/provider-options/alibaba.types.ts +++ b/packages/ai/test/provider-options/alibaba.types.ts @@ -6,34 +6,41 @@ Alibaba.configure({ baseURL: "https://gateway.example/v1" }) Alibaba.configure({ region: "eu-central-1", workspaceID: "llm-workspace" }) ai.request({ model: provider.chat("qwen3.8-max"), + prompt: "Hello", providerOptions: { reasoningEffort: "future", enableThinking: true, preserveThinking: false, toolStream: true }, }) ai.request({ model: provider.messages("qwen3.8-max"), + prompt: "Hello", providerOptions: { effort: "xhigh", thinking: { type: "enabled" } }, }) ai.request({ model: provider.messages("qwen3.7-plus"), + prompt: "Hello", providerOptions: { thinking: { type: "enabled", budgetTokens: 512 } }, }) ai.request({ model: provider.responses("qwen3.8-max"), + prompt: "Hello", providerOptions: { reasoningEffort: "low", enableThinking: true, store: true, previousResponseId: "resp_previous" }, }) // @ts-expect-error Region or complete base URL is required. Alibaba.configure({ apiKey: "fixture" }) ai.request({ model: provider.chat("qwen3.8-max"), + prompt: "Hello", // @ts-expect-error Thinking toggle is a boolean. providerOptions: { enableThinking: "true" }, }) ai.request({ model: provider.messages("qwen3.8-max"), + prompt: "Hello", // @ts-expect-error Messages uses effort. providerOptions: { reasoningEffort: "high" }, }) ai.request({ model: provider.responses("qwen3.8-max"), + prompt: "Hello", // @ts-expect-error Responses does not use Chat thinking budgets. providerOptions: { thinkingBudget: 512 }, }) diff --git a/packages/ai/test/provider-options/checkpoint.types.ts b/packages/ai/test/provider-options/checkpoint.types.ts index e49626c63c0..99ff7840d0c 100644 --- a/packages/ai/test/provider-options/checkpoint.types.ts +++ b/packages/ai/test/provider-options/checkpoint.types.ts @@ -49,7 +49,7 @@ for (const selected of [ LanguageModel.make(LanguageModel.input(model)), LanguageModel.update(model, { defaults: { generation: { maxTokens: 100 } } }), ]) { - ai.compact(ai.request({ model: selected }), { mechanism: "trigger" }) + ai.compact(ai.request({ model: selected, prompt: "Hello" }), { mechanism: "trigger" }) } ai.compact(new LLMRequest(LLMRequest.input(request)), { mechanism: "trigger" }) ai.compact(LLMRequest.update(request, { messages: [] }), { mechanism: "trigger" }) @@ -57,25 +57,26 @@ ai.compact(LLMRequest.update(request, { messages: [] }), { mechanism: "trigger" const azure = Azure.configure({ resourceName: "fixture" }).responses("fixture") const xai = XAI.configure().responses("fixture") // @ts-expect-error Azure must not inherit OpenAI's trigger operation. -ai.compact(ai.request({ model: azure }), { mechanism: "trigger" }) -ai.compact(ai.request({ model: Azure.responsesModel("fixture", { resourceName: "fixture" }) }), { +ai.compact(ai.request({ model: azure, prompt: "Hello" }), { mechanism: "trigger" }) +ai.compact(ai.request({ model: Azure.responsesModel("fixture", { resourceName: "fixture" }), prompt: "Hello" }), { // @ts-expect-error Azure's package entrypoint must preserve its narrower capability. mechanism: "trigger", }) // @ts-expect-error xAI endpoint support does not imply trigger support. -ai.compact(ai.request({ model: xai }), { mechanism: "trigger" }) +ai.compact(ai.request({ model: xai, prompt: "Hello" }), { mechanism: "trigger" }) // @ts-expect-error xAI's package entrypoint must preserve its narrower capability. -ai.compact(ai.request({ model: XAI.model("fixture", {}) }), { mechanism: "trigger" }) +ai.compact(ai.request({ model: XAI.model("fixture", {}), prompt: "Hello" }), { mechanism: "trigger" }) const unsupported = { - bedrock: ai.request({ model: AmazonBedrock.configure().model("fixture") }), - mantle: ai.request({ model: AmazonBedrockMantle.configure().responses("fixture") }), - anthropic: ai.request({ model: Anthropic.configure().model("fixture") }), - openai: ai.request({ model: OpenAI.configure().chat("fixture") }), - azure: ai.request({ model: Azure.configure({ resourceName: "fixture" }).chat("fixture") }), - xai: ai.request({ model: XAI.configure().chat("fixture") }), + bedrock: ai.request({ model: AmazonBedrock.configure().model("fixture"), prompt: "Hello" }), + mantle: ai.request({ model: AmazonBedrockMantle.configure().responses("fixture"), prompt: "Hello" }), + anthropic: ai.request({ model: Anthropic.configure().model("fixture"), prompt: "Hello" }), + openai: ai.request({ model: OpenAI.configure().chat("fixture"), prompt: "Hello" }), + azure: ai.request({ model: Azure.configure({ resourceName: "fixture" }).chat("fixture"), prompt: "Hello" }), + xai: ai.request({ model: XAI.configure().chat("fixture"), prompt: "Hello" }), compatible: ai.request({ model: OpenAICompatibleResponses.configure({ baseURL: "https://example.com" }).model("fixture"), + prompt: "Hello", }), } // @ts-expect-error Bedrock does not expose trigger compaction. @@ -94,13 +95,14 @@ ai.compact(unsupported.xai, { mechanism: "trigger" }) ai.compact(unsupported.compatible, { mechanism: "trigger" }) // @ts-expect-error Changing the model replaces its capability. ai.compact(LLMRequest.update(request, { model: azure }), { mechanism: "trigger" }) -ai.compact(ai.request({ model: LanguageModel.update(model, { route: azure.route }) }), { +ai.compact(ai.request({ model: LanguageModel.update(model, { route: azure.route }), prompt: "Hello" }), { // @ts-expect-error Changing the route replaces its capability. mechanism: "trigger", }) ai.compact( ai.request({ model: model.route.with({ compact: { endpoint: model.route.compact.endpoint } }).model({ id: "fixture" }), + prompt: "Hello", }), // @ts-expect-error Replacing route operations does not retain the old trigger capability. { mechanism: "trigger" }, @@ -110,11 +112,11 @@ declare const dynamic: LLMRequest declare const patch: Partial declare const routePatch: RoutePatch // @ts-expect-error A dynamic operation override cannot preserve trigger support. -ai.compact(ai.request({ model: model.route.with(routePatch).model({ id: "fixture" }) }), { +ai.compact(ai.request({ model: model.route.with(routePatch).model({ id: "fixture" }), prompt: "Hello" }), { mechanism: "trigger", }) // @ts-expect-error Explicitly removing operations removes trigger support. -ai.compact(ai.request({ model: model.route.with({ compact: undefined }).model({ id: "fixture" }) }), { +ai.compact(ai.request({ model: model.route.with({ compact: undefined }).model({ id: "fixture" }), prompt: "Hello" }), { mechanism: "trigger", }) // @ts-expect-error Dynamic models must be narrowed. @@ -140,7 +142,7 @@ void AI.ai.compact(request, { mechanism: "trigger", webSocket, signal: AbortSign // @ts-expect-error Endpoint compaction does not accept a WebSocket executor. void AI.ai.compact(request, { webSocket }) // @ts-expect-error Azure must not inherit OpenAI's trigger operation. -void AI.ai.compact(ai.request({ model: azure }), { mechanism: "trigger" }) +void AI.ai.compact(ai.request({ model: azure, prompt: "Hello" }), { mechanism: "trigger" }) // @ts-expect-error OpenAI Chat does not expose explicit compaction. void AI.ai.compact(unsupported.openai) // @ts-expect-error Dynamic models must be narrowed. diff --git a/packages/ai/test/provider-options/compaction.types.ts b/packages/ai/test/provider-options/compaction.types.ts index 2782cfa20e3..6c63a5f1e92 100644 --- a/packages/ai/test/provider-options/compaction.types.ts +++ b/packages/ai/test/provider-options/compaction.types.ts @@ -32,12 +32,13 @@ for (const model of [ } const unsupported = { - anthropic: ai.request({ model: Anthropic.configure().model("fixture") }), - openaiChat: ai.request({ model: OpenAI.configure().chat("fixture") }), - azureChat: ai.request({ model: Azure.configure({ resourceName: "test" }).chat("fixture") }), - xaiChat: ai.request({ model: XAI.configure().chat("fixture") }), + anthropic: ai.request({ model: Anthropic.configure().model("fixture"), prompt: "Hello" }), + openaiChat: ai.request({ model: OpenAI.configure().chat("fixture"), prompt: "Hello" }), + azureChat: ai.request({ model: Azure.configure({ resourceName: "test" }).chat("fixture"), prompt: "Hello" }), + xaiChat: ai.request({ model: XAI.configure().chat("fixture"), prompt: "Hello" }), compatible: ai.request({ model: OpenAICompatibleResponses.configure({ baseURL: "https://example.com" }).model("fixture"), + prompt: "Hello", }), } // @ts-expect-error Anthropic has no standalone compact endpoint. @@ -64,7 +65,10 @@ ai.compact(switched) ai.compact(LLMRequest.update(switched, { model: openai })) ai.compact( // @ts-expect-error Replacing the route also replaces compaction capability. - ai.request({ model: LanguageModel.update(openai, { route: Anthropic.configure().model("fixture").route }) }), + ai.request({ + model: LanguageModel.update(openai, { route: Anthropic.configure().model("fixture").route }), + prompt: "Hello", + }), ) declare const dynamicModel: LanguageModel @@ -110,6 +114,7 @@ ai.compact(ai.request({ model: openai, prompt: "hello" })).pipe( ) ai.request({ model: openai, + prompt: "Hello", providerOptions: { // @ts-expect-error A token threshold is numeric. contextManagement: [{ type: "compaction", compactThreshold: "100000" }], @@ -118,6 +123,7 @@ ai.request({ const anthropic = Anthropic.configure().model("claude-opus-4-6") ai.request({ model: anthropic, + prompt: "Hello", providerOptions: { contextManagement: { edits: [{ type: "compact_20260112", pauseAfterCompaction: true, instructions: "Summarize without using tools" }], @@ -126,6 +132,7 @@ ai.request({ }) ai.request({ model: anthropic, + prompt: "Hello", providerOptions: { // @ts-expect-error A pause setting is boolean. contextManagement: { edits: [{ type: "compact_20260112", pauseAfterCompaction: "yes" }] }, diff --git a/packages/ai/test/provider-options/minimax.types.ts b/packages/ai/test/provider-options/minimax.types.ts index e4e9effd614..121fba4b878 100644 --- a/packages/ai/test/provider-options/minimax.types.ts +++ b/packages/ai/test/provider-options/minimax.types.ts @@ -3,24 +3,31 @@ import { MiniMax } from "../../src/providers.js" const minimax = MiniMax.configure() -ai.request({ model: minimax.model("MiniMax-M3"), providerOptions: { thinking: { type: "adaptive" } } }) -ai.request({ model: minimax.chat("MiniMax-M3"), providerOptions: { thinking: { type: "disabled" } } }) -ai.request({ model: minimax.chat("MiniMax-M3"), providerOptions: { reasoningSplit: false } }) -ai.request({ model: minimax.responses("MiniMax-M3"), providerOptions: { reasoningEffort: "minimal" } }) -ai.request({ model: minimax.responses("MiniMax-M3"), providerOptions: { reasoningEffort: "future-effort" } }) +ai.request({ model: minimax.model("MiniMax-M3"), prompt: "Hello", providerOptions: { thinking: { type: "adaptive" } } }) +ai.request({ model: minimax.chat("MiniMax-M3"), prompt: "Hello", providerOptions: { thinking: { type: "disabled" } } }) +ai.request({ model: minimax.chat("MiniMax-M3"), prompt: "Hello", providerOptions: { reasoningSplit: false } }) +ai.request({ model: minimax.responses("MiniMax-M3"), prompt: "Hello", providerOptions: { reasoningEffort: "minimal" } }) +ai.request({ + model: minimax.responses("MiniMax-M3"), + prompt: "Hello", + providerOptions: { reasoningEffort: "future-effort" }, +}) ai.request({ model: minimax.model("MiniMax-M3"), + prompt: "Hello", // @ts-expect-error MiniMax Messages has no documented effort setting. providerOptions: { effort: "high" }, }) ai.request({ model: minimax.chat("MiniMax-M3"), + prompt: "Hello", // @ts-expect-error Chat reasoning_split is a boolean. providerOptions: { reasoningSplit: "true" }, }) ai.request({ model: minimax.responses("MiniMax-M3"), + prompt: "Hello", // @ts-expect-error MiniMax Responses uses reasoning effort rather than Messages thinking. providerOptions: { thinking: { type: "adaptive" } }, }) diff --git a/packages/ai/test/provider-options/moonshot.types.ts b/packages/ai/test/provider-options/moonshot.types.ts index f87ce39fa74..216976aa35e 100644 --- a/packages/ai/test/provider-options/moonshot.types.ts +++ b/packages/ai/test/provider-options/moonshot.types.ts @@ -3,27 +3,43 @@ import { Moonshot } from "../../src/providers.js" const moonshot = Moonshot.configure() -ai.request({ model: moonshot.model("kimi-k2.6"), providerOptions: { thinking: { type: "enabled", keep: "all" } } }) -ai.request({ model: moonshot.chat("kimi-k2.6"), providerOptions: { thinking: { type: "disabled", keep: null } } }) -ai.request({ model: moonshot.chat("kimi-k3"), providerOptions: { reasoningEffort: "high" } }) +ai.request({ + model: moonshot.model("kimi-k2.6"), + prompt: "Hello", + providerOptions: { thinking: { type: "enabled", keep: "all" } }, +}) +ai.request({ + model: moonshot.chat("kimi-k2.6"), + prompt: "Hello", + providerOptions: { thinking: { type: "disabled", keep: null } }, +}) +ai.request({ model: moonshot.chat("kimi-k3"), prompt: "Hello", providerOptions: { reasoningEffort: "high" } }) ai.request({ model: moonshot.messages("kimi-k3"), + prompt: "Hello", providerOptions: { effort: "low", metadata: { user_id: "fixture" } }, }) -ai.request({ model: moonshot.responses("kimi-k3"), providerOptions: { reasoningEffort: "future-effort" } }) +ai.request({ + model: moonshot.responses("kimi-k3"), + prompt: "Hello", + providerOptions: { reasoningEffort: "future-effort" }, +}) ai.request({ model: moonshot.messages("kimi-k3"), + prompt: "Hello", // @ts-expect-error Messages exposes effort rather than the K2 Chat thinking parameter. providerOptions: { thinking: { type: "enabled" } }, }) ai.request({ model: moonshot.chat("kimi-k2.6"), + prompt: "Hello", // @ts-expect-error Preserved thinking takes a string or null. providerOptions: { thinking: { type: "enabled", keep: true } }, }) ai.request({ model: moonshot.responses("kimi-k3"), + prompt: "Hello", // @ts-expect-error Responses uses reasoningEffort rather than the Messages effort option. providerOptions: { effort: "high" }, }) diff --git a/packages/ai/test/provider-options/venice.types.ts b/packages/ai/test/provider-options/venice.types.ts index 28ff86a6137..1791361f622 100644 --- a/packages/ai/test/provider-options/venice.types.ts +++ b/packages/ai/test/provider-options/venice.types.ts @@ -3,24 +3,37 @@ import { Venice } from "../../src/providers.js" ai.request({ model: Venice.chat("qwen3-6-27b"), - providerOptions: { reasoningEffort: "high", reasoning: { summary: "concise" }, veniceParameters: { includeVeniceSystemPrompt: false } }, + prompt: "Hello", + providerOptions: { + reasoningEffort: "high", + reasoning: { summary: "concise" }, + veniceParameters: { includeVeniceSystemPrompt: false }, + }, }) ai.request({ model: Venice.configure({ providerOptions: { reasoningEffort: "future-effort" } }).model("future-model"), - providerOptions: { reasoning: { enabled: false }, promptCacheRetention: "future-retention", parallelToolCalls: false }, + prompt: "Hello", + providerOptions: { + reasoning: { enabled: false }, + promptCacheRetention: "future-retention", + parallelToolCalls: false, + }, }) ai.request({ model: Venice.chat("qwen3-6-27b"), + prompt: "Hello", // @ts-expect-error Thinking toggles are boolean. providerOptions: { reasoning: { enabled: "false" } }, }) ai.request({ model: Venice.chat("qwen3-6-27b"), + prompt: "Hello", // @ts-expect-error Venice uses nested reasoning, not Anthropic thinking controls. providerOptions: { thinking: { type: "disabled" } }, }) ai.request({ model: Venice.chat("qwen3-6-27b"), + prompt: "Hello", // @ts-expect-error Venice's system-prompt toggle is boolean. providerOptions: { veniceParameters: { includeVeniceSystemPrompt: "false" } }, }) diff --git a/packages/ai/test/provider-options/zai.types.ts b/packages/ai/test/provider-options/zai.types.ts index 6db506e29c9..45a068619fd 100644 --- a/packages/ai/test/provider-options/zai.types.ts +++ b/packages/ai/test/provider-options/zai.types.ts @@ -3,30 +3,40 @@ import { ZAI, ZAICodingPlan } from "../../src/providers.js" ai.request({ model: ZAI.chat("glm-5.3"), + prompt: "Hello", providerOptions: { thinking: { clear_thinking: false }, reasoningEffort: "max" }, }) ai.request({ model: ZAI.chat("glm-5.2"), + prompt: "Hello", providerOptions: { thinking: { type: "disabled" }, toolStream: false, responseFormat: { type: "json_object" } }, }) ai.request({ model: ZAICodingPlan.messages("glm-5.3"), + prompt: "Hello", providerOptions: { thinking: { type: "enabled" }, effort: "high" }, }) -ai.request({ model: ZAICodingPlan.responses("glm-5.3"), providerOptions: { reasoningEffort: "future-effort" } }) +ai.request({ + model: ZAICodingPlan.responses("glm-5.3"), + prompt: "Hello", + providerOptions: { reasoningEffort: "future-effort" }, +}) ai.request({ model: ZAI.chat("glm-5.3"), + prompt: "Hello", // @ts-expect-error clear_thinking is a boolean. providerOptions: { thinking: { clear_thinking: "false" } }, }) ai.request({ model: ZAICodingPlan.messages("glm-5.3"), + prompt: "Hello", // @ts-expect-error Messages uses effort. providerOptions: { reasoningEffort: "high" }, }) ai.request({ model: ZAICodingPlan.responses("glm-5.3"), + prompt: "Hello", // @ts-expect-error Responses uses reasoning effort, not Chat thinking controls. providerOptions: { thinking: { type: "enabled" } }, }) diff --git a/packages/ai/test/provider-package.test.ts b/packages/ai/test/provider-package.test.ts index 9d0aff227fc..7b53054f480 100644 --- a/packages/ai/test/provider-package.test.ts +++ b/packages/ai/test/provider-package.test.ts @@ -306,7 +306,10 @@ describe("provider package entrypoints", () => { baseURL: "https://messages.example.test/v1", }) expect( - Endpoint.render(selected.route.endpoint, { request: ai.request({ model: selected }), body: {} }).toString(), + Endpoint.render(selected.route.endpoint, { + request: ai.request({ model: selected, prompt: "Hello" }), + body: {}, + }).toString(), ).toBe("https://messages.example.test/v1/messages") expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" }) expect(selected.route.defaults.http?.body).toEqual({ metadata: { user_id: "user_1" } }) diff --git a/packages/ai/test/provider/alibaba.test.ts b/packages/ai/test/provider/alibaba.test.ts index e20b505a359..16cc946f33c 100644 --- a/packages/ai/test/provider/alibaba.test.ts +++ b/packages/ai/test/provider/alibaba.test.ts @@ -64,7 +64,7 @@ it.effect("Alibaba owns regional shared and workspace-specific endpoints", () => ]) { const provider = Alibaba.configure({ region, apiKey: "fixture" }) for (const api of ["chat", "messages", "responses"] as const) { - const request = ai.request({ model: provider[api]("qwen3.8-max") }) + const request = ai.request({ model: provider[api]("qwen3.8-max"), prompt: "Hello" }) const compiled = yield* compileRequest(request) expect(Endpoint.render(request.model.route.endpoint, { request, body: compiled.body }).toString()).toBe( `https://${host}${paths[api]}`, @@ -118,7 +118,7 @@ it.effect("Alibaba resolves explicit auth, API keys, and regional environment cr ]) { const provider = Alibaba.configure({ region: "ap-southeast-1", ...item.config }) for (const api of ["chat", "messages", "responses"] as const) { - const request = ai.request({ model: provider[api]("qwen3.8-max") }) + const request = ai.request({ model: provider[api]("qwen3.8-max"), prompt: "Hello" }) const headers = yield* request.model.route.auth .apply({ request, method: "POST", url: "https://fixture", body: "{}", headers: Headers.empty }) .pipe(Effect.provide(ConfigProvider.layer(ConfigProvider.fromEnv({ env: item.env })))) @@ -133,13 +133,21 @@ it.effect("Alibaba keeps native reasoning controls and future efforts on their s const provider = Alibaba.configure({ region: "ap-southeast-1", apiKey: "fixture" }) for (const effort of ["none", "minimal", "low", "medium", "high", "xhigh", "max", "future-effort"]) { const chat = yield* compileRequest( - ai.request({ model: provider.chat("qwen3.8-max"), providerOptions: { reasoningEffort: effort } }), + ai.request({ + model: provider.chat("qwen3.8-max"), + prompt: "Hello", + providerOptions: { reasoningEffort: effort }, + }), ) const messages = yield* compileRequest( - ai.request({ model: provider.messages("qwen3.8-max"), providerOptions: { effort } }), + ai.request({ model: provider.messages("qwen3.8-max"), prompt: "Hello", providerOptions: { effort } }), ) const responses = yield* compileRequest( - ai.request({ model: provider.responses("qwen3.8-max"), providerOptions: { reasoningEffort: effort } }), + ai.request({ + model: provider.responses("qwen3.8-max"), + prompt: "Hello", + providerOptions: { reasoningEffort: effort }, + }), ) expect(chat.body.reasoning_effort).toBe(effort) expect(messages.body.output_config).toEqual({ effort }) @@ -153,6 +161,7 @@ it.effect("Alibaba keeps native reasoning controls and future efforts on their s const chat = yield* compileRequest( ai.request({ model: provider.chat("qwen3.7-plus"), + prompt: "Hello", tools: [tool], generation: { maxTokens: 1234, topK: 20 }, providerOptions: { @@ -190,6 +199,7 @@ it.effect("Alibaba keeps native reasoning controls and future efforts on their s const responses = yield* compileRequest( ai.request({ model: provider.responses("qwen3.7-plus"), + prompt: "Hello", providerOptions: { enableThinking, store: false, previousResponseId: "resp_previous" }, }), ) @@ -206,7 +216,7 @@ it.effect("Alibaba keeps native reasoning controls and future efforts on their s { type: "future", budget_tokens: 4096 }, ]) { const messages = yield* compileRequest( - ai.request({ model: provider.messages("qwen3.7-plus"), providerOptions: { thinking } }), + ai.request({ model: provider.messages("qwen3.7-plus"), prompt: "Hello", providerOptions: { thinking } }), ) expect(messages.body.thinking).toEqual({ type: thinking.type, @@ -252,7 +262,7 @@ it.effect("Alibaba validates malformed options before execution", () => ["responses", { enableThinking: "false" }], ] as const) { const model = provider[api]("qwen3.8-max").route.with({ providerOptions }).model({ id: "qwen3.8-max" }) - const error = yield* compileRequest(ai.request({ model })).pipe(Effect.flip) + const error = yield* compileRequest(ai.request({ model, prompt: "Hello" })).pipe(Effect.flip) expect(error.reason._tag).toBe("InvalidRequest") } }), diff --git a/packages/ai/test/provider/checkpoint.test.ts b/packages/ai/test/provider/checkpoint.test.ts index bb9f124a966..4d6efae5b8c 100644 --- a/packages/ai/test/provider/checkpoint.test.ts +++ b/packages/ai/test/provider/checkpoint.test.ts @@ -276,7 +276,10 @@ testEffect(dynamicResponse(() => Effect.die("Must reject before sending"))).effe () => Effect.gen(function* () { const client = yield* LLMClient.Service - const unsupported = ai.request({ model: Azure.configure({ resourceName: "fixture" }).responses("fixture") }) + const unsupported = ai.request({ + model: Azure.configure({ resourceName: "fixture" }).responses("fixture"), + prompt: "Hello", + }) expect(ai.canCompact(unsupported)).toBe(true) expect(ai.canCompact(unsupported, trigger)).toBe(false) // @ts-expect-error Exercise untyped consumers; the service must reject before sending. diff --git a/packages/ai/test/provider/cohere.test.ts b/packages/ai/test/provider/cohere.test.ts index af057ba64a2..6a26af4aca9 100644 --- a/packages/ai/test/provider/cohere.test.ts +++ b/packages/ai/test/provider/cohere.test.ts @@ -214,6 +214,7 @@ it.effect("Cohere thinking budgets must be positive integers", () => const error = yield* compileRequest( ai.request({ model: cohere.model("command-a-reasoning-08-2025"), + prompt: "Hello", providerOptions: { thinking: { tokenBudget: 0 } }, }), ).pipe(Effect.flip) diff --git a/packages/ai/test/provider/minimax.test.ts b/packages/ai/test/provider/minimax.test.ts index b9e31434d95..9c14b56cba7 100644 --- a/packages/ai/test/provider/minimax.test.ts +++ b/packages/ai/test/provider/minimax.test.ts @@ -73,13 +73,18 @@ describe("MiniMax provider", () => { Effect.gen(function* () { const minimax = MiniMax.configure({ apiKey: "fixture" }) const messages = yield* compileRequest( - ai.request({ model: minimax.model("MiniMax-M3"), providerOptions: { thinking: { type: "adaptive" } } }), + ai.request({ + model: minimax.model("MiniMax-M3"), + prompt: "Hello", + providerOptions: { thinking: { type: "adaptive" } }, + }), ) expect(messages.body.thinking).toEqual({ type: "adaptive" }) expect(messages.body.output_config).toBeUndefined() const chat = yield* compileRequest( ai.request({ model: minimax.chat("MiniMax-M3"), + prompt: "Hello", generation: { maxTokens: 128 }, providerOptions: { thinking: { type: "disabled" }, reasoningSplit: false }, }), @@ -92,7 +97,11 @@ describe("MiniMax provider", () => { }) expect(chat.body.store).toBeUndefined() const responses = yield* compileRequest( - ai.request({ model: minimax.responses("MiniMax-M3"), providerOptions: { reasoningEffort: "minimal" } }), + ai.request({ + model: minimax.responses("MiniMax-M3"), + prompt: "Hello", + providerOptions: { reasoningEffort: "minimal" }, + }), ) expect(responses.body.reasoning).toEqual({ effort: "minimal" }) expect(responses.body.include).toBeUndefined() diff --git a/packages/ai/test/provider/moonshot.test.ts b/packages/ai/test/provider/moonshot.test.ts index 6367b220e04..a7413f7fe61 100644 --- a/packages/ai/test/provider/moonshot.test.ts +++ b/packages/ai/test/provider/moonshot.test.ts @@ -104,20 +104,24 @@ it.effect("Moonshot lowers API-specific reasoning options without adding unrelat const moonshot = Moonshot.configure({ apiKey: "fixture" }) for (const thinking of [{ type: "disabled" }, { type: "enabled", keep: "all" }, { type: "enabled", keep: null }]) { const result = yield* compileRequest( - ai.request({ model: moonshot.chat("kimi-k2.6"), providerOptions: { thinking } }), + ai.request({ model: moonshot.chat("kimi-k2.6"), prompt: "Hello", providerOptions: { thinking } }), ) expect(result.body.thinking).toEqual(thinking) expect(result.body.reasoning_effort).toBeUndefined() } for (const effort of ["low", "high", "max", "future-effort"]) { const chat = yield* compileRequest( - ai.request({ model: moonshot.chat("kimi-k3"), providerOptions: { reasoningEffort: effort } }), + ai.request({ model: moonshot.chat("kimi-k3"), prompt: "Hello", providerOptions: { reasoningEffort: effort } }), ) const messages = yield* compileRequest( - ai.request({ model: moonshot.messages("kimi-k3"), providerOptions: { effort } }), + ai.request({ model: moonshot.messages("kimi-k3"), prompt: "Hello", providerOptions: { effort } }), ) const responses = yield* compileRequest( - ai.request({ model: moonshot.responses("kimi-k3"), providerOptions: { reasoningEffort: effort } }), + ai.request({ + model: moonshot.responses("kimi-k3"), + prompt: "Hello", + providerOptions: { reasoningEffort: effort }, + }), ) expect(chat.body.reasoning_effort).toBe(effort) expect(messages.body.output_config).toEqual({ effort }) @@ -135,7 +139,7 @@ it.effect("Moonshot validates native Chat thinking options", () => .chat("kimi-k2.6") .route.with({ providerOptions: { thinking: { type: "enabled", keep: 42 } } }) .model({ id: "kimi-k2.6" }) - const failure = yield* compileRequest(ai.request({ model: invalid })).pipe(Effect.flip) + const failure = yield* compileRequest(ai.request({ model: invalid, prompt: "Hello" })).pipe(Effect.flip) expect(failure.reason._tag).toBe("InvalidRequest") expect(failure.message).toContain("keep") }), diff --git a/packages/ai/test/provider/openai-compatible-responses.test.ts b/packages/ai/test/provider/openai-compatible-responses.test.ts index 85234e6c70f..ea1b37e5561 100644 --- a/packages/ai/test/provider/openai-compatible-responses.test.ts +++ b/packages/ai/test/provider/openai-compatible-responses.test.ts @@ -180,6 +180,7 @@ describe("Open Responses-compatible route", () => { const prepared = yield* compileRequest( ai.request({ model, + prompt: "Hello", tools: [ { type: "namespace", diff --git a/packages/ai/test/provider/openai-responses.test.ts b/packages/ai/test/provider/openai-responses.test.ts index 1d61b38f83c..ef64359ba32 100644 --- a/packages/ai/test/provider/openai-responses.test.ts +++ b/packages/ai/test/provider/openai-responses.test.ts @@ -223,6 +223,7 @@ describe("OpenAI Responses route", () => { const prepared = yield* compileRequest( ai.request({ model, + prompt: "Hello", tools: [ { type: "namespace", @@ -265,6 +266,7 @@ describe("OpenAI Responses route", () => { const prepared = yield* compileRequest( ai.request({ model, + prompt: "Hello", tools: [ { type: "namespace", diff --git a/packages/ai/test/provider/venice.test.ts b/packages/ai/test/provider/venice.test.ts index 7c3f12d635f..30440c75eda 100644 --- a/packages/ai/test/provider/venice.test.ts +++ b/packages/ai/test/provider/venice.test.ts @@ -53,6 +53,7 @@ it.effect("Venice lowers typed options, model defaults, and explicit reasoning o model: Venice.configure({ apiKey: "fixture", providerOptions: { reasoningEffort: "low" } }).model( "qwen3-6-27b", ), + prompt: "Hello", generation: { maxTokens: 200, topK: 20 }, providerOptions: { reasoningEffort: "future-effort", @@ -97,10 +98,12 @@ it.effect("Venice lowers typed options, model defaults, and explicit reasoning o expect(compiled.body.reasoning_effort).toBeUndefined() expect(compiled.body.max_tokens).toBeUndefined() expect( - (yield* compileRequest(ai.request({ model, providerOptions: { reasoning: { enabled: false } } }))).body.reasoning, + (yield* compileRequest( + ai.request({ model, prompt: "Hello", providerOptions: { reasoning: { enabled: false } } }), + )).body.reasoning, ).toEqual({ enabled: false }) expect( - (yield* compileRequest(ai.request({ model, cache: "none", promptCacheKey: "session-123" }))).body + (yield* compileRequest(ai.request({ model, prompt: "Hello", cache: "none", promptCacheKey: "session-123" }))).body .prompt_cache_key, ).toBeUndefined() }), diff --git a/packages/ai/test/provider/zai.test.ts b/packages/ai/test/provider/zai.test.ts index 34f7b4080c6..427c653ee4b 100644 --- a/packages/ai/test/provider/zai.test.ts +++ b/packages/ai/test/provider/zai.test.ts @@ -106,6 +106,7 @@ it.effect("ZAI Chat retains native thinking fields and scopes tool streaming to const result = yield* compileRequest( ai.request({ model: provider.chat("glm-5.2"), + prompt: "Hello", providerOptions: { thinking, toolStream: false, @@ -160,18 +161,23 @@ it.effect("ZAI lowers effort using the selected native API without inventing thi const standard = yield* compileRequest( ai.request({ model: ZAI.configure({ apiKey: "fixture" }).chat("glm-5.3"), + prompt: "Hello", providerOptions: { reasoningEffort: effort }, }), ) const coding = ZAICodingPlan.configure({ apiKey: "fixture" }) const chat = yield* compileRequest( - ai.request({ model: coding.chat("glm-5.3"), providerOptions: { reasoningEffort: effort } }), + ai.request({ model: coding.chat("glm-5.3"), prompt: "Hello", providerOptions: { reasoningEffort: effort } }), ) const messages = yield* compileRequest( - ai.request({ model: coding.messages("glm-5.3"), providerOptions: { effort } }), + ai.request({ model: coding.messages("glm-5.3"), prompt: "Hello", providerOptions: { effort } }), ) const responses = yield* compileRequest( - ai.request({ model: coding.responses("glm-5.3"), providerOptions: { reasoningEffort: effort } }), + ai.request({ + model: coding.responses("glm-5.3"), + prompt: "Hello", + providerOptions: { reasoningEffort: effort }, + }), ) expect(standard.body.reasoning_effort).toBe(effort) expect(chat.body.reasoning_effort).toBe(effort) @@ -185,6 +191,7 @@ it.effect("ZAI lowers effort using the selected native API without inventing thi model: ZAICodingPlan.configure({ apiKey: "fixture", providerOptions: { thinking: { type } } }).messages( "glm-5.3", ), + prompt: "Hello", }), ) expect(result.body.thinking).toEqual({ type }) @@ -230,7 +237,7 @@ it.effect("ZAI rejects invalid typed thinking options before execution", () => .chat("glm-5.3") .route.with({ providerOptions: { thinking: { clear_thinking: "false" } } }) .model({ id: "glm-5.3" }) - const error = yield* compileRequest(ai.request({ model })).pipe(Effect.flip) + const error = yield* compileRequest(ai.request({ model, prompt: "Hello" })).pipe(Effect.flip) expect(error.reason._tag).toBe("InvalidRequest") expect(error.message).toContain("clear_thinking") }),