import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai-compat"
import { assert, describe, it } from "@effect/vitest"
import { Effect, Layer, Redacted, Ref, Schema, Stream } from "effect"
import { type AiError, LanguageModel, Prompt, Tool, Toolkit } from "effect/ai"
import { HttpClient, type HttpClientError, type HttpClientRequest, HttpClientResponse } from "effect/http"
describe("OpenAiLanguageModel", () => {
for (const mode of ["complete", "stream"] as const) {
it.effect(`prepares selected tool codecs once per ${mode} request and normalizes repeated calls`, () =>
Effect.gen(function*() {
let conversions = 0
const Env = Schema.Record(Schema.String, Schema.String).check(
Schema.makeFilter<object>(() => true, {
representation: { id: "test/compat/toolCodec", payload: null },
toJsonSchema: () => {
conversions++
return { minItems: 1 }
}
})
)
const ReadEnv = Tool.make("ReadEnv", { parameters: Schema.Struct({ env: Env }) })
const Unselected = Tool.make("Unselected", {
parameters: Schema.Struct({ opaque: Schema.declare((input): input is string => typeof input === "string") })
})
const toolkit = Toolkit.make(ReadEnv, Unselected)
const toolkitLayer = toolkit.toLayer({
ReadEnv: () => Effect.void,
Unselected: () => Effect.void
})
const calls = ["call_1", "call_2"].map((id) => ({
id,
type: "function" as const,
function: { name: "ReadEnv", arguments: JSON.stringify({ env: [{ 0: "PATH", 1: "/usr/bin" }] }) }
}))
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) =>
Effect.gen(function*() {
const body = yield* getRequestBody(request)
assert.deepStrictEqual(body.tools.map((tool: any) => tool.function.name), ["ReadEnv"])
assert.strictEqual(body.tools[0].function.parameters.properties.env.type, "array")
return mode === "complete"
? jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "tool_calls",
message: { role: "assistant", content: null, tool_calls: calls }
}]
})
)
: sseResponse(request, [{
id: "chatcmpl_env",
object: "chat.completion.chunk",
model: "gpt-4o-mini",
created: 1,
choices: [{
index: 0,
delta: { tool_calls: calls.map((call, index) => ({ ...call, index })) },
finish_reason: "tool_calls"
}]
}, "[DONE]"])
})
)
))
)
for (let request = 1; request <= 2; request++) {
const options = {
prompt: "read the environment",
toolkit,
toolChoice: { oneOf: ["ReadEnv"] as Array<"ReadEnv"> },
disableToolCallResolution: true
}
const calls = yield* (mode === "complete"
? LanguageModel.generateText(options).pipe(
Effect.map((result) => result.toolCalls.map((part) => ({ id: part.id, params: part.params })))
)
: LanguageModel.streamText(options).pipe(
Stream.runCollect,
Effect.map((parts) =>
parts.filter((part) => part.type === "tool-call").map((part) => ({ id: part.id, params: part.params }))
)
)).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(toolkitLayer),
Effect.provide(layer)
)
assert.deepStrictEqual(
calls,
[
{ id: "call_1", params: { env: { PATH: "/usr/bin" } } },
{ id: "call_2", params: { env: { PATH: "/usr/bin" } } }
]
)
assert.strictEqual(conversions, request)
}
}))
}
describe("generateText", () => {
it.effect("serializes text-only user messages and decodes text output", () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "stop",
message: {
role: "assistant",
content: "Hello, compat!"
}
}]
})
))
})
))
)
const result = yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: [Prompt.textPart({ text: "hello" })] },
{ role: "user", content: [Prompt.textPart({ text: "" })] },
{ role: "user", content: [Prompt.textPart({ text: " Hello, 世界!\nGoodbye. " })] },
{ role: "user", content: [Prompt.textPart({ text: "first" }), Prompt.textPart({ text: "second" })] },
{ role: "user", content: [] }
])
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
assert.strictEqual(result.text, "Hello, compat!")
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
assert.strictEqual(requestBody.model, "gpt-4o-mini")
assert.deepStrictEqual(requestBody.messages, [
{ role: "user", content: "hello" },
{ role: "user", content: "" },
{ role: "user", content: " Hello, 世界!\nGoodbye. " },
{ role: "user", content: "first\nsecond" },
{ role: "user", content: "" }
])
}))
it.effect("routes invalid tool call params through failureMode: return without failing the effect", () =>
Effect.gen(function*() {
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) =>
Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "tool_calls",
message: {
role: "assistant",
content: null,
tool_calls: [{
id: "call_1",
type: "function",
function: {
name: "ReturnModeTool",
arguments: JSON.stringify({ input: 123 })
}
}]
}
}]
})
))
)
))
)
const ReturnModeTool = Tool.make("ReturnModeTool", {
description: "A test tool",
failureMode: "return",
parameters: Schema.Struct({ input: Schema.String }),
success: Schema.Struct({ output: Schema.String }),
failure: Schema.Struct({ error: Schema.String })
})
const toolkit = Toolkit.make(ReturnModeTool)
const toolkitLayer = toolkit.toLayer({
ReturnModeTool: ({ input }) => Effect.succeed({ output: `processed: ${input}` })
})
const result = yield* LanguageModel.generateText({
prompt: "use the tool",
toolkit
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(toolkitLayer),
Effect.provide(layer)
)
assert.strictEqual(result.toolResults.length, 1)
const toolResult = result.toolResults[0]!
assert.strictEqual(toolResult.isFailure, true)
const failure = toolResult.result as AiError.AiError
assert.strictEqual(failure._tag, "AiError")
assert.strictEqual(failure.reason._tag, "ToolParameterValidationError")
}))
it.effect("forwards reasoning config to chat completions request", () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "stop",
message: {
role: "assistant",
content: "Done"
}
}]
})
))
})
))
)
yield* LanguageModel.generateText({ prompt: "hello" }).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-5", {
reasoning: {
effort: "medium",
summary: "auto"
}
})),
Effect.provide(layer)
)
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
assert.deepStrictEqual(requestBody.reasoning, {
effort: "medium",
summary: "auto"
})
}))
it.effect("forwards custom model config properties to chat completions request", () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "stop",
message: {
role: "assistant",
content: "Done"
}
}]
})
))
})
))
)
yield* LanguageModel.generateText({ prompt: "hello" }).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", {
vendor_setting: {
mode: "strict"
}
})),
Effect.provide(layer)
)
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
assert.deepStrictEqual(requestBody.vendor_setting, {
mode: "strict"
})
}))
it.effect("preserves URL and base64 images in multimodal content order", () =>
Effect.gen(function*() {
const base64 = "iVBORw0KGgo="
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "stop",
message: {
role: "assistant",
content: "done"
}
}]
})
))
})
))
)
yield* LanguageModel.generateText({
prompt: Prompt.make([{
role: "user",
content: [
Prompt.textPart({ text: "first text" }),
Prompt.filePart({
mediaType: "image/png",
data: new URL("https://example.com/image.png")
}),
Prompt.filePart({ mediaType: "image/png", data: "https://example.com/string-image.png" }),
Prompt.filePart({ mediaType: "image/png", data: base64 }),
Prompt.textPart({ text: "second text" })
]
}])
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
const content = requestBody.messages[0]?.content
assert.isTrue(Array.isArray(content))
assert.deepStrictEqual(content, [
{
type: "text",
text: "first text"
},
{
type: "image_url",
image_url: {
url: "https://example.com/image.png",
detail: "auto"
}
},
{
type: "image_url",
image_url: {
url: "https://example.com/string-image.png",
detail: "auto"
}
},
{
type: "image_url",
image_url: {
url: `data:image/png;base64,${base64}`,
detail: "auto"
}
},
{
type: "text",
text: "second text"
}
])
}))
it.effect("normalizes empty assistant message content to an empty string", () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "stop",
message: {
role: "assistant",
content: "done"
}
}]
})
))
})
))
)
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "hello" },
{
role: "assistant",
content: [Prompt.textPart({ text: "" })]
},
{ role: "user", content: "continue" }
])
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
const assistantMessage = requestBody.messages.find((message: any) => message.role === "assistant")
assert.isDefined(assistantMessage)
assert.strictEqual(assistantMessage.content, "")
assert.isUndefined(assistantMessage.tool_calls)
}))
it.effect("maps function_call output to tool-call part and sends function tool schema", () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "tool_calls",
message: {
role: "assistant",
content: null,
tool_calls: [{
id: "call_1",
type: "function",
function: {
name: "TestTool",
arguments: JSON.stringify({ input: "hello" })
}
}]
}
}]
})
))
})
))
)
const result = yield* LanguageModel.generateText({
prompt: "use the tool",
toolkit: TestToolkit,
disableToolCallResolution: true
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(TestToolkitLayer),
Effect.provide(layer)
)
const toolCall = result.content.find((part) => part.type === "tool-call")
assert.isDefined(toolCall)
if (toolCall?.type !== "tool-call") {
return
}
assert.strictEqual(toolCall.name, "TestTool")
assert.deepStrictEqual(toolCall.params, { input: "hello" })
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
const functionTool = requestBody.tools.find((tool: any) => tool.type === "function")
assert.isDefined(functionTool)
assert.strictEqual(functionTool.function.name, "TestTool")
assert.strictEqual(functionTool.function.strict, true)
}))
it.effect("decodes tool call params with the OpenAI codec", () =>
Effect.gen(function*() {
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) =>
Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "tool_calls",
message: {
role: "assistant",
content: null,
tool_calls: [{
id: "call_record_1",
type: "function",
function: {
name: "RecordTool",
arguments: JSON.stringify({ env: [{ 0: "PATH", 1: "/usr/bin" }] })
}
}]
}
}]
})
))
)
))
)
const result = yield* LanguageModel.generateText({
prompt: "read the environment",
toolkit: RecordToolkit,
disableToolCallResolution: true
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(RecordToolkitLayer),
Effect.provide(layer)
)
const toolCall = result.content.find((part) => part.type === "tool-call")
assert.isDefined(toolCall)
if (toolCall?.type !== "tool-call") {
return
}
assert.deepStrictEqual(toolCall.params, { env: { PATH: "/usr/bin" } })
}))
it.effect("preserves raw JSON Schema dynamic tool call params", () =>
Effect.gen(function*() {
const params = { query: "effect" }
const client = makeHttpClient((request) =>
Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "tool_calls",
message: {
role: "assistant",
content: null,
tool_calls: [{
id: "call_dynamic_1",
type: "function",
function: { name: "DynamicTool", arguments: JSON.stringify(params) }
}]
}
}]
})
))
)
const DynamicTool = Tool.dynamic("DynamicTool", {
parameters: {
type: "object",
properties: { query: { type: "string" } },
required: ["query"],
additionalProperties: false
} as const
})
const result = yield* LanguageModel.generateText({
prompt: "use the dynamic tool",
toolkit: Toolkit.make(DynamicTool),
disableToolCallResolution: true
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
Effect.provideService(HttpClient.HttpClient, client)
)
assert.deepStrictEqual(result.toolCalls[0]?.params, params)
}))
it.effect("decodes Effect Schema dynamic tool call params with the OpenAI codec", () =>
Effect.gen(function*() {
const DynamicTool = Tool.dynamic("DynamicTool", {
parameters: Schema.Struct({
env: Schema.Record(Schema.String, Schema.String)
})
})
const client = makeHttpClient((request) =>
Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "tool_calls",
message: {
role: "assistant",
content: null,
tool_calls: [{
id: "call_dynamic_1",
type: "function",
function: {
name: "DynamicTool",
arguments: JSON.stringify({ env: [{ 0: "PATH", 1: "/usr/bin" }] })
}
}]
}
}]
})
))
)
const result = yield* LanguageModel.generateText({
prompt: "use the dynamic tool",
toolkit: Toolkit.make(DynamicTool),
disableToolCallResolution: true
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
Effect.provideService(HttpClient.HttpClient, client)
)
assert.deepStrictEqual(result.toolCalls[0]?.params, { env: { PATH: "/usr/bin" } })
}))
it.effect("groups parallel tool calls into one assistant message", () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(request, makeChatCompletion()))
})
))
)
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "use both tools" },
{
role: "assistant",
content: [
Prompt.toolCallPart({
id: "call_1",
name: "TestTool",
params: { input: "first" },
providerExecuted: false
}),
Prompt.toolCallPart({
id: "call_2",
name: "TestTool",
params: { input: "second" },
providerExecuted: false
})
]
},
{
role: "tool",
content: [
Prompt.toolResultPart({
id: "call_1",
name: "TestTool",
isFailure: false,
result: { output: "first" },
providerExecuted: false
}),
Prompt.toolResultPart({
id: "call_2",
name: "TestTool",
isFailure: false,
result: { output: "second" },
providerExecuted: false
})
]
}
]),
toolkit: TestToolkit
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(TestToolkitLayer),
Effect.provide(layer)
)
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
assert.deepStrictEqual(requestBody.messages, [
{ role: "user", content: "use both tools" },
{
role: "assistant",
content: null,
tool_calls: [
{
id: "call_1",
type: "function",
function: { name: "TestTool", arguments: JSON.stringify({ input: "first" }) }
},
{
id: "call_2",
type: "function",
function: { name: "TestTool", arguments: JSON.stringify({ input: "second" }) }
}
]
},
{ role: "tool", tool_call_id: "call_1", content: JSON.stringify({ output: "first" }) },
{ role: "tool", tool_call_id: "call_2", content: JSON.stringify({ output: "second" }) }
])
}))
const modelOutputCases = [
{
label: "as text with file placeholders",
modelOutput: [
Prompt.textPart({ text: "Screenshot" }),
Prompt.filePart({ mediaType: "image/png", fileName: "screenshot.png", data: "iVBORw0KGgo=" })
],
content: "Screenshot\n[image/png screenshot.png omitted]"
},
{ label: "as an empty string when it is empty", modelOutput: [], content: "" }
]
for (const { content, label, modelOutput } of modelOutputCases) {
it.effect(`sends tool result model output ${label}`, () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(request, makeChatCompletion()))
})
))
)
yield* LanguageModel.generateText({
prompt: Prompt.make([
{
role: "assistant",
content: [Prompt.toolCallPart({
id: "call_1",
name: "TestTool",
params: { input: "screenshot" },
providerExecuted: false
})]
},
{
role: "tool",
content: [Prompt.toolResultPart({
id: "call_1",
name: "TestTool",
isFailure: false,
result: { output: "APPLICATION_ONLY" },
modelOutput,
providerExecuted: false
})]
}
]),
toolkit: TestToolkit,
disableToolCallResolution: true
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
assert.deepStrictEqual(requestBody.messages[1], {
role: "tool",
tool_call_id: "call_1",
content
})
}))
}
it.effect("echoes tool call extra_content in follow-up requests", () =>
Effect.gen(function*() {
const extraContent = { google: { thought_signature: "signature-1" } }
const requests: Array<HttpClientRequest.HttpClientRequest> = []
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
requests.push(request)
return Effect.succeed(jsonResponse(
request,
requests.length > 1 ? makeChatCompletion() : makeChatCompletion({
choices: [{
index: 0,
finish_reason: "tool_calls",
message: {
role: "assistant",
content: null,
tool_calls: [{
id: "call_1",
type: "function",
extra_content: extraContent,
function: { name: "TestTool", arguments: JSON.stringify({ input: "hello" }) }
}]
}
}]
})
))
})
))
)
const generate = (prompt: Prompt.Prompt) =>
LanguageModel.generateText({ prompt, toolkit: TestToolkit, disableToolCallResolution: true }).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
const prompt = Prompt.make("use the tool")
const first = yield* generate(prompt)
yield* generate(Prompt.concat(prompt, Prompt.fromResponseParts(first.content)))
const followUpBody = yield* getRequestBody(requests[1])
assert.deepStrictEqual(followUpBody.messages[1].tool_calls[0].extra_content, extraContent)
}))
it.effect("converts dynamic tools to function type", () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "stop",
message: {
role: "assistant",
content: "Done"
}
}]
})
))
})
))
)
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 dynamic tool",
toolkit: Toolkit.make(DynamicTool),
disableToolCallResolution: true
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
const functionTool = requestBody.tools?.find((tool: any) =>
tool.type === "function" && tool.function?.name === "DynamicTool"
)
assert.isDefined(functionTool)
assert.strictEqual(functionTool.function.description, "A dynamic tool")
assert.deepStrictEqual(functionTool.function.parameters, inputSchema)
}))
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.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
Effect.provideService(HttpClient.HttpClient, makeHttpClient(() => Effect.die("unexpected request"))),
Effect.flip
)
assert.strictEqual(error.reason._tag, "UnsupportedSchemaError")
assert.include(error.message, `"NoParams"`)
assert.include(error.message, "Tool.EmptyParams")
}))
it.effect("maps provider apply_patch function call back to custom provider-defined tool", () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "tool_calls",
message: {
role: "assistant",
content: null,
tool_calls: [{
id: "call_1",
type: "function",
function: {
name: "apply_patch",
arguments: JSON.stringify({
call_id: "call_1",
operation: {
type: "delete_file",
path: "src/obsolete.ts"
}
})
}
}]
}
}]
})
))
})
))
)
const toolkit = Toolkit.make(CompatApplyPatchTool({}))
const toolkitLayer = toolkit.toLayer({
CompatApplyPatch: () =>
Effect.succeed({
status: "completed",
output: "deleted"
})
})
const result = yield* LanguageModel.generateText({
prompt: "delete src/obsolete.ts",
toolkit,
toolChoice: { tool: "CompatApplyPatch" },
disableToolCallResolution: true
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(toolkitLayer),
Effect.provide(layer)
)
const toolCall = result.content.find((part) => part.type === "tool-call")
assert.isDefined(toolCall)
if (toolCall?.type !== "tool-call") {
return
}
assert.strictEqual(toolCall.name, "CompatApplyPatch")
assert.deepStrictEqual(toolCall.params, {
call_id: "call_1",
operation: {
type: "delete_file",
path: "src/obsolete.ts"
}
})
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
const functionTool = requestBody.tools.find((tool: any) => tool.type === "function")
assert.isDefined(functionTool)
assert.strictEqual(functionTool.function.name, "apply_patch")
assert.deepStrictEqual(requestBody.tool_choice, {
type: "function",
function: {
name: "apply_patch"
}
})
}))
it.effect("decodes usage when token detail fields are absent", () =>
Effect.gen(function*() {
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) =>
Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "stop",
message: {
role: "assistant",
content: "Hello"
}
}],
usage: {
prompt_tokens: 4,
completion_tokens: 5,
total_tokens: 9,
provider_future_field: true
}
})
))
)
))
)
const result = yield* LanguageModel.generateText({ prompt: "hello" }).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
const finish = result.content.find((part) => part.type === "finish")
assert.isDefined(finish)
if (finish?.type !== "finish") {
return
}
assert.deepStrictEqual(finish.usage.inputTokens, {
uncached: 4,
total: 4,
cacheRead: 0,
cacheWrite: undefined
})
assert.deepStrictEqual(finish.usage.outputTokens, {
total: 5,
text: 5,
reasoning: 0
})
}))
it.effect("surfaces reasoning from non-streaming responses", () =>
Effect.gen(function*() {
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) =>
Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "stop",
message: {
role: "assistant",
reasoning: "I should greet the user.",
content: "Hello!"
}
}]
})
))
)
))
)
const result = yield* LanguageModel.generateText({ prompt: "hello" }).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
const reasoning = result.content.find((part) => part.type === "reasoning")
assert.isDefined(reasoning)
if (reasoning?.type !== "reasoning") {
return
}
assert.strictEqual(reasoning.text, "I should greet the user.")
assert.strictEqual(result.text, "Hello!")
}))
it.effect("surfaces reasoning_content from non-streaming responses", () =>
Effect.gen(function*() {
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) =>
Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "stop",
message: {
role: "assistant",
reasoning_content: "I should greet the user.",
content: "Hello!"
}
}]
})
))
)
))
)
const result = yield* LanguageModel.generateText({ prompt: "hello" }).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
const reasoning = result.content.find((part) => part.type === "reasoning")
assert.isDefined(reasoning)
if (reasoning?.type !== "reasoning") {
return
}
assert.strictEqual(reasoning.text, "I should greet the user.")
assert.strictEqual(result.text, "Hello!")
}))
it.effect("returns invalid and undeclared tool calls when tool call validation is deferred", () =>
Effect.gen(function*() {
const client = makeHttpClient((request) =>
Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "tool_calls",
message: {
role: "assistant",
content: null,
tool_calls: [
{ id: "call_1", type: "function", function: { name: "TestTool", arguments: "{\"input\":42}" } },
{ id: "call_2", type: "function", function: { name: "Write", arguments: "{\"path\":\"a\"}" } }
]
}
}]
})
))
)
const result = yield* LanguageModel.generateText({
prompt: "use the tools",
toolkit: TestToolkit,
disableToolCallResolution: true,
toolCallValidation: "deferred"
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(TestToolkitLayer),
Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
Effect.provideService(HttpClient.HttpClient, client)
)
assert.deepStrictEqual(result.toolCalls.map(({ name, params }) => ({ name, params })), [
{ name: "TestTool", params: { input: 42 } },
{ name: "Write", params: { path: "a" } }
])
}))
it.effect("replays reasoning alongside assistant text and tool calls", () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(request, makeChatCompletion()))
})
))
)
const prompt = Prompt.make([
{ role: "user", content: "What is in a.txt?" },
{
role: "assistant",
content: [
{ type: "reasoning", text: "The user wants a.txt; I should read it." },
{ type: "text", text: "Let me read it." },
{ type: "tool-call", id: "call_1", name: "TestTool", params: { input: "a.txt" } }
]
},
{
role: "tool",
content: [{ type: "tool-result", id: "call_1", name: "TestTool", isFailure: false, result: "hello" }]
}
])
yield* LanguageModel.generateText({ prompt, toolkit: TestToolkit, disableToolCallResolution: true }).pipe(
Effect.provide(OpenAiLanguageModel.model("deepseek-reasoner")),
Effect.provide(layer)
)
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
assert.deepStrictEqual(requestBody.messages, [
{ role: "user", content: "What is in a.txt?" },
{
role: "assistant",
content: "Let me read it.",
reasoning_content: "The user wants a.txt; I should read it.",
tool_calls: [{
id: "call_1",
type: "function",
function: { name: "TestTool", arguments: JSON.stringify({ input: "a.txt" }) }
}]
},
{ role: "tool", tool_call_id: "call_1", content: "hello" }
])
}))
it.effect("replays decoded Groq reasoning under its original field alongside text and tool calls", () =>
Effect.gen(function*() {
const requests: Array<HttpClientRequest.HttpClientRequest> = []
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
requests.push(request)
return Effect.succeed(jsonResponse(
request,
requests.length > 1 ? makeChatCompletion() : makeChatCompletion({
choices: [{
index: 0,
finish_reason: "tool_calls",
message: {
role: "assistant",
reasoning: "Need the file",
content: "Let me read it.",
tool_calls: [{
id: "call_1",
type: "function",
function: { name: "TestTool", arguments: JSON.stringify({ input: "a.txt" }) }
}]
}
}]
})
))
})
))
)
const generate = (prompt: Prompt.Prompt) =>
LanguageModel.generateText({ prompt, toolkit: TestToolkit, disableToolCallResolution: true }).pipe(
Effect.provide(OpenAiLanguageModel.model("openai/gpt-oss-120b")),
Effect.provide(layer)
)
const prompt = Prompt.make("What is in a.txt?")
const first = yield* generate(prompt)
yield* generate(Prompt.concat(
Prompt.concat(prompt, Prompt.fromResponseParts(first.content)),
Prompt.make([{
role: "tool",
content: [{ type: "tool-result", id: "call_1", name: "TestTool", isFailure: false, result: "hello" }]
}])
))
const followUpBody = yield* getRequestBody(requests[1])
assert.deepStrictEqual(followUpBody.messages, [
{ role: "user", content: "What is in a.txt?" },
{
role: "assistant",
content: "Let me read it.",
reasoning: "Need the file",
tool_calls: [{
id: "call_1",
type: "function",
function: { name: "TestTool", arguments: JSON.stringify({ input: "a.txt" }) }
}]
},
{ role: "tool", tool_call_id: "call_1", content: "hello" }
])
}))
})
describe("generateObject", () => {
it.effect("uses json_schema format for structured output", () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "stop",
message: {
role: "assistant",
content: JSON.stringify({ name: "Ada", age: 37 })
}
}]
})
))
})
))
)
const person = yield* LanguageModel.generateObject({
prompt: "Return a person",
schema: Schema.Struct({
name: Schema.String,
age: Schema.Number
})
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
assert.strictEqual(person.value.name, "Ada")
assert.strictEqual(person.value.age, 37)
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
assert.strictEqual(requestBody.response_format.type, "json_schema")
assert.strictEqual(requestBody.response_format.json_schema.strict, true)
}))
it.effect("uses OpenAI codec transformer for optional structured fields", () =>
Effect.gen(function*() {
let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
capturedRequest = request
return Effect.succeed(jsonResponse(
request,
makeChatCompletion({
choices: [{
index: 0,
finish_reason: "stop",
message: {
role: "assistant",
content: JSON.stringify({ name: "Ada", nickname: null })
}
}]
})
))
})
))
)
const person = yield* LanguageModel.generateObject({
prompt: "Return a person",
schema: Schema.Struct({
name: Schema.String,
nickname: Schema.optionalKey(Schema.String)
})
}).pipe(
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
assert.strictEqual(person.value.name, "Ada")
assert.isUndefined(person.value.nickname)
assert.isDefined(capturedRequest)
if (capturedRequest === undefined) {
return
}
const requestBody = yield* getRequestBody(capturedRequest)
assert.deepStrictEqual(requestBody.response_format.json_schema.schema.required, ["name", "nickname"])
assert.deepStrictEqual(requestBody.response_format.json_schema.schema.properties.nickname, {
anyOf: [{ type: "string" }, { type: "null" }]
})
}))
})
describe("streamText", () => {
it.effect("replays streamed assistant text and tool calls with store enabled", () =>
Effect.gen(function*() {
const requests: Array<HttpClientRequest.HttpClientRequest> = []
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) => {
requests.push(request)
return Effect.succeed(
requests.length > 1
? jsonResponse(request, makeChatCompletion())
: sseResponse(request, [
{
id: "chatcmpl_store_1",
object: "chat.completion.chunk",
model: "gpt-4o-mini",
created: 1,
choices: [{
index: 0,
delta: {
content: "Let me read it.",
tool_calls: [{
index: 0,
id: "call_1",
type: "function",
function: { name: "TestTool", arguments: JSON.stringify({ input: "a.txt" }) }
}]
},
finish_reason: "tool_calls"
}]
},
"[DONE]"
])
)
})
))
)
const model = OpenAiLanguageModel.model("gpt-4o-mini", { store: true })
const prompt = Prompt.make("What is in a.txt?")
const parts = yield* LanguageModel.streamText({
prompt,
toolkit: TestToolkit,
disableToolCallResolution: true
}).pipe(
Stream.runCollect,
Effect.provide(model),
Effect.provide(layer)
)
yield* LanguageModel.generateText({
prompt: Prompt.concat(
Prompt.concat(prompt, Prompt.fromResponseParts(parts)),
Prompt.make([{
role: "tool",
content: [{ type: "tool-result", id: "call_1", name: "TestTool", isFailure: false, result: "hello" }]
}])
),
toolkit: TestToolkit,
disableToolCallResolution: true
}).pipe(
Effect.provide(model),
Effect.provide(layer)
)
const followUpBody = yield* getRequestBody(requests[1])
assert.deepStrictEqual(followUpBody.messages, [
{ role: "user", content: "What is in a.txt?" },
{
role: "assistant",
content: "Let me read it.",
tool_calls: [{
id: "call_1",
type: "function",
function: { name: "TestTool", arguments: JSON.stringify({ input: "a.txt" }) }
}]
},
{ role: "tool", tool_call_id: "call_1", content: "hello" }
])
}))
it.effect("handles chat completion stream chunks", () =>
Effect.gen(function*() {
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) =>
Effect.succeed(sseResponse(request, [
{
id: "chatcmpl_test123",
object: "chat.completion.chunk",
model: "gpt-4o-mini",
created: 1,
choices: [{
index: 0,
delta: {},
finish_reason: "stop"
}]
},
"[DONE]"
]))
)
))
)
const partsChunk = yield* LanguageModel.streamText({ prompt: "test" }).pipe(
Stream.runCollect,
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(layer)
)
const parts = Array.from(partsChunk)
assert.isTrue(parts.some((part) => part.type === "response-metadata"))
const finish = parts.find((part) => part.type === "finish")
assert.isDefined(finish)
if (finish?.type === "finish") {
assert.strictEqual(finish.reason, "stop")
}
}))
it.effect("streams undeclared tool calls when tool call validation is deferred", () =>
Effect.gen(function*() {
const client = makeHttpClient((request) =>
Effect.succeed(sseResponse(request, [
{
id: "chatcmpl_undeclared",
object: "chat.completion.chunk",
model: "gpt-4o-mini",
created: 1,
choices: [{
index: 0,
delta: {
tool_calls: [{
index: 0,
id: "call_1",
type: "function",
function: { name: "Write", arguments: JSON.stringify({ path: "a" }) }
}]
},
finish_reason: "tool_calls"
}]
},
"[DONE]"
]))
)
const parts = yield* LanguageModel.streamText({
prompt: "use the tools",
toolkit: TestToolkit,
disableToolCallResolution: true,
toolCallValidation: "deferred"
}).pipe(
Stream.runCollect,
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(TestToolkitLayer),
Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
Effect.provideService(HttpClient.HttpClient, client)
)
assert.deepStrictEqual(
parts.filter((part) => part.type === "tool-call").map(({ name, params }) => ({ name, params })),
[{ name: "Write", params: { path: "a" } }]
)
}))
it.effect("emits text when streamed tool_calls is null", () =>
Effect.gen(function*() {
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) =>
Effect.succeed(sseResponse(request, [
{
id: "chatcmpl_nullable_tool_calls",
object: "chat.completion.chunk",
model: "inception/mercury-2",
created: 1,
choices: [{
index: 0,
delta: {
content: "Hello",
role: "assistant",
tool_calls: null
},
finish_reason: null
}]
},
"[DONE]"
]))
)
))
)
const partsChunk = yield* LanguageModel.streamText({ prompt: "test" }).pipe(
Stream.runCollect,
Effect.provide(OpenAiLanguageModel.model("inception/mercury-2")),
Effect.provide(layer)
)
const text = Array.from(partsChunk)
.filter((part) => part.type === "text-delta")
.map((part) => part.delta)
.join("")
assert.strictEqual(text, "Hello")
}))
it.effect("preserves streamed text and tool args with nullable delta fields", () =>
Effect.gen(function*() {
const extraContent = { google: { thought_signature: "signature-1" } }
const chunk = (delta: Record<string, unknown>) => ({
id: "chatcmpl_nullable_delta_fields",
object: "chat.completion.chunk",
model: "gpt-4o-mini",
created: 1,
choices: [{ index: 0, delta, finish_reason: null }]
})
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) =>
Effect.succeed(sseResponse(request, [
chunk({ content: "Hello", role: null }),
chunk({
tool_calls: [{
index: 0,
id: "call_1",
type: "function",
extra_content: extraContent,
function: { name: "TestTool", arguments: "" }
}]
}),
chunk({
tool_calls: [{
index: 0,
id: null,
extra_content: null,
function: { name: null, arguments: "{\"in" }
}]
}),
chunk({
tool_calls: [{ index: 0, id: null, function: { name: null, arguments: "put\":\"hel" } }]
}),
chunk({
tool_calls: [{ index: 0, id: null, function: { name: null, arguments: "lo\"}" } }]
}),
{
id: "chatcmpl_nullable_delta_fields",
object: "chat.completion.chunk",
model: "gpt-4o-mini",
created: 1,
choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }]
},
"[DONE]"
]))
)
))
)
const partsChunk = yield* LanguageModel.streamText({
prompt: "use the tool",
toolkit: TestToolkit,
disableToolCallResolution: true
}).pipe(
Stream.runCollect,
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(TestToolkitLayer),
Effect.provide(layer)
)
const parts = globalThis.Array.from(partsChunk)
const text = parts
.filter((part) => part.type === "text-delta")
.map((part) => part.delta)
.join("")
const toolCall = parts.find((part) => part.type === "tool-call")
assert.strictEqual(text, "Hello")
assert.isDefined(toolCall)
if (toolCall?.type !== "tool-call") {
return
}
assert.strictEqual(toolCall.id, "call_1")
assert.deepStrictEqual(toolCall.params, { input: "hello" })
assert.deepStrictEqual(toolCall.metadata["openai-compat"] as unknown, { itemId: "call_1", extraContent })
}))
it.effect("decodes streamed tool call params with the OpenAI codec", () =>
Effect.gen(function*() {
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(
HttpClient.HttpClient,
makeHttpClient((request) =>
Effect.succeed(sseResponse(request, [
{
id: "chatcmpl_record_1",
object: "chat.completion.chunk",
model: "gpt-4o-mini",
created: 1,
choices: [{
index: 0,
delta: {
tool_calls: [{
index: 0,
id: "call_record_1",
type: "function",
function: {
name: "RecordTool",
arguments: JSON.stringify({ env: [{ 0: "PATH", 1: "/usr/bin" }] })
}
}]
},
finish_reason: "tool_calls"
}]
},
"[DONE]"
]))
)
))
)
const partsChunk = yield* LanguageModel.streamText({
prompt: "read the environment",
toolkit: RecordToolkit,
disableToolCallResolution: true
}).pipe(
Stream.runCollect,
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(RecordToolkitLayer),
Effect.provide(layer)
)
const toolCall = globalThis.Array.from(partsChunk).find((part) => part.type === "tool-call")
assert.isDefined(toolCall)
if (toolCall?.type !== "tool-call") {
return
}
assert.deepStrictEqual(toolCall.params, { env: { PATH: "/usr/bin" } })
}))
it.effect("maps local shell stream tool calls to local_shell call outputs", () =>
Effect.gen(function*() {
const capturedRequests = yield* Ref.make<ReadonlyArray<HttpClientRequest.HttpClientRequest>>([])
const requestCount = yield* Ref.make(0)
const httpClient = HttpClient.makeWith(
Effect.fnUntraced(function*(requestEffect) {
const request = yield* requestEffect
yield* Ref.update(capturedRequests, (requests) => [...requests, request])
const index = yield* Ref.getAndUpdate(requestCount, (value) => value + 1)
if (index === 0) {
return sseResponse(request, [makeLocalShellChunk(), "[DONE]"])
}
return jsonResponse(request, makeChatCompletion())
}),
Effect.succeed as HttpClient.HttpClient.Preprocess<HttpClientError.HttpClientError, never>
)
const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
Layer.provide(Layer.succeed(HttpClient.HttpClient, httpClient))
)
const toolkit = Toolkit.make(CompatLocalShellTool({}))
const toolkitLayer = toolkit.toLayer({
CompatLocalShell: () => Effect.succeed("done")
})
const partsChunk = yield* LanguageModel.streamText({
prompt: "Run pwd",
toolkit,
disableToolCallResolution: true
}).pipe(
Stream.runCollect,
Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
Effect.provide(toolkitLayer),
Effect.provide(layer)
)
const toolCall = globalThis.Array.from(partsChunk).find((part) => part.type === "tool-call")
assert.isDefined(toolCall)
if (toolCall?.type !== "tool-call") {
return
}
assert.strictEqual(toolCall.name, "CompatLocalShell")
assert.deepStrictEqual(toolCall.params, { action: localShellAction })
yield* LanguageModel.generateText({
prompt: Prompt.make([
{ role: "user", content: "Run pwd" },
{
role: "assistant",