From 39416a0d954a7b210b34d58cb5724c586e94a691 Mon Sep 17 00:00:00 2001 From: Kit Langton Date: Thu, 27 Aug 2026 17:07:02 -0400 Subject: [PATCH] test(ai): align test runners with API boundaries (#45469) --- packages/ai/test/adapter.test.ts | 16 +- packages/ai/test/generate-object.test.ts | 32 +-- packages/ai/test/provider/cloudflare.test.ts | 22 +- .../ai/test/provider/google-vertex.test.ts | 14 +- .../ai/test/provider/native-providers.test.ts | 191 ++++++++---------- .../provider/openai-compatible-chat.test.ts | 64 +++--- packages/ai/test/schema.test.ts | 76 +++---- packages/ai/test/tool-runtime.test.ts | 140 ++++++------- packages/ai/test/tool-stream.test.ts | 80 ++++---- 9 files changed, 301 insertions(+), 334 deletions(-) diff --git a/packages/ai/test/adapter.test.ts b/packages/ai/test/adapter.test.ts index f9602e4d00f..0b5978ce5eb 100644 --- a/packages/ai/test/adapter.test.ts +++ b/packages/ai/test/adapter.test.ts @@ -1,4 +1,4 @@ -import { describe, expect } from "bun:test" +import { describe, expect, test } from "bun:test" import { Effect, Schema, Stream } from "effect" import { LLM, LLMRequest, LLMResponse } from "../src/index.js" import { Route, Endpoint, LLMClient, Protocol, type FramingDef } from "../src/route.js" @@ -148,15 +148,13 @@ describe("llm route", () => { }), ) - it.effect("builds models from configured routes", () => - Effect.gen(function* () { - const configured = fake.with({ provider: "fake-provider", endpoint: { baseURL: "https://fake.local" } }) + test("builds models from configured routes", () => { + const configured = fake.with({ provider: "fake-provider", endpoint: { baseURL: "https://fake.local" } }) - expect(configured.model({ id: "fake-model" })).toMatchObject({ - provider: "fake-provider", - }) - }), - ) + expect(configured.model({ id: "fake-model" })).toMatchObject({ + provider: "fake-provider", + }) + }) it.effect("does not register duplicate route ids globally", () => Effect.gen(function* () { diff --git a/packages/ai/test/generate-object.test.ts b/packages/ai/test/generate-object.test.ts index d29725e715d..dd4490807bd 100644 --- a/packages/ai/test/generate-object.test.ts +++ b/packages/ai/test/generate-object.test.ts @@ -44,21 +44,23 @@ describe("Tool.make (dynamic JSON Schema)", () => { expect(definition?.inputSchema).toEqual(jsonSchema) }) - test("execute receives the raw input untouched", async () => { - const seen: unknown[] = [] - const tool = Tool.make({ - description: "echo", - jsonSchema: { type: "object" }, - execute: (params) => - Effect.sync(() => { - seen.push(params) - return { ok: true } - }), - }) - const result = await Effect.runPromise(tool.execute({ hello: "world" })) - expect(seen).toEqual([{ hello: "world" }]) - expect(result).toEqual({ ok: true }) - }) + it.effect("execute receives the raw input untouched", () => + Effect.gen(function* () { + const seen: unknown[] = [] + const tool = Tool.make({ + description: "echo", + jsonSchema: { type: "object" }, + execute: (params) => + Effect.sync(() => { + seen.push(params) + return { ok: true } + }), + }) + const result = yield* tool.execute({ hello: "world" }) + expect(seen).toEqual([{ hello: "world" }]) + expect(result).toEqual({ ok: true }) + }), + ) }) describe("LLM.generateObject", () => { diff --git a/packages/ai/test/provider/cloudflare.test.ts b/packages/ai/test/provider/cloudflare.test.ts index 5940d3c10b6..784915d27a3 100644 --- a/packages/ai/test/provider/cloudflare.test.ts +++ b/packages/ai/test/provider/cloudflare.test.ts @@ -1,4 +1,4 @@ -import { describe, expect } from "bun:test" +import { describe, expect, test } from "bun:test" import { ConfigProvider, Effect, Schema } from "effect" import { HttpClientRequest } from "effect/unstable/http" import { LLM, LLMEvent } from "../../src/index.js" @@ -136,17 +136,15 @@ describe("Cloudflare", () => { }), ) - it.effect("defaults AI Gateway id to default when omitted or blank", () => - Effect.gen(function* () { - expect( - CloudflareAIGateway.configure({ - accountId: "test-account", - gatewayId: "", - gatewayApiKey: "test-token", - }).model("workers-ai/@cf/meta/llama-3.3-70b-instruct").route.endpoint.baseURL, - ).toBe("https://gateway.ai.cloudflare.com/v1/test-account/default/compat") - }), - ) + test("defaults AI Gateway id to default when omitted or blank", () => { + expect( + CloudflareAIGateway.configure({ + accountId: "test-account", + gatewayId: "", + gatewayApiKey: "test-token", + }).model("workers-ai/@cf/meta/llama-3.3-70b-instruct").route.endpoint.baseURL, + ).toBe("https://gateway.ai.cloudflare.com/v1/test-account/default/compat") + }) it.effect("supports authenticated AI Gateway plus upstream provider auth", () => Effect.gen(function* () { diff --git a/packages/ai/test/provider/google-vertex.test.ts b/packages/ai/test/provider/google-vertex.test.ts index c6c3ee9c01c..7ffc83e4420 100644 --- a/packages/ai/test/provider/google-vertex.test.ts +++ b/packages/ai/test/provider/google-vertex.test.ts @@ -1,4 +1,4 @@ -import { describe, expect } from "bun:test" +import { describe, expect, test } from "bun:test" import { Effect } from "effect" import { HttpClientRequest } from "effect/unstable/http" import { LLM, Message, ToolCallPart } from "../../src/index.js" @@ -376,11 +376,9 @@ describe("Google Vertex providers", () => { }), ) - it.effect("rejects tuned Gemini models in express mode", () => - Effect.sync(() => { - expect(() => GoogleVertex.configure({ apiKey: "fixture" }).model("endpoints/1234567890")).toThrow( - "Google Vertex tuned models do not support Express Mode API keys", - ) - }), - ) + test("rejects tuned Gemini models in express mode", () => { + expect(() => GoogleVertex.configure({ apiKey: "fixture" }).model("endpoints/1234567890")).toThrow( + "Google Vertex tuned models do not support Express Mode API keys", + ) + }) }) diff --git a/packages/ai/test/provider/native-providers.test.ts b/packages/ai/test/provider/native-providers.test.ts index 7c4131f8826..66371f78f1d 100644 --- a/packages/ai/test/provider/native-providers.test.ts +++ b/packages/ai/test/provider/native-providers.test.ts @@ -1,4 +1,4 @@ -import { describe, expect } from "bun:test" +import { describe, expect, test } from "bun:test" import { ConfigProvider, Effect } from "effect" import { HttpClientRequest } from "effect/unstable/http" import { LLM, Message, ToolDefinition } from "../../src/index.js" @@ -31,82 +31,71 @@ import { dynamicResponse } from "../lib/http.js" import { sseEvents } from "../lib/sse.js" describe("native OpenAI-compatible providers", () => { - it.effect("assigns provider-owned metadata namespaces across native routes", () => - Effect.gen(function* () { - const vertex = { project: "project", accessToken: "token" } - const providers = [ - [OpenAI.configure({ apiKey: "test" }).chat("model"), "openai"], - [OpenAI.configure({ apiKey: "test" }).responses("model"), "openai"], - [Azure.configure({ resourceName: "resource", apiKey: "test" }).chat("model"), "azure"], - [Azure.configure({ resourceName: "resource", apiKey: "test" }).responses("model"), "azure"], - [AmazonBedrock.configure({ apiKey: "test" }).model("model"), "bedrock"], - [AmazonBedrockMantle.configure({ apiKey: "test" }).chat("model"), "mantle"], - [AmazonBedrockMantle.configure({ apiKey: "test" }).responses("model"), "mantle"], - [Google.configure({ apiKey: "test" }).model("model"), "google"], - [GoogleVertex.configure(vertex).model("model"), "vertex"], - [GoogleVertexChat.configure(vertex).model("model"), "vertex"], - [GoogleVertexResponses.configure(vertex).model("model"), "vertex"], - [GoogleVertexMessages.configure(vertex).model("model"), "anthropic"], - [Anthropic.configure({ apiKey: "test" }).model("model"), "anthropic"], - [ - AnthropicCompatible.configure({ baseURL: "https://example.test/v1", provider: "minimax" }).model("model"), - "minimax", - ], - [ - OpenAICompatible.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model("model"), - "custom", - ], - [ - OpenAICompatibleResponses.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model( - "model", - ), - "custom", - ], - [Cerebras.configure({ apiKey: "test" }).model("model"), "cerebras"], - [DeepInfra.configure({ apiKey: "test" }).model("model"), "deepinfra"], - [TogetherAI.configure({ apiKey: "test" }).model("model"), "togetherai"], - [CloudflareAIGateway.configure({ accountId: "account" }).model("model"), "cloudflare-ai-gateway"], - [CloudflareWorkersAI.configure({ accountId: "account" }).model("model"), "cloudflare-workers-ai"], - [OpenRouter.configure({ apiKey: "test" }).model("model"), "openrouter"], - [XAI.configure({ apiKey: "test" }).chat("model"), "xai"], - [XAI.configure({ apiKey: "test" }).responses("model"), "xai"], - ] as const + test("assigns provider-owned metadata namespaces across native routes", () => { + const vertex = { project: "project", accessToken: "token" } + const providers = [ + [OpenAI.configure({ apiKey: "test" }).chat("model"), "openai"], + [OpenAI.configure({ apiKey: "test" }).responses("model"), "openai"], + [Azure.configure({ resourceName: "resource", apiKey: "test" }).chat("model"), "azure"], + [Azure.configure({ resourceName: "resource", apiKey: "test" }).responses("model"), "azure"], + [AmazonBedrock.configure({ apiKey: "test" }).model("model"), "bedrock"], + [AmazonBedrockMantle.configure({ apiKey: "test" }).chat("model"), "mantle"], + [AmazonBedrockMantle.configure({ apiKey: "test" }).responses("model"), "mantle"], + [Google.configure({ apiKey: "test" }).model("model"), "google"], + [GoogleVertex.configure(vertex).model("model"), "vertex"], + [GoogleVertexChat.configure(vertex).model("model"), "vertex"], + [GoogleVertexResponses.configure(vertex).model("model"), "vertex"], + [GoogleVertexMessages.configure(vertex).model("model"), "anthropic"], + [Anthropic.configure({ apiKey: "test" }).model("model"), "anthropic"], + [ + AnthropicCompatible.configure({ baseURL: "https://example.test/v1", provider: "minimax" }).model("model"), + "minimax", + ], + [OpenAICompatible.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model("model"), "custom"], + [ + OpenAICompatibleResponses.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model("model"), + "custom", + ], + [Cerebras.configure({ apiKey: "test" }).model("model"), "cerebras"], + [DeepInfra.configure({ apiKey: "test" }).model("model"), "deepinfra"], + [TogetherAI.configure({ apiKey: "test" }).model("model"), "togetherai"], + [CloudflareAIGateway.configure({ accountId: "account" }).model("model"), "cloudflare-ai-gateway"], + [CloudflareWorkersAI.configure({ accountId: "account" }).model("model"), "cloudflare-workers-ai"], + [OpenRouter.configure({ apiKey: "test" }).model("model"), "openrouter"], + [XAI.configure({ apiKey: "test" }).chat("model"), "xai"], + [XAI.configure({ apiKey: "test" }).responses("model"), "xai"], + ] as const - for (const [model, key] of providers) expect(model.route.providerMetadataKey).toBe(key) - }), - ) + for (const [model, key] of providers) expect(model.route.providerMetadataKey).toBe(key) + }) - it.effect("preserves native Together AI and Cerebras provider and route identities", () => - Effect.gen(function* () { - const together = TogetherAI.configure({ apiKey: "fixture" }).model("meta-llama/Llama-3.3-70B") - const cerebras = Cerebras.configure({ apiKey: "fixture" }).model("qwen-3-235b-a22b") + test("preserves native Together AI and Cerebras provider and route identities", () => { + const together = TogetherAI.configure({ apiKey: "fixture" }).model("meta-llama/Llama-3.3-70B") + const cerebras = Cerebras.configure({ apiKey: "fixture" }).model("qwen-3-235b-a22b") - expect(together).toMatchObject({ - provider: "togetherai", - compatibility: { maxTokensField: "max_tokens", supportsStore: false, supportsStrictMode: false }, - route: { id: "togetherai-chat", protocol: "openai-chat" }, - }) - expect(together.route.endpoint.baseURL).toBe("https://api.together.xyz/v1") - expect(cerebras).toMatchObject({ - provider: "cerebras", - compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning", supportsStore: false }, - route: { id: "cerebras-chat", protocol: "openai-chat" }, - }) - expect(cerebras.route.endpoint.baseURL).toBe("https://api.cerebras.ai/v1") - }), - ) + expect(together).toMatchObject({ + provider: "togetherai", + compatibility: { maxTokensField: "max_tokens", supportsStore: false, supportsStrictMode: false }, + route: { id: "togetherai-chat", protocol: "openai-chat" }, + }) + expect(together.route.endpoint.baseURL).toBe("https://api.together.xyz/v1") + expect(cerebras).toMatchObject({ + provider: "cerebras", + compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning", supportsStore: false }, + route: { id: "cerebras-chat", protocol: "openai-chat" }, + }) + expect(cerebras.route.endpoint.baseURL).toBe("https://api.cerebras.ai/v1") + }) - it.effect("preserves native DeepInfra provider and route identity", () => - Effect.gen(function* () { - const deepinfra = DeepInfra.configure({ apiKey: "fixture" }).model("google/gemma-3-27b-it") - expect(deepinfra).toMatchObject({ - provider: "deepinfra", - compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning_content", supportsStore: false }, - route: { id: "deepinfra-chat", protocol: "openai-chat" }, - }) - expect(deepinfra.route.endpoint.baseURL).toBe("https://api.deepinfra.com/v1/openai") - }), - ) + test("preserves native DeepInfra provider and route identity", () => { + const deepinfra = DeepInfra.configure({ apiKey: "fixture" }).model("google/gemma-3-27b-it") + expect(deepinfra).toMatchObject({ + provider: "deepinfra", + compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning_content", supportsStore: false }, + route: { id: "deepinfra-chat", protocol: "openai-chat" }, + }) + expect(deepinfra.route.endpoint.baseURL).toBe("https://api.deepinfra.com/v1/openai") + }) it.effect("applies native provider request defaults even with a custom gateway URL", () => Effect.gen(function* () { @@ -161,39 +150,35 @@ describe("native OpenAI-compatible providers", () => { }), ) - it.effect("normalizes DeepInfra API roots without duplicating the OpenAI path", () => - Effect.gen(function* () { - for (const baseURL of [ - "https://gateway.example/v1", - "https://gateway.example/v1/", + test("normalizes DeepInfra API roots without duplicating the OpenAI path", () => { + for (const baseURL of [ + "https://gateway.example/v1", + "https://gateway.example/v1/", + "https://gateway.example/v1/openai", + "https://gateway.example/v1/openai/", + ]) { + expect(DeepInfra.configure({ apiKey: "fixture", baseURL }).model("gemma").route.endpoint.baseURL).toBe( "https://gateway.example/v1/openai", - "https://gateway.example/v1/openai/", - ]) { - expect(DeepInfra.configure({ apiKey: "fixture", baseURL }).model("gemma").route.endpoint.baseURL).toBe( - "https://gateway.example/v1/openai", - ) - } - }), - ) + ) + } + }) - it.effect("maps package settings onto native executable models", () => - Effect.gen(function* () { - for (const native of [TogetherAI, Cerebras]) { - const selected = native.model("provider-model", { - apiKey: "fixture", - baseURL: "https://gateway.example/v1", - headers: { "x-application": "opencode" }, - body: { service_tier: "priority" }, - providerOptions: { reasoningEffort: "high" }, - }) + test("maps package settings onto native executable models", () => { + for (const native of [TogetherAI, Cerebras]) { + const selected = native.model("provider-model", { + apiKey: "fixture", + baseURL: "https://gateway.example/v1", + headers: { "x-application": "opencode" }, + body: { service_tier: "priority" }, + providerOptions: { reasoningEffort: "high" }, + }) - expect(selected.route.endpoint.baseURL).toBe("https://gateway.example/v1") - expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" }) - expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" }) - expect(selected.route.defaults.providerOptions).toEqual({ reasoningEffort: "high" }) - } - }), - ) + expect(selected.route.endpoint.baseURL).toBe("https://gateway.example/v1") + expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" }) + expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" }) + expect(selected.route.defaults.providerOptions).toEqual({ reasoningEffort: "high" }) + } + }) it.effect("resolves provider environment credentials and preserves deprecated Together credentials", () => Effect.gen(function* () { diff --git a/packages/ai/test/provider/openai-compatible-chat.test.ts b/packages/ai/test/provider/openai-compatible-chat.test.ts index f9e380283d2..ab12d415d81 100644 --- a/packages/ai/test/provider/openai-compatible-chat.test.ts +++ b/packages/ai/test/provider/openai-compatible-chat.test.ts @@ -1,4 +1,4 @@ -import { describe, expect } from "bun:test" +import { describe, expect, test } from "bun:test" import { Effect, Schema } from "effect" import { HttpClientRequest } from "effect/unstable/http" import { LLM, LLMRequest, Message, ToolCallPart, ToolChoice, ToolDefinition } from "../../src/index.js" @@ -91,40 +91,38 @@ describe("OpenAI-compatible Chat route", () => { }), ) - it.effect("provides model helpers for compatible provider families", () => - Effect.gen(function* () { - expect( - providerFamilies.map(([provider, family]) => { - const model = family.configure({ apiKey: "test-key" }).model(`${provider}-model`) - return { - id: String(model.id), - provider: String(model.provider), - route: model.route.id, - baseURL: model.route.endpoint.baseURL, - } - }), - ).toEqual( - providerFamilies.map(([provider, _, baseURL]) => ({ - id: `${provider}-model`, - provider, - route: "openai-compatible-chat", - baseURL, - })), - ) + test("provides model helpers for compatible provider families", () => { + expect( + providerFamilies.map(([provider, family]) => { + const model = family.configure({ apiKey: "test-key" }).model(`${provider}-model`) + return { + id: String(model.id), + provider: String(model.provider), + route: model.route.id, + baseURL: model.route.endpoint.baseURL, + } + }), + ).toEqual( + providerFamilies.map(([provider, _, baseURL]) => ({ + id: `${provider}-model`, + provider, + route: "openai-compatible-chat", + baseURL, + })), + ) - const custom = OpenAICompatible.deepseek - .configure({ - apiKey: "test-key", - baseURL: "https://custom.deepseek.test/v1", - }) - .model("deepseek-chat") - expect(custom).toMatchObject({ - provider: "deepseek", - route: { id: "openai-compatible-chat" }, + const custom = OpenAICompatible.deepseek + .configure({ + apiKey: "test-key", + baseURL: "https://custom.deepseek.test/v1", }) - expect(custom.route.endpoint.baseURL).toBe("https://custom.deepseek.test/v1") - }), - ) + .model("deepseek-chat") + expect(custom).toMatchObject({ + provider: "deepseek", + route: { id: "openai-compatible-chat" }, + }) + expect(custom.route.endpoint.baseURL).toBe("https://custom.deepseek.test/v1") + }) it.effect("matches AI SDK compatible basic request body fixture", () => Effect.gen(function* () { diff --git a/packages/ai/test/schema.test.ts b/packages/ai/test/schema.test.ts index 26b0d2642bf..a366f407616 100644 --- a/packages/ai/test/schema.test.ts +++ b/packages/ai/test/schema.test.ts @@ -26,6 +26,7 @@ import { Usage, } from "../src/schema/index.js" import { ProviderShared } from "../src/protocols/shared.js" +import { it } from "./lib/effect.js" const model = new LanguageModel({ id: ModelID.make("fake-model"), @@ -101,49 +102,48 @@ describe("AI.Usage", () => { expect(ProviderShared.sumTokens()).toBeUndefined() }) - test("sseFraming maps decoder failures to AI errors", async () => { - const error = await Effect.runPromise( - ProviderShared.sseFraming(Stream.make(new TextEncoder().encode(`data: ${"x".repeat(10 * 1024 * 1024)}`))).pipe( - Stream.runCollect, - Effect.flip, - ), - ) + it.effect("sseFraming maps decoder failures to AI errors", () => + Effect.gen(function* () { + const error = yield* ProviderShared.sseFraming( + Stream.make(new TextEncoder().encode(`data: ${"x".repeat(10 * 1024 * 1024)}`)), + ).pipe(Stream.runCollect, Effect.flip) - expect(error).toBeInstanceOf(AIError) - expect(error.reason._tag).toBe("InvalidProviderOutput") - }) + expect(error).toBeInstanceOf(AIError) + expect(error.reason._tag).toBe("InvalidProviderOutput") + }), + ) - test("sseFraming ignores retry directives without ending the stream", async () => { - const encoder = new TextEncoder() - const frames = await Effect.runPromise( - ProviderShared.sseFraming( + it.effect("sseFraming ignores retry directives without ending the stream", () => + Effect.gen(function* () { + const encoder = new TextEncoder() + const frames = yield* ProviderShared.sseFraming( Stream.make( encoder.encode("retry: 1000\n\n"), encoder.encode('data: {"first":true}\n\n'), encoder.encode("retry: 2000\n\n"), encoder.encode('data: {"second":true}\n\n'), ).pipe(Stream.rechunk(1)), - ).pipe(Stream.runCollect), - ) + ).pipe(Stream.runCollect) - expect(Array.from(frames)).toEqual(['{"first":true}', '{"second":true}']) - }) + expect(Array.from(frames)).toEqual(['{"first":true}', '{"second":true}']) + }), + ) - test("sseFraming preserves event data around retry directives", async () => { - const encoder = new TextEncoder() - const frames = await Effect.runPromise( - ProviderShared.sseFraming( + it.effect("sseFraming preserves event data around retry directives", () => + Effect.gen(function* () { + const encoder = new TextEncoder() + const frames = yield* ProviderShared.sseFraming( Stream.make( encoder.encode("event: update\ndata: first\n"), encoder.encode("retry: 1000\n"), encoder.encode("data: second\n\n"), ).pipe(Stream.rechunk(1)), new Set(["update"]), - ).pipe(Stream.runCollect), - ) + ).pipe(Stream.runCollect) - expect(Array.from(frames)).toEqual(["first\nsecond"]) - }) + expect(Array.from(frames)).toEqual(["first\nsecond"]) + }), + ) test("visibleOutputTokens clamps reasoning > output to zero", () => { expect(new Usage({ outputTokens: 10, reasoningTokens: 4 }).visibleOutputTokens).toBe(6) @@ -153,18 +153,18 @@ describe("AI.Usage", () => { }) }) -test("AI errors expose the shared runtime tag", async () => { - const error = new AIError({ - reason: new InvalidRequestError({ message: "invalid" }), - }) - expect(error._tag).toBe("AI.Error") - expect(error.message).toBe("invalid") - expect(error.cause).toBe(error.reason) - expect(error.reason.cause).toBeUndefined() - expect( - await Effect.runPromise(Effect.fail(error).pipe(Effect.catchTag("AI.Error", () => Effect.succeed("caught")))), - ).toBe("caught") -}) +it.effect("AI errors expose the shared runtime tag", () => + Effect.gen(function* () { + const error = new AIError({ + reason: new InvalidRequestError({ message: "invalid" }), + }) + expect(error._tag).toBe("AI.Error") + expect(error.message).toBe("invalid") + expect(error.cause).toBe(error.reason) + expect(error.reason.cause).toBeUndefined() + expect(yield* Effect.fail(error).pipe(Effect.catchTag("AI.Error", () => Effect.succeed("caught")))).toBe("caught") + }), +) test("transport errors serialize execution facts", () => { const reason = new TransportError({ diff --git a/packages/ai/test/tool-runtime.test.ts b/packages/ai/test/tool-runtime.test.ts index 39fef6b0838..f45455b5d35 100644 --- a/packages/ai/test/tool-runtime.test.ts +++ b/packages/ai/test/tool-runtime.test.ts @@ -1,4 +1,4 @@ -import { describe, expect } from "bun:test" +import { describe, expect, test } from "bun:test" import { Content } from "@opencode-ai/schema/tool" import { Effect, Schema, Stream } from "effect" import { @@ -277,65 +277,61 @@ describe("LLMClient tools", () => { }), ) - it.effect("models canonical tool files with URIs", () => - Effect.sync(() => { - const decode = Schema.decodeUnknownSync(Content) + test("models canonical tool files with URIs", () => { + const decode = Schema.decodeUnknownSync(Content) - expect(decode({ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" })).toEqual({ - type: "file", - uri: "data:image/png;base64,AAAA", - mime: "image/png", - }) - expect(decode({ type: "file", uri: "https://example.test/image.png", mime: "image/png" })).toEqual({ - type: "file", - uri: "https://example.test/image.png", - mime: "image/png", - }) - expect(decode({ type: "file", uri: "file:///tmp/image.png", mime: "image/png" })).toEqual({ - type: "file", - uri: "file:///tmp/image.png", - mime: "image/png", - }) - }), - ) + expect(decode({ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" })).toEqual({ + type: "file", + uri: "data:image/png;base64,AAAA", + mime: "image/png", + }) + expect(decode({ type: "file", uri: "https://example.test/image.png", mime: "image/png" })).toEqual({ + type: "file", + uri: "https://example.test/image.png", + mime: "image/png", + }) + expect(decode({ type: "file", uri: "file:///tmp/image.png", mime: "image/png" })).toEqual({ + type: "file", + uri: "file:///tmp/image.png", + mime: "image/png", + }) + }) - it.effect("preserves canonical tool file URIs", () => - Effect.sync(() => { - expect( - ToolOutput.toResultValue( - ToolOutput.make({}, [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }]), - ), - ).toEqual({ - type: "content", - value: [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }], - }) - expect( - ToolOutput.toResultValue( - ToolOutput.make({}, [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }]), - ), - ).toEqual({ + test("preserves canonical tool file URIs", () => { + expect( + ToolOutput.toResultValue( + ToolOutput.make({}, [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }]), + ), + ).toEqual({ + type: "content", + value: [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }], + }) + expect( + ToolOutput.toResultValue( + ToolOutput.make({}, [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }]), + ), + ).toEqual({ + type: "content", + value: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }], + }) + expect( + ToolOutput.toResultValue( + ToolOutput.make({}, [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }]), + ), + ).toEqual({ + type: "content", + value: [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }], + }) + expect( + ToolOutput.fromResultValue({ type: "content", value: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }], - }) - expect( - ToolOutput.toResultValue( - ToolOutput.make({}, [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }]), - ), - ).toEqual({ - type: "content", - value: [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }], - }) - expect( - ToolOutput.fromResultValue({ - type: "content", - value: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }], - }), - ).toEqual({ - structured: {}, - content: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }], - }) - }), - ) + }), + ).toEqual({ + structured: {}, + content: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }], + }) + }) it.effect("settles projected URL files as canonical tool results", () => Effect.gen(function* () { @@ -364,24 +360,22 @@ describe("LLMClient tools", () => { }), ) - it.effect("derives typed output schemas and preserves dynamic output schemas", () => - Effect.sync(() => { - const [typed] = toDefinitions({ get_weather }) - const schema = { type: "object", properties: { result: { type: "string" } } } as const - const [dynamic] = toDefinitions({ - dynamic: Tool.make({ description: "Dynamic tool.", jsonSchema: { type: "object" }, outputSchema: schema }), - }) + test("derives typed output schemas and preserves dynamic output schemas", () => { + const [typed] = toDefinitions({ get_weather }) + const schema = { type: "object", properties: { result: { type: "string" } } } as const + const [dynamic] = toDefinitions({ + dynamic: Tool.make({ description: "Dynamic tool.", jsonSchema: { type: "object" }, outputSchema: schema }), + }) - expect(typed?.outputSchema).toMatchObject({ - type: "object", - properties: { condition: { type: "string" } }, - required: ["temperature", "condition"], - additionalProperties: false, - }) - expect(Reflect.get(Reflect.get(typed?.outputSchema ?? {}, "properties") as object, "temperature")).toBeDefined() - expect(dynamic?.outputSchema).toEqual(schema) - }), - ) + expect(typed?.outputSchema).toMatchObject({ + type: "object", + properties: { condition: { type: "string" } }, + required: ["temperature", "condition"], + additionalProperties: false, + }) + expect(Reflect.get(Reflect.get(typed?.outputSchema ?? {}, "properties") as object, "temperature")).toBeDefined() + expect(dynamic?.outputSchema).toEqual(schema) + }) it.effect("preserves content tool results from dynamic tools", () => Effect.gen(function* () { diff --git a/packages/ai/test/tool-stream.test.ts b/packages/ai/test/tool-stream.test.ts index 29400dee527..3786ab49537 100644 --- a/packages/ai/test/tool-stream.test.ts +++ b/packages/ai/test/tool-stream.test.ts @@ -1,4 +1,4 @@ -import { describe, expect } from "bun:test" +import { describe, expect, test } from "bun:test" import { Effect } from "effect" import { AIError } from "../src/schema/index.js" import { ToolStream } from "../src/protocols/utils/tool-stream.js" @@ -38,44 +38,40 @@ describe("ToolStream", () => { }), ) - it.effect("exposes cumulative partial string values", () => - Effect.gen(function* () { - const result = ToolStream.appendOrStart( - ADAPTER, - ToolStream.empty(), - 0, - { id: "call_1", name: "lookup", text: '{"query":"wea' }, - "missing tool", - ) - if (ToolStream.isError(result)) return yield* result + test("exposes cumulative partial string values", () => { + const result = ToolStream.appendOrStart( + ADAPTER, + ToolStream.empty(), + 0, + { id: "call_1", name: "lookup", text: '{"query":"wea' }, + "missing tool", + ) + if (ToolStream.isError(result)) throw result - expect(result.events.at(-1)).toEqual({ - type: "tool-input-delta", - id: "call_1", - name: "lookup", - text: '{"query":"wea', - input: { query: "wea" }, - }) - }), - ) + expect(result.events.at(-1)).toEqual({ + type: "tool-input-delta", + id: "call_1", + name: "lookup", + text: '{"query":"wea', + input: { query: "wea" }, + }) + }) - it.effect("defaults partial input to an empty object when the accumulated value cannot be parsed", () => - Effect.gen(function* () { - const result = ToolStream.appendOrStart( - ADAPTER, - ToolStream.empty(), - 0, - { id: "call_1", name: "lookup", text: "x" }, - "missing tool", - ) - if (ToolStream.isError(result)) return yield* result + test("defaults partial input to an empty object when the accumulated value cannot be parsed", () => { + const result = ToolStream.appendOrStart( + ADAPTER, + ToolStream.empty(), + 0, + { id: "call_1", name: "lookup", text: "x" }, + "missing tool", + ) + if (ToolStream.isError(result)) throw result - expect(result.events).toEqual([ - { type: "tool-input-start", id: "call_1", name: "lookup" }, - { type: "tool-input-delta", id: "call_1", name: "lookup", text: "x", input: {} }, - ]) - }), - ) + expect(result.events).toEqual([ + { type: "tool-input-start", id: "call_1", name: "lookup" }, + { type: "tool-input-delta", id: "call_1", name: "lookup", text: "x", input: {} }, + ]) + }) it.effect("keeps accumulated identity when later deltas contain empty strings", () => Effect.gen(function* () { @@ -104,14 +100,12 @@ describe("ToolStream", () => { }), ) - it.effect("fails appendExisting when the provider skipped the tool start", () => - Effect.gen(function* () { - const error = ToolStream.appendExisting(ADAPTER, ToolStream.empty(), 0, "{}", "missing tool") + test("fails appendExisting when the provider skipped the tool start", () => { + const error = ToolStream.appendExisting(ADAPTER, ToolStream.empty(), 0, "{}", "missing tool") - expect(error).toBeInstanceOf(AIError) - if (ToolStream.isError(error)) expect(error.message).toBe("missing tool") - }), - ) + expect(error).toBeInstanceOf(AIError) + if (ToolStream.isError(error)) expect(error.message).toBe("missing tool") + }) it.effect("uses final input override without losing accumulated deltas", () => Effect.gen(function* () {