import { type Generated, OpenAiClient, OpenAiLanguageModel, OpenAiSchema, OpenAiTool } from "@effect/ai-openai"
import { assert, describe, it } from "@effect/vitest"
import { assertTrue, deepStrictEqual, strictEqual } from "@effect/vitest/utils"
import { Array, Context, Effect, Layer, Redacted, Ref, Schema, SchemaGetter, Stream } from "effect"
import { AiError, LanguageModel, Prompt, Response as AiResponse, Tool, Toolkit } from "effect/ai"
import { HttpClient, type HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http"
const webSearchFailures = [
{ tool: OpenAiTool.WebSearch({}), status: "failed" },
{ tool: OpenAiTool.WebSearch({}), status: "incomplete" },
{ tool: OpenAiTool.WebSearchPreview({}), status: "searching" }
] as const
const fileSearchOutcomes = [
{ status: "completed", isFailure: false, results: undefined },
{ status: "failed", isFailure: true, results: null },
{ status: "incomplete", isFailure: true, results: [{ file_id: "file_123", text: "Matching text" }] }
] as const
describe("OpenAiLanguageModel", () => {
describe("make", () => {
it.effect("sends correct model in request", () =>
Effect.gen(function*() {
const result = yield* LanguageModel.generateText({ prompt: "test" }).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini"))
)
const metadata = result.content.find((part) => part.type === "response-metadata")
strictEqual(metadata?.modelId, "gpt-4o-mini")
}).pipe(Effect.provide(makeTestLayer())))
it.effect("sends custom model string in request", () =>
Effect.gen(function*() {
const result = yield* LanguageModel.generateText({ prompt: "test" }).pipe(
Effect.provide(OpenAiLanguageModel.model("ft:gpt-4o-mini:custom"))
)
const metadata = result.content.find((part) => part.type === "response-metadata")
strictEqual(metadata?.modelId, "ft:gpt-4o-mini:custom")
}).pipe(Effect.provide(makeTestLayer({ body: { model: "ft:gpt-4o-mini:custom" as any } }))))
})
describe("web search sources", () => {
it.effect.each(["generateText", "streamText"] as const)(
"preserves URL and API sources with %s",
(method) =>
Effect.gen(function*() {
const sources = [
{ type: "url", url: "https://example.com/weather" },
{ type: "api", name: "oai-weather" }
] as const
const action = { type: "search", query: "weather in London", sources } as const
const item = makeWebSearchCall({ action })
const event = { type: "response.output_item.done", sequence_number: 1, output_index: 0, item }
const body = method === "generateText"
? JSON.stringify(makeDefaultResponse({ output: [item] }))
: `data: ${JSON.stringify(event)}\n\n`
const client = makeRawResponseClient(
body,
method === "generateText" ? "application/json" : "text/event-stream"
)
const options = { prompt: "Weather in London", toolkit: Toolkit.make(OpenAiTool.WebSearch({})) }
const parts = yield* Effect.gen(function*() {
if (method === "generateText") {
const response = yield* LanguageModel.generateText(options)
return response.content
}
return yield* LanguageModel.streamText(options).pipe(Stream.runCollect)
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-5.6")),
Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
Effect.provideService(HttpClient.HttpClient, client)
)
const calls = parts.filter((part) => part.type === "tool-call")
deepStrictEqual(calls.map((part) => part.params), [{ action }])
const results = parts.filter((part) => part.type === "tool-result")
deepStrictEqual(results.map((part) => part.result), [{ action, status: "completed" }])
})
)
})
describe("web search find_in_page", () => {
it.effect.each(["generateText", "streamText"] as const)(
"preserves actions without a URL with %s",
(method) =>
Effect.gen(function*() {
const action = { type: "find_in_page", pattern: "og:image" } as const
const item = { type: "web_search_call", id: "ws_123", status: "completed", action }
const event = { type: "response.output_item.done", sequence_number: 1, output_index: 0, item }
const body = method === "generateText"
? JSON.stringify({ ...makeDefaultResponse(), output: [item] })
: `data: ${JSON.stringify(event)}\n\n`
const client = makeRawResponseClient(
body,
method === "generateText" ? "application/json" : "text/event-stream"
)
const options = { prompt: "Search the page", toolkit: Toolkit.make(OpenAiTool.WebSearch({})) }
const parts = yield* Effect.gen(function*() {
if (method === "generateText") return (yield* LanguageModel.generateText(options)).content
return yield* LanguageModel.streamText(options).pipe(Stream.runCollect)
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-5.4")),
Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
Effect.provideService(HttpClient.HttpClient, client)
)
deepStrictEqual(parts.filter((part) => part.type === "tool-call").map((part) => part.params), [{ action }])
deepStrictEqual<unknown>(
parts.filter((part) => part.type === "tool-result").map((part) => part.result),
[{ action, status: "completed" }]
)
})
)
})
describe("web search without an action", () => {
it.effect.each(
[
{ method: "streamText", status: "incomplete", isFailure: true },
{ method: "generateText", status: "incomplete", isFailure: true },
{ method: "generateText", status: "completed", isFailure: false }
] as const
)("preserves omitted actions for $status with $method", ({ method, status, isFailure }) =>
Effect.gen(function*() {
const item: Generated.WebSearchToolCall = { type: "web_search_call", id: "ws_123", status }
const event = { type: "response.output_item.done", sequence_number: 1, output_index: 0, item }
const body = method === "generateText"
? JSON.stringify(makeDefaultResponse({ output: [item] }))
: `data: ${JSON.stringify(event)}\n\n`
const client = makeRawResponseClient(body, method === "generateText" ? "application/json" : "text/event-stream")
const options = { prompt: "Search the web", toolkit: Toolkit.make(OpenAiTool.WebSearch({})) }
const parts = yield* Effect.gen(function*() {
if (method === "generateText") return (yield* LanguageModel.generateText(options)).content
return yield* LanguageModel.streamText(options).pipe(Stream.runCollect)
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-6-luna")),
Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
Effect.provideService(HttpClient.HttpClient, client)
)
deepStrictEqual(
parts.filter((part) => part.type === "tool-call" || part.type === "tool-result")
.map((part) => ({
type: part.type,
id: part.id,
providerExecuted: part.providerExecuted,
...(part.type === "tool-call"
? { params: part.params }
: { result: part.result, isFailure: part.isFailure })
})),
[
{ type: "tool-call", id: "ws_123", providerExecuted: true, params: {} },
{ type: "tool-result", id: "ws_123", providerExecuted: true, result: { status }, isFailure }
]
)
}))
it.effect("rejects null and malformed actions when present", () =>
Effect.forEach([null, { type: "find_in_page", url: "https://example.com", pattern: null }], (action) => {
const event = {
type: "response.output_item.done",
sequence_number: 1,
output_index: 0,
item: { type: "web_search_call", id: "ws_123", status: "completed", action }
}
const client = makeRawResponseClient(`data: ${JSON.stringify(event)}\n\n`, "text/event-stream")
return LanguageModel.streamText({ prompt: "Search", toolkit: Toolkit.make(OpenAiTool.WebSearch({})) }).pipe(
Stream.runCollect,
Effect.flip,
Effect.tap((error) => {
assert(AiError.isAiError(error))
strictEqual(error.reason._tag, "InvalidOutputError")
return Effect.void
}),
Effect.provide(OpenAiLanguageModel.model("gpt-6-luna")),
Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
Effect.provideService(HttpClient.HttpClient, client)
)
}))
})
describe("generateText", () => {
describe("message preparation", () => {
it.effect("forwards prompt cache, safety configuration and text breakpoints", () =>
Effect.gen(function*() {
const breakpoint = { mode: "explicit" } as const
yield* LanguageModel.generateText({
prompt: Prompt.make([
Prompt.systemMessage({
content: "Stable instructions",
options: { openai: { promptCacheBreakpoint: breakpoint } }
}),
Prompt.userMessage({
content: [Prompt.textPart({
text: "Stable context",
options: { openai: { promptCacheBreakpoint: breakpoint } }
})]
})
])
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-5.6", {
prompt_cache_key: "assistant:v1",
prompt_cache_options: { mode: "explicit", ttl: "30m", comparison_response_id: "resp_baseline" },
prompt_cache_retention: "24h",
safety_identifier: "user-hash-123"
}))
)
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
strictEqual(body.prompt_cache_key, "assistant:v1")
strictEqual(body.prompt_cache_retention, "24h")
strictEqual(body.safety_identifier, "user-hash-123")
deepStrictEqual(body.prompt_cache_options, {
mode: "explicit",
ttl: "30m",
comparison_response_id: "resp_baseline"
})
deepStrictEqual(body.input, [{
role: "developer",
content: [{
type: "input_text",
text: "Stable instructions",
prompt_cache_breakpoint: breakpoint
}]
}, {
role: "user",
content: [{
type: "input_text",
text: "Stable context",
prompt_cache_breakpoint: breakpoint
}]
}])
}).pipe(Effect.provide(makeTestLayer({ body: { model: "gpt-5.6" as any } }))))
it.effect("forwards image and file breakpoints", () =>
Effect.gen(function*() {
const breakpoint = { mode: "explicit" } as const
yield* LanguageModel.generateText({
prompt: Prompt.make([
Prompt.userMessage({
content: [
Prompt.filePart({
mediaType: "image/png",
data: new URL("https://example.com/image.png"),
options: { openai: { promptCacheBreakpoint: breakpoint } }
}),
Prompt.filePart({
mediaType: "application/pdf",
data: new URL("https://example.com/document.pdf"),
options: { openai: { promptCacheBreakpoint: breakpoint } }
})
]
})
])
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-5.6")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
deepStrictEqual(body.input, [{
role: "user",
content: [{
type: "input_image",
image_url: "https://example.com/image.png",
detail: "auto",
prompt_cache_breakpoint: breakpoint
}, {
type: "input_file",
file_url: "https://example.com/document.pdf",
prompt_cache_breakpoint: breakpoint
}]
}])
}).pipe(Effect.provide(makeTestLayer({ body: { model: "gpt-5.6" as any } }))))
it.effect("forwards implicit prompt cache mode without text breakpoints", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({ prompt: "Stable context" }).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-5.6", {
prompt_cache_options: { mode: "implicit" }
}))
)
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
deepStrictEqual(body.prompt_cache_options, { mode: "implicit" })
deepStrictEqual(body.input, [{
role: "user",
content: [{ type: "input_text", text: "Stable context" }]
}])
}).pipe(Effect.provide(makeTestLayer({ body: { model: "gpt-5.6" as any } }))))
describe("system messages", () => {
it.effect("uses system role for standard models", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "Hello" }
])
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const systemMessage = body.input.find((m: any) => m.role === "system")
assert.isDefined(systemMessage)
deepStrictEqual(systemMessage.content, [{
type: "input_text",
text: "You are a helpful assistant"
}])
}).pipe(Effect.provide(makeTestLayer())))
it.effect("uses developer role for reasoning models", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "Hello" }
])
}).pipe(Effect.provide(OpenAiLanguageModel.model("o1")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const devMessage = body.input.find((m: any) => m.role === "developer")
assert.isDefined(devMessage)
deepStrictEqual(devMessage.content, [{
type: "input_text",
text: "You are a helpful assistant"
}])
}).pipe(Effect.provide(makeTestLayer({ body: { model: "o1" } }))))
it.effect("uses developer role for gpt-5 models", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "Hello" }
])
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-5")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const devMessage = body.input.find((m: any) => m.role === "developer")
assert.isDefined(devMessage)
}).pipe(Effect.provide(makeTestLayer({ body: { model: "gpt-5" } }))))
it.effect("uses developer role for o3 models", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "Hello" }
])
}).pipe(Effect.provide(OpenAiLanguageModel.model("o3-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const devMessage = body.input.find((m: any) => m.role === "developer")
assert.isDefined(devMessage)
}).pipe(Effect.provide(makeTestLayer({ body: { model: "o3-mini" } }))))
})
describe("user messages", () => {
it.effect("converts text parts to input_text", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: "Hello world"
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const userMessage = body.input.find((m: any) => m.role === "user")
assert.isDefined(userMessage)
deepStrictEqual(userMessage.content, [{ type: "input_text", text: "Hello world" }])
}).pipe(Effect.provide(makeTestLayer())))
it.effect("handles image URLs", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([{
role: "user",
content: [
Prompt.filePart({
mediaType: "image/png",
data: new URL("https://example.com/image.png")
})
]
}])
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const userMessage = body.input.find((m: any) => m.role === "user")
deepStrictEqual(userMessage.content, [{
type: "input_image",
image_url: "https://example.com/image.png",
detail: "auto"
}])
}).pipe(Effect.provide(makeTestLayer())))
it.effect("handles image strings", () =>
Effect.gen(function*() {
const base64 = "iVBORw0KGgo="
const dataUrl = `data:image/png;base64,${base64}`
const upperCaseDataUrl = `DATA:image/png;base64,${base64}`
const url = "https://example.com/image.png"
yield* LanguageModel.generateText({
prompt: Prompt.make([Prompt.userMessage({
content: [base64, dataUrl, upperCaseDataUrl, url].map((data) =>
Prompt.filePart({ mediaType: "image/png", data })
)
})])
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
assert.deepStrictEqual(body.input, [{
role: "user",
content: [
{ type: "input_image", image_url: `data:image/png;base64,${base64}`, detail: "auto" },
{ type: "input_image", image_url: dataUrl, detail: "auto" },
{ type: "input_image", image_url: upperCaseDataUrl, detail: "auto" },
{ type: "input_image", image_url: url, detail: "auto" }
]
}])
}).pipe(Effect.provide(makeTestLayer())))
it.effect("handles image with custom detail level", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([{
role: "user",
content: [
Prompt.filePart({
mediaType: "image/png",
data: new URL("https://example.com/image.png"),
options: { openai: { imageDetail: "high" } }
})
]
}])
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const userMessage = body.input.find((m: any) => m.role === "user")
strictEqual(userMessage.content[0].detail, "high")
}).pipe(Effect.provide(makeTestLayer())))
it.effect("handles image file IDs with configured prefixes", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([{
role: "user",
content: [
Prompt.filePart({
mediaType: "image/png",
data: "file-abc123"
})
]
}])
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", {
fileIdPrefixes: ["file-"]
}))
)
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const userMessage = body.input.find((m: any) => m.role === "user")
deepStrictEqual(userMessage.content, [{
type: "input_image",
file_id: "file-abc123",
detail: "auto"
}])
}).pipe(Effect.provide(makeTestLayer())))
it.effect("handles image base64 data", () =>
Effect.gen(function*() {
const imageData = new Uint8Array([137, 80, 78, 71]) // PNG magic bytes
yield* LanguageModel.generateText({
prompt: Prompt.make([{
role: "user",
content: [
Prompt.filePart({
mediaType: "image/png",
data: imageData
})
]
}])
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const userMessage = body.input.find((m: any) => m.role === "user")
assert.isTrue(userMessage.content[0].image_url.startsWith("data:image/png;base64,"))
}).pipe(Effect.provide(makeTestLayer())))
it.effect("handles PDF URLs", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([{
role: "user",
content: [
Prompt.filePart({
mediaType: "application/pdf",
data: new URL("https://example.com/document.pdf")
})
]
}])
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const userMessage = body.input.find((m: any) => m.role === "user")
deepStrictEqual(userMessage.content, [{
type: "input_file",
file_url: "https://example.com/document.pdf"
}])
}).pipe(Effect.provide(makeTestLayer())))
it.effect("handles PDF base64 data with filename", () =>
Effect.gen(function*() {
const pdfData = new Uint8Array([0x25, 0x50, 0x44, 0x46]) // %PDF
yield* LanguageModel.generateText({
prompt: Prompt.make([{
role: "user",
content: [
Prompt.filePart({
mediaType: "application/pdf",
data: pdfData,
fileName: "document.pdf"
})
]
}])
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const userMessage = body.input.find((m: any) => m.role === "user")
strictEqual(userMessage.content[0].type, "input_file")
strictEqual(userMessage.content[0].filename, "document.pdf")
assert.isTrue(userMessage.content[0].file_data.startsWith("data:application/pdf;base64,"))
}).pipe(Effect.provide(makeTestLayer())))
const pdfStringCases = [
{
label: "base64",
data: "JVBERi0xLjcK",
content: {
type: "input_file",
filename: "part-0.pdf",
file_data: "data:application/pdf;base64,JVBERi0xLjcK"
}
},
{
label: "data URL",
data: "data:application/pdf;base64,JVBERi0xLjcK",
content: {
type: "input_file",
filename: "part-0.pdf",
file_data: "data:application/pdf;base64,JVBERi0xLjcK"
}
},
{
label: "HTTPS URL",
data: "https://example.com/document.pdf",
content: { type: "input_file", file_url: "https://example.com/document.pdf" }
}
]
for (const { content, data, label } of pdfStringCases) {
it.effect(`handles PDF ${label} strings`, () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([{
role: "user",
content: [Prompt.filePart({ mediaType: "application/pdf", data })]
}])
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const userMessage = body.input.find((m: any) => m.role === "user")
deepStrictEqual(userMessage.content, [content])
}).pipe(Effect.provide(makeTestLayer())))
}
})
describe("assistant messages", () => {
it.effect("converts text parts to message output", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Hello" },
{
role: "assistant",
content: [Prompt.textPart({ text: "Hi there!" })]
},
{ role: "user", content: "How are you?" }
])
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const assistantMessage = body.input.find((m: any) => m.type === "message" && m.role === "assistant")
assert.isDefined(assistantMessage)
strictEqual(assistantMessage.content[0].type, "output_text")
strictEqual(assistantMessage.content[0].text, "Hi there!")
}).pipe(Effect.provide(makeTestLayer())))
it.effect("converts reasoning parts", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Think step by step" },
{
role: "assistant",
content: [
Prompt.reasoningPart({
text: "Let me think...",
options: { openai: { itemId: "reasoning_123" } }
})
]
},
{ role: "user", content: "Continue" }
])
}).pipe(Effect.provide(OpenAiLanguageModel.model("o1")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const reasoningItem = body.input.find((m: any) => m.type === "reasoning")
assert.isDefined(reasoningItem)
strictEqual(reasoningItem.id, "reasoning_123")
}).pipe(Effect.provide(makeTestLayer({ body: { model: "o1" } }))))
it.effect("replays encrypted reasoning from response parts", () =>
Effect.gen(function*() {
const history = Prompt.fromResponseParts([
AiResponse.makePart("reasoning-start", {
id: "reasoning_123:0",
metadata: { openai: { itemId: "reasoning_123" } }
}),
AiResponse.makePart("reasoning-delta", {
id: "reasoning_123:0",
delta: "Let me think..."
}),
AiResponse.makePart("reasoning-end", {
id: "reasoning_123:0",
metadata: {
openai: {
itemId: "reasoning_123",
encryptedContent: "encrypted-reasoning"
}
}
})
])
yield* LanguageModel.generateText({
prompt: Prompt.concat(history, Prompt.make("Continue"))
}).pipe(Effect.provide(OpenAiLanguageModel.model("o1")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const reasoningItem = body.input.find((item: any) => item.type === "reasoning")
assert.isDefined(reasoningItem)
deepStrictEqual(reasoningItem, {
type: "reasoning",
id: "reasoning_123",
summary: [{ type: "summary_text", text: "Let me think..." }],
encrypted_content: "encrypted-reasoning"
})
}).pipe(Effect.provide(makeTestLayer({ body: { model: "o1" } }))))
it.effect("replays encrypted reasoning statelessly for an unknown model", () =>
Effect.gen(function*() {
const history = Prompt.fromResponseParts([
AiResponse.makePart("reasoning-start", {
id: "reasoning_123:0",
metadata: { openai: { itemId: "reasoning_123" } }
}),
AiResponse.makePart("reasoning-delta", {
id: "reasoning_123:0",
delta: "Let me think..."
}),
AiResponse.makePart("reasoning-end", {
id: "reasoning_123:0",
metadata: {
openai: {
itemId: "reasoning_123",
encryptedContent: "encrypted-reasoning"
}
}
})
])
yield* LanguageModel.generateText({
prompt: Prompt.concat(history, Prompt.make("Continue"))
}).pipe(Effect.provide(OpenAiLanguageModel.model("custom-model", { store: false })))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const reasoningItem = body.input.find((item: any) => item.type === "reasoning")
assert.isDefined(reasoningItem)
deepStrictEqual(reasoningItem, {
type: "reasoning",
id: "reasoning_123",
summary: [{ type: "summary_text", text: "Let me think..." }],
encrypted_content: "encrypted-reasoning"
})
}).pipe(Effect.provide(makeTestLayer({ body: { model: "custom-model" } }))))
it.effect("serializes stored assistant history according to item reference config", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: storedHistoryPrompt,
toolkit: TestToolkit,
disableToolCallResolution: true
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", { store: true })))
yield* LanguageModel.generateText({
prompt: storedHistoryPrompt,
toolkit: TestToolkit,
disableToolCallResolution: true
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", {
store: true,
useItemReferences: false
})))
const requests = yield* MockHttpClient.requests
const referencedBody = yield* getRequestBody(requests[0])
const inlineBody = yield* getRequestBody(requests[1])
assert.deepStrictEqual(referencedBody.input, [
{ role: "user", content: [{ type: "input_text", text: "Question" }] },
{ type: "item_reference", id: "msg_1" },
{ type: "item_reference", id: "rs_1" },
{ type: "item_reference", id: "fc_1" },
{ type: "function_call_output", call_id: "call_1", output: "{\"output\":\"result\"}" },
{ role: "user", content: [{ type: "input_text", text: "Continue" }] }
])
assert.deepStrictEqual(inlineBody.input, [
{ role: "user", content: [{ type: "input_text", text: "Question" }] },
{
id: "msg_1",
type: "message",
role: "assistant",
status: "completed",
content: [{
type: "output_text",
text: "Answer",
annotations: [],
logprobs: []
}]
},
{
type: "reasoning",
id: "rs_1",
summary: [{ type: "summary_text", text: "Thinking" }],
encrypted_content: "encrypted-reasoning"
},
{
type: "function_call",
name: "TestTool",
call_id: "call_1",
arguments: "{\"input\":\"value\"}",
id: "fc_1"
},
{ type: "function_call_output", call_id: "call_1", output: "{\"output\":\"result\"}" },
{ role: "user", content: [{ type: "input_text", text: "Continue" }] }
])
strictEqual(inlineBody.useItemReferences, undefined)
}).pipe(Effect.provide(makeTestLayer())))
it.effect("replays matched provider-executed history inline", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: providerExecutedHistoryPrompt,
toolkit: Toolkit.make(OpenAiTool.WebSearch({})),
disableToolCallResolution: true
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", {
store: true,
useItemReferences: false
})))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
assert.deepStrictEqual(body.input, [
{ role: "user", content: [{ type: "input_text", text: "Search" }] },
{
type: "web_search_call",
id: "ws_1",
status: "completed",
action: { type: "search", query: "Effect TypeScript" }
},
{ role: "user", content: [{ type: "input_text", text: "Continue" }] }
])
}).pipe(Effect.provide(makeTestLayer())))
it.effect("replays web search history with an omitted action", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Search" },
{
role: "assistant",
content: [
Prompt.toolCallPart({ id: "ws_1", name: "OpenAiWebSearch", params: {}, providerExecuted: true }),
Prompt.toolResultPart({
id: "ws_1",
name: "OpenAiWebSearch",
providerExecuted: true,
isFailure: true,
result: { status: "incomplete" }
})
]
},
{ role: "user", content: "Continue" }
]),
toolkit: Toolkit.make(OpenAiTool.WebSearch({})),
disableToolCallResolution: true
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-6-luna", {
store: true,
useItemReferences: false
})))
const body = yield* getRequestBody((yield* MockHttpClient.requests)[0])
deepStrictEqual(body.input?.[1], { type: "web_search_call", id: "ws_1", status: "incomplete" })
}).pipe(Effect.provide(makeTestLayer())))
it.effect("fails locally when provider-executed history cannot be replayed inline", () =>
Effect.gen(function*() {
const cases = [
providerExecutedCall,
providerExecutedResult
] as const
yield* Effect.forEach(cases, (part) =>
LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Search" },
{
role: "assistant",
content: [part]
},
{ role: "user", content: "Continue" }
]),
toolkit: Toolkit.make(OpenAiTool.WebSearch({})),
disableToolCallResolution: true
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", {
store: true,
useItemReferences: false
})),
Effect.flip,
Effect.tap((error) =>
Effect.sync(() => {
strictEqual(error.reason._tag, "InvalidRequestError")
if (error.reason._tag === "InvalidRequestError") {
assert.include(error.reason.description, "OpenAiWebSearch")
assert.include(error.reason.description, "ws_1")
}
})
)
))
strictEqual((yield* MockHttpClient.requests).length, 0)
}).pipe(Effect.provide(makeTestLayer())))
it.effect("converts tool call parts to function_call", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Use the tool" },
{
role: "assistant",
content: [
Prompt.toolCallPart({
id: "call_abc",
name: "TestTool",
params: { input: "test" },
providerExecuted: false
})
]
},
{
role: "tool",
content: [
Prompt.toolResultPart({
id: "call_abc",
name: "TestTool",
isFailure: false,
result: { output: "result" },
providerExecuted: false
})
]
}
]),
toolkit: TestToolkit
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const functionCall = body.input.find((m: any) => m.type === "function_call")
assert.isDefined(functionCall)
strictEqual(functionCall.name, "TestTool")
strictEqual(functionCall.call_id, "call_abc")
}).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))
})
describe("tool messages", () => {
it.effect("converts tool results to function_call_output", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Use the tool" },
{
role: "assistant",
content: [
Prompt.toolCallPart({
id: "call_abc",
name: "TestTool",
params: { input: "test" },
providerExecuted: false
})
]
},
{
role: "tool",
content: [
Prompt.toolResultPart({
id: "call_abc",
name: "TestTool",
isFailure: false,
result: { output: "result" },
providerExecuted: false
})
]
}
]),
toolkit: TestToolkit
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const toolOutput = body.input.find((m: any) => m.type === "function_call_output")
assert.isDefined(toolOutput)
strictEqual(toolOutput.call_id, "call_abc")
strictEqual(toolOutput.output, JSON.stringify({ output: "result" }))
}).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))
it.effect("preserves string tool results", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Use the tool" },
{
role: "assistant",
content: [
Prompt.toolCallPart({
id: "call_text",
name: "TestTool",
params: { input: "test" },
providerExecuted: false
})
]
},
{
role: "tool",
content: [
Prompt.toolResultPart({
id: "call_text",
name: "TestTool",
isFailure: false,
result: "PLAIN_TEXT_SENTINEL\n",
providerExecuted: false
})
]
}
]),
toolkit: TestToolkit
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const toolOutput = body.input.find((item: any) => item.type === "function_call_output")
assert.isDefined(toolOutput)
strictEqual(toolOutput.output, "PLAIN_TEXT_SENTINEL\n")
}).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))
const png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR4nGP4DwQACfsD/fteaysAAAAASUVORK5CYII="
const modelOutputCases = [
{
label: "as native input items",
modelOutput: [
Prompt.textPart({ text: "Screenshot" }),
Prompt.filePart({ mediaType: "image/png", data: png })
],
output: [
{ type: "input_text", text: "Screenshot" },
{ type: "input_image", image_url: `data:image/png;base64,${png}` }
]
},
{ label: "without the result when it is empty", modelOutput: [], output: "" }
]
for (const { label, modelOutput, output } of modelOutputCases) {
it.effect(`sends tool result model output ${label}`, () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Use the tool" },
{
role: "assistant",
content: [
Prompt.toolCallPart({
id: "call_image",
name: "TestTool",
params: { input: "test" },
providerExecuted: false
})
]
},
{
role: "tool",
content: [
Prompt.toolResultPart({
id: "call_image",
name: "TestTool",
isFailure: false,
result: { output: png },
modelOutput,
providerExecuted: false
})
]
}
]),
toolkit: TestToolkit
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const toolOutput = body.input.find((item: any) => item.type === "function_call_output")
strictEqual(toolOutput.call_id, "call_image")
deepStrictEqual(
Array.isArray(toolOutput.output)
? toolOutput.output.map(({ detail: _, ...item }: any) => item)
: toolOutput.output,
output
)
}).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))
}
it.effect("emits only the specialized output for apply_patch results", () =>
Effect.gen(function*() {
const toolkit = Toolkit.make(OpenAiTool.ApplyPatch({}))
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Apply a patch" },
{
role: "assistant",
content: [Prompt.toolCallPart({
id: "call_apply_patch",
name: "OpenAiApplyPatch",
params: {
call_id: "call_apply_patch",
operation: { type: "delete_file", path: "old.ts" }
},
providerExecuted: false
})]
},
{
role: "tool",
content: [Prompt.toolResultPart({
id: "call_apply_patch",
name: "OpenAiApplyPatch",
isFailure: false,
result: { status: "completed", output: "deleted" },
providerExecuted: false
})]
}
]),
toolkit,
disableToolCallResolution: true
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const outputs = body.input.filter((item: any) =>
item.call_id === "call_apply_patch" && item.type.endsWith("_output")
)
deepStrictEqual(outputs.map((item: any) => item.type), ["apply_patch_call_output"])
}).pipe(Effect.provide(makeTestLayer())))
it.effect("emits only the specialized output for shell results", () =>
Effect.gen(function*() {
const toolkit = Toolkit.make(OpenAiTool.Shell({}))
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Run a shell command" },
{
role: "assistant",
content: [Prompt.toolCallPart({
id: "call_shell",
name: "OpenAiShell",
params: {
action: {
commands: ["echo hello"],
timeout_ms: null,
max_output_length: null
}
},
providerExecuted: false
})]
},
{
role: "tool",
content: [Prompt.toolResultPart({
id: "call_shell",
name: "OpenAiShell",
isFailure: false,
result: {
output: [{
stdout: "hello\n",
stderr: "",
outcome: { type: "exit", exit_code: 0 }
}]
},
providerExecuted: false
})]
}
]),
toolkit,
disableToolCallResolution: true
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const outputs = body.input.filter((item: any) =>
item.call_id === "call_shell" && item.type.endsWith("_output")
)
deepStrictEqual(outputs.map((item: any) => item.type), ["shell_call_output"])
}).pipe(Effect.provide(makeTestLayer())))
it.effect("emits only the specialized output for local_shell results", () =>
Effect.gen(function*() {
const toolkit = Toolkit.make(OpenAiTool.LocalShell({}))
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Run a local shell command" },
{
role: "assistant",
content: [Prompt.toolCallPart({
id: "call_local_shell",
name: "OpenAiLocalShell",
params: {
action: {
type: "exec",
command: ["echo", "hello"],
env: {}
}
},
providerExecuted: false
})]
},
{
role: "tool",
content: [Prompt.toolResultPart({
id: "call_local_shell",
name: "OpenAiLocalShell",
isFailure: false,
result: { output: "hello\n" },
providerExecuted: false
})]
}
]),
toolkit,
disableToolCallResolution: true
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const outputs = body.input.filter((item: any) =>
item.call_id === "call_local_shell" && item.type.endsWith("_output")
)
deepStrictEqual(outputs.map((item: any) => item.type), ["local_shell_call_output"])
}).pipe(Effect.provide(makeTestLayer())))
})
})
describe("tool preparation", () => {
it.effect("converts user-defined tools to function type", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: "Use the tool",
toolkit: TestToolkit
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const tool = body.tools?.find((t: any) => t.type === "function")
assert.isDefined(tool)
strictEqual(tool.name, "TestTool")
strictEqual(tool.description, "A test tool")
strictEqual(tool.strict, true)
}).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))
it.effect("empty object on properties for empty parameters", () =>
Effect.gen(function*() {
const EmptyTool = Tool.make("EmptyParamsTool", {
description: "Empty params tool",
parameters: Tool.EmptyParams,
success: Schema.String
})
const toolkit = Toolkit.make(EmptyTool)
const toolkitLayer = toolkit.toLayer({
EmptyParamsTool: () => Effect.succeed("ok")
})
yield* LanguageModel.generateText({
prompt: "Use the tool",
toolkit
}).pipe(Effect.provide([OpenAiLanguageModel.model("gpt-4o-mini"), toolkitLayer]))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const tool = body.tools?.find((t: any) => t.type === "function" && t.name === "EmptyParamsTool")
assert.isDefined(tool)
deepStrictEqual(tool.parameters, {
type: "object",
properties: {},
additionalProperties: false
})
}).pipe(Effect.provide(makeTestLayer())))
it.effect("converts dynamic tools to function type", () =>
Effect.gen(function*() {
const inputSchema = {
type: "object",
properties: {
query: { type: "string" },
limit: { type: "number" }
},
required: ["query"],
additionalProperties: false
} as const
const DynamicTool = Tool.dynamic("DynamicTool", {
description: "A dynamic tool",
parameters: inputSchema
})
yield* LanguageModel.generateText({
prompt: "Use the dynamic tool",
toolkit: Toolkit.make(DynamicTool),
disableToolCallResolution: true
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const tool = body.tools?.find((entry: any) => entry.type === "function" && entry.name === "DynamicTool")
assert.isDefined(tool)
strictEqual(tool.description, "A dynamic tool")
deepStrictEqual(tool.parameters, inputSchema)
}).pipe(Effect.provide(makeTestLayer())))
it.effect("names the tool when its parameters are not an object schema", () =>
Effect.gen(function*() {
const error = yield* LanguageModel.generateText({
prompt: "Use the tool",
toolkit: Toolkit.make(Tool.make("NoParams", { parameters: Schema.Struct({}) })),
disableToolCallResolution: true
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")), Effect.flip)
strictEqual(error.reason._tag, "UnsupportedSchemaError")
assert.include(error.message, `"NoParams"`)
assert.include(error.message, "Tool.EmptyParams")
}).pipe(Effect.provide(makeTestLayer())))
it.effect("empty object on properties for empty parameters", () =>
Effect.gen(function*() {
const EmptyTool = Tool.make("EmptyParamsTool", {
description: "Empty params tool",
parameters: Tool.EmptyParams,
success: Schema.String
})
const toolkit = Toolkit.make(EmptyTool)
const toolkitLayer = toolkit.toLayer({
EmptyParamsTool: () => Effect.succeed("ok")
})
yield* LanguageModel.generateText({
prompt: "Use the tool",
toolkit
}).pipe(Effect.provide([OpenAiLanguageModel.model("gpt-4o-mini"), toolkitLayer]))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const tool = body.tools?.find((t: any) => t.type === "function" && t.name === "EmptyParamsTool")
assert.isDefined(tool)
deepStrictEqual(tool.parameters, {
type: "object",
properties: {},
additionalProperties: false
})
}).pipe(Effect.provide(makeTestLayer())))
it.effect("handles tool choice auto", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: "Use the tool",
toolkit: TestToolkit,
toolChoice: "auto"
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
strictEqual(body.tool_choice, "auto")
}).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))
it.effect("handles tool choice none", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: "Use the tool",
toolkit: TestToolkit,
toolChoice: "none"
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
strictEqual(body.tool_choice, "none")
}).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))
it.effect("handles tool choice required", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: "Use the tool",
toolkit: TestToolkit,
toolChoice: "required"
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
strictEqual(body.tool_choice, "required")
}).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))
it.effect("handles specific tool choice", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: "Use the tool",
toolkit: TestToolkit,
toolChoice: { tool: "TestTool" }
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
deepStrictEqual(body.tool_choice, { type: "function", name: "TestTool" })
}).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))
it.effect("adds code_interpreter tool", () =>
Effect.gen(function*() {
const toolkit = Toolkit.make(OpenAiTool.CodeInterpreter({ container: { type: "auto" } }))
yield* LanguageModel.generateText({
prompt: "Run some code",
toolkit
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const tool = body.tools?.find((t: any) => t.type === "code_interpreter")
assert.isDefined(tool)
}).pipe(Effect.provide(makeTestLayer())))
it.effect("adds web_search tool", () =>
Effect.gen(function*() {
const toolkit = Toolkit.make(OpenAiTool.WebSearch({}))
yield* LanguageModel.generateText({
prompt: "Search the web",
toolkit
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const tool = body.tools?.find((t: any) => t.type === "web_search")
assert.isDefined(tool)
}).pipe(Effect.provide(makeTestLayer())))
it.effect("adds file_search tool with vector store IDs", () =>
Effect.gen(function*() {
const toolkit = Toolkit.make(OpenAiTool.FileSearch({
vector_store_ids: ["vs_123"]
}))
yield* LanguageModel.generateText({
prompt: "Search files",
toolkit
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
const tool = body.tools?.find((t: any) => t.type === "file_search")
assert.isDefined(tool)
deepStrictEqual(tool.vector_store_ids, ["vs_123"])
}).pipe(Effect.provide(makeTestLayer())))
})
describe("response format", () => {
it.effect("uses text format by default", () =>
Effect.gen(function*() {
yield* LanguageModel.generateText({
prompt: "Hello"
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
strictEqual(body.text?.format?.type, "text")
}).pipe(Effect.provide(makeTestLayer())))
it.effect("uses json_schema format for structured output", () =>
Effect.gen(function*() {
yield* LanguageModel.generateObject({
prompt: "Give me a person",
schema: Schema.Struct({
name: Schema.String,
age: Schema.Number
})
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const requests = yield* MockHttpClient.requests
const body = yield* getRequestBody(requests[0])
strictEqual(body.text?.format?.type, "json_schema")
strictEqual(body.text?.format?.strict, true)
}).pipe(Effect.provide(makeTestLayer({
body: {
output: [makeTextOutput(JSON.stringify({ name: "John", age: 30 }))]
}
}))))
})
describe("response handling", () => {
it.effect("preserves ultrafast service tier alongside prompt cache diagnostics", () =>
Effect.gen(function*() {
const diagnostics = {
type: "cache_miss",
reason: "tools_changed",
cache_missed_tokens: 1024,
comparison_reusable_tokens: 2048
} as const
const body = JSON.stringify({
...makeDefaultResponse({ service_tier: "ultrafast" }),
prompt_cache_diagnostics: diagnostics
})
const result = yield* LanguageModel.generateText({ prompt: "test" }).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
Effect.provideService(HttpClient.HttpClient, makeRawResponseClient(body, "application/json"))
)
const finish = result.content.find((part) => part.type === "finish")
assert.isDefined(finish)
deepStrictEqual(finish.metadata.openai, {
serviceTier: "ultrafast",
promptCacheDiagnostics: diagnostics
})
}))
it.effect("extracts text from output_text", () =>
Effect.gen(function*() {
const result = yield* LanguageModel.generateText({
prompt: "Hello"
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
strictEqual(result.text, "Hello, world!")
}).pipe(Effect.provide(makeTestLayer({
body: { output: [makeTextOutput("Hello, world!")] }
}))))
it.effect("extracts multiple text parts", () =>
Effect.gen(function*() {
const result = yield* LanguageModel.generateText({
prompt: "Hello"
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const textParts = result.content.filter((p) => p.type === "text")
strictEqual(textParts.length, 2)
}).pipe(Effect.provide(makeTestLayer({
body: {
output: [
makeTextOutput("First"),
makeTextOutput("Second", { id: "msg_456" })
]
}
}))))
it.effect("handles refusal content", () =>
Effect.gen(function*() {
const result = yield* LanguageModel.generateText({
prompt: "Do something bad"
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const textPart = result.content.find((p) => p.type === "text")
strictEqual(textPart?.text, "")
strictEqual(textPart?.metadata?.openai?.refusal, "I cannot do that")
}).pipe(Effect.provide(makeTestLayer({
body: {
output: [{
type: "message",
id: "msg_123",
role: "assistant",
status: "completed",
content: [{ type: "refusal", refusal: "I cannot do that" }]
}]
}
}))))
it.effect("parses function call arguments", () =>
Effect.gen(function*() {
const result = yield* LanguageModel.generateText({
prompt: "Use the tool",
toolkit: TestToolkit
}).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))
const toolCall = result.content.find((p) => p.type === "tool-call")
assert.isDefined(toolCall)
if (toolCall?.type === "tool-call") {
strictEqual(toolCall.name, "TestTool")
deepStrictEqual(toolCall.params, { input: "hello" })
}
}).pipe(
Effect.provide([
makeTestLayer({
body: { output: [makeFunctionCall("TestTool", { input: "hello" })] }
}),