@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 1,378 lines 49.6 KB
Raw
1 import type { OpenAiSchema } from "@effect/ai-openai"
2 import type * as Generated from "@effect/ai-openai/Generated"
3 import * as Errors from "@effect/ai-openai/internal/errors"
4 import * as OpenAiClient from "@effect/ai-openai/OpenAiClient"
5 import * as OpenAiClientGenerated from "@effect/ai-openai/OpenAiClientGenerated"
6 import * as OpenAiConfig from "@effect/ai-openai/OpenAiConfig"
7 import * as OpenAiLanguageModel from "@effect/ai-openai/OpenAiLanguageModel"
8 import { assert, describe, it } from "@effect/vitest"
9 import { Config, ConfigProvider, Context, Duration, Effect, Layer, Redacted, Schema, Stream } from "effect"
10 import { Chat } from "effect/ai"
11 import * as HttpClient from "effect/http/HttpClient"
12 import * as HttpClientError from "effect/http/HttpClientError"
13 import * as HttpClientRequest from "effect/http/HttpClientRequest"
14 import * as HttpClientResponse from "effect/http/HttpClientResponse"
15 import * as Socket from "effect/socket/Socket"
16 import { WS } from "vitest-websocket-mock"
17
18 describe("OpenAiClient", () => {
19 describe("make", () => {
20 it.effect("sets Bearer token from apiKey", () =>
21 Effect.gen(function*() {
22 const client = yield* OpenAiClient.OpenAiClient
23 yield* client.createResponse({ model: "gpt-4o", input: "test" })
24
25 const requests = yield* MockHttpClient.requests
26 assert.strictEqual(requests[0]?.headers["authorization"], "Bearer sk-test-12345")
27 }).pipe(Effect.provide(makeTestLayer({
28 apiKey: Redacted.make("sk-test-12345")
29 }))))
30
31 it.effect("prepends default URL", () =>
32 Effect.gen(function*() {
33 const client = yield* OpenAiClient.OpenAiClient
34 yield* client.createResponse({ model: "gpt-4o", input: "test" })
35
36 const requests = yield* MockHttpClient.requests
37 assert.isTrue(requests[0]?.url.startsWith("https://api.openai.com/v1"))
38 }).pipe(Effect.provide(makeTestLayer())))
39
40 it.effect("uses custom apiUrl when provided", () =>
41 Effect.gen(function*() {
42 const client = yield* OpenAiClient.OpenAiClient
43 yield* client.createResponse({ model: "gpt-4o", input: "test" })
44
45 const requests = yield* MockHttpClient.requests
46 assert.isTrue(requests[0]?.url.startsWith("https://custom.api.com/v2"))
47 }).pipe(Effect.provide(makeTestLayer({
48 apiKey: Redacted.make("test-key"),
49 apiUrl: "https://custom.api.com/v2"
50 }))))
51
52 it.effect("sets OpenAI-Organization header when organizationId provided", () =>
53 Effect.gen(function*() {
54 const client = yield* OpenAiClient.OpenAiClient
55 yield* client.createResponse({ model: "gpt-4o", input: "test" })
56
57 const requests = yield* MockHttpClient.requests
58 assert.strictEqual(requests[0]?.headers["openai-organization"], "org-12345")
59 }).pipe(Effect.provide(makeTestLayer({
60 apiKey: Redacted.make("test-key"),
61 organizationId: Redacted.make("org-12345")
62 }))))
63
64 it.effect("sets OpenAI-Project header when projectId provided", () =>
65 Effect.gen(function*() {
66 const client = yield* OpenAiClient.OpenAiClient
67 yield* client.createResponse({ model: "gpt-4o", input: "test" })
68
69 const requests = yield* MockHttpClient.requests
70 assert.strictEqual(requests[0]?.headers["openai-project"], "proj-67890")
71 }).pipe(Effect.provide(makeTestLayer({
72 apiKey: Redacted.make("test-key"),
73 projectId: Redacted.make("proj-67890")
74 }))))
75
76 it.effect("applies transformClient option", () => {
77 let transformApplied = false
78 return Effect.gen(function*() {
79 const client = yield* OpenAiClient.OpenAiClient
80 yield* client.createResponse({ model: "gpt-4o", input: "test" })
81 assert.isTrue(transformApplied)
82 }).pipe(Effect.provide(makeTestLayer({
83 apiKey: Redacted.make("test-key"),
84 transformClient: (client) => {
85 transformApplied = true
86 return client
87 }
88 })))
89 })
90
91 it.effect("exposes transformed HttpClient via client field", () =>
92 Effect.gen(function*() {
93 const client = yield* OpenAiClient.OpenAiClient
94 yield* client.client.execute(HttpClientRequest.get("/responses"))
95
96 const requests = yield* MockHttpClient.requests
97 const request = requests[0]
98 assert.isTrue(request?.url.startsWith("https://api.openai.com/v1"))
99 assert.strictEqual(request?.headers["authorization"], "Bearer test-key")
100 assert.strictEqual(request?.headers["x-client-field"], "enabled")
101 }).pipe(Effect.provide(makeTestLayer({
102 apiKey: Redacted.make("test-key"),
103 transformClient: (client) =>
104 client.pipe(HttpClient.mapRequest(HttpClientRequest.setHeader("x-client-field", "enabled")))
105 }))))
106
107 it.effect("applies OpenAiConfig transformClient after options transformClient", () => {
108 let optionsTransformApplied = false
109 let configTransformApplied = false
110
111 return Effect.gen(function*() {
112 const client = yield* OpenAiClient.OpenAiClient
113 yield* client.createResponse({
114 model: "gpt-4o",
115 input: "test"
116 }).pipe(
117 OpenAiConfig.withClientTransform((client) => {
118 configTransformApplied = true
119 return client.pipe(
120 HttpClient.mapRequest(HttpClientRequest.setHeader("x-openai-transform", "config"))
121 )
122 })
123 )
124
125 const requests = yield* MockHttpClient.requests
126 assert.isTrue(optionsTransformApplied)
127 assert.isTrue(configTransformApplied)
128 assert.strictEqual(requests[0]?.headers["x-openai-transform"], "config")
129 }).pipe(Effect.provide(makeTestLayer({
130 apiKey: Redacted.make("test-key"),
131 transformClient: (client) => {
132 optionsTransformApplied = true
133 return client.pipe(
134 HttpClient.mapRequest(HttpClientRequest.setHeader("x-openai-transform", "options"))
135 )
136 }
137 })))
138 })
139 })
140
141 describe("OpenAiClientGenerated", () => {
142 it.effect("sets Bearer token from apiKey", () =>
143 Effect.gen(function*() {
144 const client = yield* OpenAiClientGenerated.OpenAiClientGenerated
145 yield* client.createResponse({
146 payload: { model: "gpt-4o", input: "test" }
147 })
148
149 const requests = yield* MockHttpClient.requests
150 assert.strictEqual(requests[0]?.headers["authorization"], "Bearer sk-generated-test")
151 }).pipe(Effect.provide(makeGeneratedTestLayer({
152 apiKey: Redacted.make("sk-generated-test")
153 }))))
154
155 it.effect("prepends custom apiUrl", () =>
156 Effect.gen(function*() {
157 const client = yield* OpenAiClientGenerated.OpenAiClientGenerated
158 yield* client.createResponse({
159 payload: { model: "gpt-4o", input: "test" }
160 })
161
162 const requests = yield* MockHttpClient.requests
163 assert.isTrue(requests[0]?.url.startsWith("https://generated.example.test/v2"))
164 }).pipe(Effect.provide(makeGeneratedTestLayer({
165 apiKey: Redacted.make("test-key"),
166 apiUrl: "https://generated.example.test/v2"
167 }))))
168
169 it.effect("applies OpenAiConfig transformClient after options transformClient", () => {
170 let optionsTransformApplied = false
171 let configTransformApplied = false
172
173 return Effect.gen(function*() {
174 const client = yield* OpenAiClientGenerated.OpenAiClientGenerated
175 yield* client.createResponse({
176 payload: { model: "gpt-4o", input: "test" }
177 }).pipe(
178 OpenAiConfig.withClientTransform((client) => {
179 configTransformApplied = true
180 return client.pipe(
181 HttpClient.mapRequest(HttpClientRequest.setHeader("x-openai-transform", "config"))
182 )
183 })
184 )
185
186 const requests = yield* MockHttpClient.requests
187 assert.isTrue(optionsTransformApplied)
188 assert.isTrue(configTransformApplied)
189 assert.strictEqual(requests[0]?.headers["x-openai-transform"], "config")
190 }).pipe(Effect.provide(makeGeneratedTestLayer({
191 apiKey: Redacted.make("test-key"),
192 transformClient: (client) => {
193 optionsTransformApplied = true
194 return client.pipe(
195 HttpClient.mapRequest(HttpClientRequest.setHeader("x-openai-transform", "options"))
196 )
197 }
198 })))
199 })
200 })
201
202 describe("layer", () => {
203 it.effect("creates working service", () =>
204 Effect.gen(function*() {
205 const client = yield* OpenAiClient.OpenAiClient
206 assert.isNotNull(client.client)
207 }).pipe(Effect.provide(makeTestLayer())))
208
209 it.effect("layerConfig loads from Config", () => {
210 const configProvider = ConfigProvider.fromEnv({
211 env: {
212 MY_API_KEY: "sk-config-key",
213 MY_API_URL: "https://config.api.com/v1"
214 }
215 })
216
217 return Effect.gen(function*() {
218 const client = yield* OpenAiClient.OpenAiClient
219 yield* client.createResponse({ model: "gpt-4o", input: "test" })
220
221 const requests = yield* MockHttpClient.requests
222 assert.strictEqual(requests[0]?.headers["authorization"], "Bearer sk-config-key")
223 assert.isTrue(requests[0]?.url.startsWith("https://config.api.com/v1"))
224 }).pipe(Effect.provide(makeConfigTestLayer(configProvider)))
225 })
226 })
227
228 describe("request behavior", () => {
229 it.effect("redacts OpenAI-specific headers in AI error context", () =>
230 Effect.gen(function*() {
231 const client = yield* OpenAiClient.OpenAiClient
232 const result = yield* client.createResponse({
233 model: "gpt-4o",
234 input: "test"
235 }).pipe(Effect.flip)
236
237 assert.strictEqual(result.reason._tag, "InvalidRequestError")
238 const output = JSON.stringify(result)
239 assert.notInclude(output, "test-key")
240 assert.notInclude(output, "org-secret")
241 assert.notInclude(output, "proj-secret")
242 }).pipe(Effect.provide(makeTestLayer({
243 apiKey: Redacted.make("test-key"),
244 organizationId: Redacted.make("org-secret"),
245 projectId: Redacted.make("proj-secret")
246 }, {
247 _tag: "Json",
248 status: 400,
249 body: { error: { message: "Bad request" } }
250 }))))
251 })
252
253 describe("error mapping", () => {
254 it.effect("maps TransportError to NetworkError reason", () => {
255 const failures: Array<HttpClientError.HttpClientError> = []
256 return Effect.gen(function*() {
257 const client = yield* OpenAiClient.make({
258 apiKey: Redacted.make("test-key")
259 })
260 const result = yield* client.createResponse({ model: "gpt-4o", input: "test" }).pipe(
261 Effect.flip
262 )
263
264 assert.strictEqual(result._tag, "AiError")
265 assert.strictEqual(result.module, "OpenAiClient")
266 assert.strictEqual(result.method, "createResponse")
267 assert.strictEqual(result.reason._tag, "NetworkError")
268 if (result.reason._tag !== "NetworkError") return
269 assert.strictEqual(result.reason.cause, failures[0])
270 assert.isUndefined(result.reason.description)
271 }).pipe(Effect.provide(Layer.succeed(HttpClient.HttpClient, makeTransportErrorHttpClient(failures))))
272 })
273
274 it.effect("keeps the HttpClientError as the NetworkError cause when it has no cause", () => {
275 const failures: Array<HttpClientError.HttpClientError> = []
276 return Effect.gen(function*() {
277 const client = yield* OpenAiClient.make({
278 apiKey: Redacted.make("test-key")
279 })
280 const result = yield* client.createResponse({ model: "gpt-4o", input: "test" }).pipe(
281 Effect.flip
282 )
283
284 assert.isUndefined(failures[0].cause)
285 assert.strictEqual(result.reason._tag === "NetworkError" && result.reason.cause, failures[0])
286 }).pipe(Effect.provide(Layer.succeed(HttpClient.HttpClient, makeTransportErrorHttpClient(failures, {}))))
287 })
288
289 it.effect("maps 400 status to InvalidRequestError reason", () =>
290 Effect.gen(function*() {
291 const client = yield* OpenAiClient.OpenAiClient
292 const result = yield* client.createResponse({ model: "gpt-4o", input: "test" }).pipe(Effect.flip)
293
294 assert.strictEqual(result._tag, "AiError")
295 assert.strictEqual(result.module, "OpenAiClient")
296 assert.strictEqual(result.method, "createResponse")
297 assert.strictEqual(result.reason._tag, "InvalidRequestError")
298 }).pipe(Effect.provide(makeTestLayer(undefined, {
299 _tag: "Json",
300 status: 400,
301 body: { error: { message: "Bad request" } }
302 }))))
303
304 it.effect("maps 401 status to AuthenticationError reason", () =>
305 Effect.gen(function*() {
306 const client = yield* OpenAiClient.OpenAiClient
307 const result = yield* client.createResponse({ model: "gpt-4o", input: "test" }).pipe(Effect.flip)
308
309 assert.strictEqual(result._tag, "AiError")
310 assert.strictEqual(result.reason._tag, "AuthenticationError")
311 if (result.reason._tag === "AuthenticationError") {
312 assert.strictEqual(result.reason.kind, "InvalidKey")
313 assert.strictEqual(
314 result.reason.description,
315 "Invalid API key (POST https://api.openai.com/v1/responses) [code: invalid_api_key] [requestId: req_openai]"
316 )
317 assert.include(result.reason.message, "Invalid API key")
318 }
319 }).pipe(Effect.provide(makeTestLayer(undefined, {
320 _tag: "Json",
321 status: 401,
322 body: { error: { message: "Invalid API key", type: "invalid_request_error", code: "invalid_api_key" } },
323 headers: { "x-request-id": "req_openai" }
324 }))))
325
326 it("preserves and truncates a fallback HTTP response", () => {
327 const body = `${"a".repeat(200)}b`
328 const reason = Errors.mapStatusCodeToReason({
329 now: 0,
330 status: 400,
331 headers: {},
332 message: undefined,
333 metadata: { errorCode: null, errorType: null, requestId: null },
334 method: "POST",
335 url: "https://api.openai.com/v1/responses",
336 http: { body }
337 })
338
339 assert.strictEqual(reason._tag, "InvalidRequestError")
340 if (reason._tag !== "InvalidRequestError") {
341 throw new Error("Expected InvalidRequestError")
342 }
343 assert.strictEqual(
344 reason.description,
345 `HTTP 400 (POST https://api.openai.com/v1/responses) Response: ${"a".repeat(200)}...`
346 )
347 })
348
349 it.effect("maps 403 status to AuthenticationError with InsufficientPermissions", () =>
350 Effect.gen(function*() {
351 const client = yield* OpenAiClient.OpenAiClient
352 const result = yield* client.createResponse({ model: "gpt-4o", input: "test" }).pipe(Effect.flip)
353
354 assert.strictEqual(result._tag, "AiError")
355 assert.strictEqual(result.reason._tag, "AuthenticationError")
356 if (result.reason._tag === "AuthenticationError") {
357 assert.strictEqual(result.reason.kind, "InsufficientPermissions")
358 assert.include(result.reason.description ?? "", "Access denied")
359 assert.include(result.reason.message, "Access denied")
360 }
361 }).pipe(Effect.provide(makeTestLayer(undefined, {
362 _tag: "Json",
363 status: 403,
364 body: { error: { message: "Access denied" } }
365 }))))
366
367 it.effect("maps 429 status to RateLimitError reason", () =>
368 Effect.gen(function*() {
369 const client = yield* OpenAiClient.OpenAiClient
370 const result = yield* client.createResponse({ model: "gpt-4o", input: "test" }).pipe(Effect.flip)
371
372 assert.strictEqual(result._tag, "AiError")
373 assert.strictEqual(result.reason._tag, "RateLimitError")
374 assert.isTrue(result.isRetryable)
375 }).pipe(Effect.provide(makeTestLayer(undefined, {
376 _tag: "Json",
377 status: 429,
378 body: { error: { message: "Rate limit exceeded", type: "rate_limit_error", code: null } }
379 }))))
380
381 it.effect.each([
382 { name: "ignores a negative Retry-After", header: "-5", expected: undefined },
383 { name: "ignores a non-finite Retry-After", header: "Infinity", expected: undefined },
384 { name: "honors an HTTP-date Retry-After", header: "Thu, 01 Jan 1970 00:00:30 GMT", expected: 30_000 }
385 ])("$name", ({ expected, header }) =>
386 Effect.gen(function*() {
387 const client = yield* OpenAiClient.OpenAiClient
388 const result = yield* client.createResponse({ model: "gpt-4o", input: "test" }).pipe(Effect.flip)
389
390 assert.strictEqual(result.reason._tag, "RateLimitError")
391 if (result.reason._tag !== "RateLimitError") return
392 assert.strictEqual(
393 result.reason.retryAfter === undefined ? undefined : Duration.toMillis(result.reason.retryAfter),
394 expected
395 )
396 }).pipe(Effect.provide(makeTestLayer(undefined, {
397 _tag: "Json",
398 status: 429,
399 headers: { "retry-after": header },
400 body: { error: { message: "Rate limit exceeded", type: "rate_limit_error", code: null } }
401 }))))
402
403 it.effect("maps 429 with insufficient_quota code to QuotaExhaustedError", () =>
404 Effect.gen(function*() {
405 const client = yield* OpenAiClient.OpenAiClient
406 const result = yield* client.createResponse({ model: "gpt-4o", input: "test" }).pipe(Effect.flip)
407
408 assert.strictEqual(result._tag, "AiError")
409 assert.strictEqual(result.reason._tag, "QuotaExhaustedError")
410 assert.isFalse(result.isRetryable)
411 }).pipe(Effect.provide(makeTestLayer(undefined, {
412 _tag: "Json",
413 status: 429,
414 body: {
415 error: {
416 message: "You exceeded your current quota",
417 type: "insufficient_quota",
418 code: "insufficient_quota"
419 }
420 }
421 }))))
422
423 it.effect("maps OpenAI-compatible 402 errors to QuotaExhaustedError", () =>
424 Effect.gen(function*() {
425 const client = yield* OpenAiClient.OpenAiClient
426 const result = yield* client.createResponse({ model: "grok-4", input: "test" }).pipe(Effect.flip)
427
428 assert.strictEqual(result._tag, "AiError")
429 assert.strictEqual(result.reason._tag, "QuotaExhaustedError")
430 assert.isFalse(result.isRetryable)
431 }).pipe(Effect.provide(makeTestLayer(undefined, {
432 _tag: "Json",
433 status: 402,
434 body: { error: "Your balance is too low", code: "billing_insufficient_balance" }
435 }))))
436
437 it.effect("maps OpenAI-compatible insufficient balance errors to QuotaExhaustedError", () =>
438 Effect.gen(function*() {
439 const client = yield* OpenAiClient.OpenAiClient
440 const result = yield* client.createResponse({ model: "grok-4", input: "test" }).pipe(Effect.flip)
441
442 assert.strictEqual(result._tag, "AiError")
443 assert.strictEqual(result.reason._tag, "QuotaExhaustedError")
444 assert.isFalse(result.isRetryable)
445 }).pipe(Effect.provide(makeTestLayer(undefined, {
446 _tag: "Json",
447 status: 429,
448 body: { error: "Your balance is too low", code: "billing_insufficient_balance" }
449 }))))
450
451 it("mapStatusCodeToReason detects insufficient_quota as QuotaExhaustedError", () => {
452 const reason = Errors.mapStatusCodeToReason({
453 now: 0,
454 status: 429,
455 method: "POST",
456 url: "https://api.openai.com",
457 headers: {},
458 message: "You exceeded your current quota",
459 metadata: {
460 errorCode: "insufficient_quota",
461 errorType: "insufficient_quota",
462 requestId: null
463 },
464 http: {}
465 })
466 assert.strictEqual(reason._tag, "QuotaExhaustedError")
467 })
468
469 it("OpenAiErrorBody decodes error with type and code", () => {
470 const json = {
471 error: {
472 message: "You exceeded your current quota",
473 type: "insufficient_quota",
474 code: "insufficient_quota"
475 }
476 }
477 const decoded = Schema.decodeUnknownSync(Errors.OpenAiErrorBody)(json)
478 assert.strictEqual(decoded.error.message, "You exceeded your current quota")
479 assert.strictEqual(decoded.error.type, "insufficient_quota")
480 assert.strictEqual(decoded.error.code, "insufficient_quota")
481 })
482
483 it.effect("maps 5xx status to InternalProviderError reason", () =>
484 Effect.gen(function*() {
485 const client = yield* OpenAiClient.OpenAiClient
486 const result = yield* client.createResponse({ model: "gpt-4o", input: "test" }).pipe(Effect.flip)
487
488 assert.strictEqual(result._tag, "AiError")
489 assert.strictEqual(result.reason._tag, "InternalProviderError")
490 assert.isTrue(result.isRetryable)
491 }).pipe(Effect.provide(makeTestLayer(undefined, {
492 _tag: "Json",
493 status: 500,
494 body: { error: { message: "Internal server error" } }
495 }))))
496
497 it.effect("maps a malformed successful response envelope to a non-retryable InvalidResponseError reason", () =>
498 Effect.gen(function*() {
499 const client = yield* OpenAiClient.OpenAiClient
500 const result = yield* client.createResponse({ model: "gpt-4o", input: "test" }).pipe(Effect.flip)
501
502 assert.strictEqual(result._tag, "AiError")
503 assert.strictEqual(result.method, "createResponse")
504 assert.strictEqual(result.reason._tag, "InvalidResponseError")
505 assert.isFalse(result.isRetryable)
506 }).pipe(Effect.provide(makeTestLayer(undefined, {
507 _tag: "Json",
508 body: { invalid: "response" } as any
509 }))))
510 })
511
512 describe("createEmbedding", () => {
513 it.effect("maps 400 error to AiError", () =>
514 Effect.gen(function*() {
515 const client = yield* OpenAiClient.OpenAiClient
516 const result = yield* client.createEmbedding({
517 model: "invalid-model",
518 input: "test"
519 }).pipe(Effect.flip)
520
521 assert.strictEqual(result._tag, "AiError")
522 assert.strictEqual(result.method, "createEmbedding")
523 assert.strictEqual(result.reason._tag, "InvalidRequestError")
524 }).pipe(Effect.provide(makeTestLayer(undefined, {
525 _tag: "Json",
526 status: 400,
527 body: { error: { message: "Invalid model" } }
528 }))))
529
530 it.effect("maps 429 error to RateLimitError", () =>
531 Effect.gen(function*() {
532 const client = yield* OpenAiClient.OpenAiClient
533 const result = yield* client.createEmbedding({
534 model: "text-embedding-ada-002",
535 input: "test"
536 }).pipe(Effect.flip)
537
538 assert.strictEqual(result._tag, "AiError")
539 assert.strictEqual(result.reason._tag, "RateLimitError")
540 }).pipe(Effect.provide(makeTestLayer(undefined, {
541 _tag: "Json",
542 status: 429,
543 body: { error: { message: "Rate limit exceeded" } }
544 }))))
545 })
546
547 describe("createResponseStream", () => {
548 it.effect("emits response.completed before [DONE] in the same SSE chunk", () =>
549 Effect.gen(function*() {
550 const client = yield* OpenAiClient.OpenAiClient
551 const [, stream] = yield* client.createResponseStream({ model: "gpt-4o", input: "test" })
552 const events = yield* Stream.runCollect(stream)
553
554 assert.deepStrictEqual(events.map((event) => event.type), ["response.completed"])
555 }).pipe(Effect.provide(makeTestLayer(undefined, {
556 _tag: "Sse",
557 events: [{
558 type: "response.completed",
559 sequence_number: 1,
560 response: makeResponseBody({ status: "completed" })
561 }],
562 trailer: "data: [DONE]\n\n"
563 }))))
564
565 it.live("terminates an SSE stream at response.failed", () =>
566 Effect.gen(function*() {
567 const client = yield* OpenAiClient.OpenAiClient
568 const [, stream] = yield* client.createResponseStream({ model: "gpt-4o", input: "test" })
569 const result = yield* Stream.runCollect(stream).pipe(Effect.timeoutOption("100 millis"))
570
571 assert.strictEqual(result._tag, "Some")
572 }).pipe(Effect.provide(makeTestLayer(undefined, {
573 _tag: "Sse",
574 events: [{
575 type: "response.failed",
576 sequence_number: 1,
577 response: makeResponseBody({ status: "failed" })
578 }],
579 keepOpen: true
580 }))))
581
582 it.live("terminates a WebSocket stream at response.failed", () =>
583 Effect.gen(function*() {
584 const server = yield* Effect.acquireRelease(
585 Effect.sync(() => new WS("wss://api.openai.com/v1/responses", { jsonProtocol: true })),
586 (server) => Effect.sync(() => server.close())
587 )
588 const event = {
589 type: "response.failed",
590 sequence_number: 1,
591 response: makeResponseBody({ status: "failed" })
592 }
593 const result = yield* OpenAiClient.withWebSocketMode(
594 Effect.gen(function*() {
595 const client = yield* OpenAiClient.OpenAiClient
596 const [, stream] = yield* client.createResponseStream({ model: "gpt-4o", input: "test" })
597 const [events] = yield* Effect.all([
598 Stream.runCollect(stream),
599 Effect.promise(() => server.nextMessage).pipe(
600 Effect.tap(() => Effect.sync(() => server.send(event)))
601 )
602 ], { concurrency: "unbounded" })
603 return events
604 })
605 ).pipe(
606 Effect.provide(makeTestLayer()),
607 Effect.provideService(Socket.WebSocketConstructor, (url) => new globalThis.WebSocket(url)),
608 Effect.timeoutOption("1 second")
609 )
610
611 assert.strictEqual(result._tag, "Some")
612 }))
613
614 it.live("replaces the WebSocket after non-retryable error events", () =>
615 Effect.gen(function*() {
616 const server = yield* Effect.acquireRelease(
617 Effect.sync(() => new WS("wss://socket-errors.test/v1/responses", { jsonProtocol: true })),
618 (server) => Effect.sync(() => server.close())
619 )
620 let connections = 0
621
622 yield* OpenAiClient.withWebSocketMode(
623 Effect.gen(function*() {
624 const client = yield* OpenAiClient.OpenAiClient
625 const [, failedStream] = yield* client.createResponseStream({ model: "gpt-4o", input: "first" })
626 yield* Effect.all([
627 Stream.runDrain(failedStream).pipe(Effect.flip),
628 nextWebSocketCreate(server).pipe(
629 Effect.tap(() =>
630 Effect.sync(() =>
631 server.send({
632 type: "error",
633 code: "invalid_request_error",
634 message: "bad",
635 param: null
636 })
637 )
638 )
639 )
640 ], { concurrency: "unbounded" })
641
642 const [, secondFailedStream] = yield* client.createResponseStream({ model: "gpt-4o", input: "second" })
643 yield* Effect.all([
644 Stream.runDrain(secondFailedStream).pipe(Effect.flip),
645 nextWebSocketCreate(server).pipe(
646 Effect.tap(() =>
647 Effect.sync(() =>
648 server.send({
649 error: {
650 message: "gRPC error: permission denied",
651 type: "api_error"
652 }
653 })
654 )
655 )
656 )
657 ], { concurrency: "unbounded" })
658
659 const [, thirdFailedStream] = yield* client.createResponseStream({ model: "gpt-4o", input: "third" })
660 const [error] = yield* Effect.all([
661 Stream.runDrain(thirdFailedStream).pipe(Effect.flip),
662 nextWebSocketCreate(server).pipe(
663 Effect.tap(() =>
664 Effect.sync(() =>
665 server.send({
666 error: {
667 message: "bad request",
668 type: "invalid_request_error"
669 }
670 })
671 )
672 )
673 )
674 ], { concurrency: "unbounded" })
675 assert.strictEqual(error.reason._tag, "InvalidRequestError")
676
677 const [, nextStream] = yield* client.createResponseStream({ model: "gpt-4o", input: "fourth" })
678 yield* Effect.all([
679 Stream.runDrain(nextStream),
680 nextWebSocketCreate(server).pipe(
681 Effect.tap(() => Effect.sync(() => sendWebSocketCompleted(server, "resp_4", "msg_4", "ok")))
682 )
683 ], { concurrency: "unbounded" })
684 })
685 ).pipe(
686 Effect.provide(OpenAiClient.layer({
687 apiKey: Redacted.make("sk-test"),
688 apiUrl: "https://socket-errors.test/v1"
689 })),
690 Effect.provideService(Socket.WebSocketConstructor, (url) => {
691 connections++
692 return new globalThis.WebSocket(url)
693 }),
694 Effect.provideService(HttpClient.HttpClient, HttpClient.make(() => Effect.die("unexpected http"))),
695 Effect.timeout("5 seconds")
696 )
697
698 assert.strictEqual(connections, 4)
699 }))
700
701 it.live("retries an untagged xAI response-not-found error with the full prompt", () =>
702 Effect.gen(function*() {
703 const server = yield* Effect.acquireRelease(
704 Effect.sync(() => new WS("wss://previous-response.test/v1/responses", { jsonProtocol: true })),
705 (server) => Effect.sync(() => server.close())
706 )
707
708 const drive = Effect.gen(function*() {
709 const chat = yield* Chat.empty
710 yield* chat.streamText({ prompt: "hello" }).pipe(Stream.runDrain)
711 yield* chat.streamText({ prompt: "again" }).pipe(Stream.runDrain)
712 yield* chat.streamText({ prompt: "later" }).pipe(Stream.runDrain)
713 }).pipe(
714 OpenAiClient.withWebSocketMode,
715 Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", { store: true })),
716 Effect.provide(OpenAiClient.layer({
717 apiKey: Redacted.make("sk-test"),
718 apiUrl: "https://previous-response.test/v1"
719 })),
720 Effect.provideService(Socket.WebSocketConstructor, (url) => new globalThis.WebSocket(url)),
721 Effect.provideService(HttpClient.HttpClient, HttpClient.make(() => Effect.die("unexpected http")))
722 )
723
724 const respond = Effect.gen(function*() {
725 const first = yield* nextWebSocketCreate(server)
726 assert.isUndefined(first.previous_response_id)
727 assert.deepStrictEqual(first.input, [webSocketUserInput("hello")])
728 sendWebSocketCompleted(server, "resp_1", "msg_1", "ok")
729
730 const incremental = yield* nextWebSocketCreate(server)
731 assert.strictEqual(incremental.previous_response_id, "resp_1")
732 assert.deepStrictEqual(incremental.input, [webSocketUserInput("again")])
733 server.send({
734 error: {
735 message: "gRPC error: Response with id=resp_1 not found",
736 type: "api_error"
737 }
738 })
739
740 const retried = yield* nextWebSocketCreate(server)
741 assert.isUndefined(retried.previous_response_id)
742 assert.deepStrictEqual(retried.input, [
743 webSocketUserInput("hello"),
744 webSocketAssistantInput("msg_1", "ok"),
745 webSocketUserInput("again")
746 ])
747 sendWebSocketCompleted(server, "resp_2", "msg_2", "retried")
748
749 const later = yield* nextWebSocketCreate(server)
750 assert.strictEqual(later.previous_response_id, "resp_2")
751 assert.deepStrictEqual(later.input, [webSocketUserInput("later")])
752 sendWebSocketCompleted(server, "resp_3", "msg_3", "later")
753 })
754
755 yield* Effect.all([drive, respond], { concurrency: "unbounded" }).pipe(
756 Effect.timeout("5 seconds")
757 )
758 }))
759
760 it.live("round-trips streamed encrypted reasoning in a full-prompt retry", () =>
761 Effect.gen(function*() {
762 const server = yield* Effect.acquireRelease(
763 Effect.sync(() => new WS("wss://reasoning-recovery.test/v1/responses", { jsonProtocol: true })),
764 (server) => Effect.sync(() => server.close())
765 )
766 const requests: Array<WebSocketResponseCreate> = []
767
768 const drive = Effect.gen(function*() {
769 const chat = yield* Chat.empty
770 yield* chat.streamText({ prompt: "think" }).pipe(Stream.runDrain)
771 yield* chat.streamText({ prompt: "continue" }).pipe(Stream.runDrain)
772 }).pipe(
773 OpenAiClient.withWebSocketMode,
774 Effect.provide(OpenAiLanguageModel.model("o3-mini", { store: true })),
775 Effect.provide(OpenAiClient.layer({
776 apiKey: Redacted.make("sk-test"),
777 apiUrl: "https://reasoning-recovery.test/v1"
778 })),
779 Effect.provideService(Socket.WebSocketConstructor, (url) => new globalThis.WebSocket(url)),
780 Effect.provideService(HttpClient.HttpClient, HttpClient.make(() => Effect.die("unexpected http")))
781 )
782
783 const respond = Effect.gen(function*() {
784 requests.push(yield* nextWebSocketCreate(server))
785 sendWebSocketReasoningCompleted(server, "resp_1", "rs_1", "thinking", "encrypted-reasoning")
786
787 requests.push(yield* nextWebSocketCreate(server))
788 server.send({
789 error: {
790 message: "gRPC error: Response with id=resp_1 not found",
791 type: "api_error"
792 }
793 })
794
795 requests.push(yield* nextWebSocketCreate(server))
796 sendWebSocketCompleted(server, "resp_2", "msg_2", "done")
797 })
798
799 yield* Effect.all([drive, respond], { concurrency: "unbounded" }).pipe(
800 Effect.timeout("5 seconds")
801 )
802
803 assert.deepStrictEqual({
804 include: requests[0]?.include,
805 reasoning: requests[2]?.input.find((item) => item.type === "reasoning")
806 }, {
807 include: ["reasoning.encrypted_content"],
808 reasoning: {
809 type: "reasoning",
810 id: "rs_1",
811 summary: [{ type: "summary_text", text: "thinking" }],
812 encrypted_content: "encrypted-reasoning"
813 }
814 })
815 }))
816
817 it.effect("accepts keepalive stream events", () =>
818 Effect.gen(function*() {
819 const client = yield* OpenAiClient.OpenAiClient
820 const [_, stream] = yield* client.createResponseStream({
821 model: "gpt-4o",
822 input: "test"
823 })
824
825 const events = yield* Stream.runCollect(stream)
826 const parts = globalThis.Array.from(events)
827
828 assert.strictEqual(parts.length, 3)
829 const keepAlive = parts[1]
830 assert.strictEqual(keepAlive.type, "keepalive")
831 if (keepAlive.type === "keepalive" && "sequence_number" in keepAlive) {
832 assert.strictEqual(keepAlive.sequence_number, 2)
833 }
834
835 const completed = parts[2]
836 assert.isTrue(typeof completed === "object" && completed !== null && "type" in completed)
837 if (typeof completed === "object" && completed !== null && "type" in completed) {
838 assert.strictEqual(completed.type, "response.completed")
839 if (
840 completed.type === "response.completed" &&
841 "response" in completed &&
842 typeof completed.response === "object" &&
843 completed.response !== null &&
844 "id" in completed.response
845 ) {
846 assert.strictEqual(completed.response.id, "resp_stream")
847 }
848 }
849 }).pipe(Effect.provide(makeTestLayer(undefined, {
850 _tag: "Sse",
851 events: [
852 {
853 type: "response.created",
854 sequence_number: 1,
855 response: makeResponseBody({ id: "resp_stream", status: "in_progress" })
856 },
857 {
858 type: "keepalive",
859 sequence_number: 2
860 },
861 {
862 type: "response.completed",
863 sequence_number: 3,
864 response: makeResponseBody({ id: "resp_stream" })
865 }
866 ]
867 }))))
868
869 it.effect("accepts response stream events without sequence numbers", () =>
870 Effect.gen(function*() {
871 const client = yield* OpenAiClient.OpenAiClient
872 const [, stream] = yield* client.createResponseStream({
873 model: "gpt-4o",
874 input: "test"
875 })
876
877 const events = yield* Stream.runCollect(stream)
878 const decoded = globalThis.Array.from(events)
879
880 assert.deepStrictEqual(decoded.map((event) => event.type), [
881 "response.created",
882 "response.output_item.added",
883 "response.content_part.added",
884 "response.output_text.delta",
885 "response.reasoning_text.delta",
886 "response.reasoning_text.done",
887 "response.content_part.done",
888 "response.completed"
889 ])
890 assert.deepStrictEqual(decoded[0], {
891 type: "response.created",
892 response: {
893 id: "resp_test123",
894 object: "response",
895 model: "gpt-4o-mini",
896 created_at: 1,
897 output: [],
898 error: null,
899 incomplete_details: null
900 }
901 })
902 assert.deepStrictEqual(decoded[3], {
903 type: "response.output_text.delta",
904 output_index: 0,
905 item_id: "msg_123",
906 content_index: 0,
907 delta: "hello",
908 sequence_number: 4
909 })
910 assert.deepStrictEqual([decoded[2], decoded[4], decoded[5], decoded[6]], [
911 {
912 type: "response.content_part.added",
913 output_index: 0,
914 item_id: "rs_tmp_123",
915 content_index: 0,
916 part: { type: "reasoning_text", text: "" }
917 },
918 {
919 type: "response.reasoning_text.delta",
920 output_index: 0,
921 item_id: "rs_tmp_123",
922 content_index: 0,
923 delta: "thinking..."
924 },
925 {
926 type: "response.reasoning_text.done",
927 output_index: 0,
928 item_id: "rs_tmp_123",
929 content_index: 0,
930 text: "thinking..."
931 },
932 {
933 type: "response.content_part.done",
934 output_index: 0,
935 item_id: "rs_tmp_123",
936 content_index: 0,
937 part: { type: "reasoning_text", text: "thinking..." }
938 }
939 ])
940 }).pipe(Effect.provide(makeTestLayer(undefined, {
941 _tag: "Sse",
942 events: [
943 {
944 type: "response.created",
945 response: makeResponseBody({ status: "in_progress" })
946 },
947 {
948 type: "response.output_item.added",
949 output_index: 0,
950 item: {
951 id: "msg_123",
952 type: "message",
953 role: "assistant",
954 status: "in_progress",
955 content: []
956 }
957 },
958 {
959 type: "response.content_part.added",
960 output_index: 0,
961 item_id: "rs_tmp_123",
962 content_index: 0,
963 part: { type: "reasoning_text", text: "" }
964 },
965 {
966 type: "response.output_text.delta",
967 output_index: 0,
968 item_id: "msg_123",
969 content_index: 0,
970 delta: "hello",
971 sequence_number: 4
972 },
973 {
974 type: "response.reasoning_text.delta",
975 output_index: 0,
976 item_id: "rs_tmp_123",
977 content_index: 0,
978 delta: "thinking..."
979 },
980 {
981 type: "response.reasoning_text.done",
982 output_index: 0,
983 item_id: "rs_tmp_123",
984 content_index: 0,
985 text: "thinking..."
986 },
987 {
988 type: "response.content_part.done",
989 output_index: 0,
990 item_id: "rs_tmp_123",
991 content_index: 0,
992 part: { type: "reasoning_text", text: "thinking..." }
993 },
994 {
995 type: "response.completed",
996 response: makeResponseBody()
997 }
998 ]
999 }))))
1000
1001 it.effect("maps a malformed stream event to a non-retryable InvalidResponseError", () =>
1002 Effect.gen(function*() {
1003 const client = yield* OpenAiClient.OpenAiClient
1004 const result = yield* client.createResponseStream({
1005 model: "gpt-4o",
1006 input: "test"
1007 }).pipe(
1008 Effect.andThen(([_, stream]) => Stream.runDrain(stream)),
1009 Effect.flip
1010 )
1011
1012 assert.strictEqual(result.reason._tag, "InvalidResponseError")
1013 assert.isFalse(result.isRetryable)
1014 }).pipe(Effect.provide(makeTestLayer(undefined, {
1015 _tag: "Sse",
1016 events: [
1017 {
1018 type: "response.output_text.delta",
1019 output_index: "zero",
1020 item_id: "msg_123",
1021 content_index: 0,
1022 delta: "hello"
1023 }
1024 ]
1025 }))))
1026
1027 it.effect("maps an oversized SSE event to a non-retryable InvalidResponseError", () =>
1028 Effect.gen(function*() {
1029 const client = yield* OpenAiClient.OpenAiClient
1030 const result = yield* client.createResponseStream({
1031 model: "gpt-4o",
1032 input: "test"
1033 }).pipe(
1034 Effect.andThen(([_, stream]) => Stream.runDrain(stream)),
1035 Effect.flip
1036 )
1037
1038 assert.strictEqual(result.reason._tag, "InvalidResponseError")
1039 assert.isFalse(result.isRetryable)
1040 }).pipe(Effect.provide(makeTestLayer(undefined, {
1041 _tag: "Sse",
1042 events: [],
1043 // Exceed the default 10 MiB SSE limit without completing an event.
1044 trailer: `data: ${"x".repeat(10 * 1024 * 1024 + 1)}`
1045 }))))
1046
1047 it.effect("maps HTTP error before stream starts", () =>
1048 Effect.gen(function*() {
1049 const client = yield* OpenAiClient.OpenAiClient
1050 const result = yield* client.createResponseStream({
1051 model: "gpt-4o",
1052 input: "test"
1053 }).pipe(
1054 Effect.andThen(([_, stream]) => Stream.runDrain(stream)),
1055 Effect.flip
1056 )
1057
1058 assert.strictEqual(result._tag, "AiError")
1059 assert.strictEqual(result.reason._tag, "InternalProviderError")
1060 }).pipe(Effect.provide(makeTestLayer(undefined, {
1061 _tag: "Json",
1062 status: 500,
1063 body: { error: { message: "Server error" } }
1064 }))))
1065 })
1066 })
1067
1068 type WebSocketResponseCreate = {
1069 readonly type: "response.create"
1070 readonly previous_response_id?: string | undefined
1071 readonly include?: ReadonlyArray<string> | undefined
1072 readonly input: ReadonlyArray<Record<string, unknown>>
1073 }
1074
1075 const nextWebSocketCreate = (server: WS) =>
1076 Effect.promise(() => server.nextMessage).pipe(
1077 Effect.map((message) => message as WebSocketResponseCreate)
1078 )
1079
1080 const webSocketUserInput = (text: string) => ({
1081 role: "user",
1082 content: [{ type: "input_text", text }]
1083 })
1084
1085 const webSocketAssistantInput = (id: string, text: string) => ({
1086 id,
1087 type: "message",
1088 role: "assistant",
1089 status: "completed",
1090 content: [{
1091 type: "output_text",
1092 text,
1093 annotations: [],
1094 logprobs: []
1095 }]
1096 })
1097
1098 const sendWebSocketCompleted = (server: WS, id: string, itemId: string, text: string) => {
1099 const response = {
1100 id,
1101 object: "response",
1102 model: "gpt-4o-mini",
1103 created_at: 1,
1104 output: [],
1105 error: null,
1106 incomplete_details: null
1107 }
1108 const events = [
1109 { type: "response.created", response },
1110 {
1111 type: "response.output_item.added",
1112 output_index: 0,
1113 item: {
1114 id: itemId,
1115 type: "message",
1116 role: "assistant",
1117 status: "in_progress",
1118 content: []
1119 }
1120 },
1121 {
1122 type: "response.output_text.delta",
1123 item_id: itemId,
1124 output_index: 0,
1125 content_index: 0,
1126 delta: text
1127 },
1128 {
1129 type: "response.output_item.done",
1130 output_index: 0,
1131 item: {
1132 id: itemId,
1133 type: "message",
1134 role: "assistant",
1135 status: "completed",
1136 content: [{ type: "output_text", text, annotations: [] }]
1137 }
1138 },
1139 { type: "response.completed", response }
1140 ]
1141 for (const event of events) {
1142 server.send(event)
1143 }
1144 }
1145
1146 const sendWebSocketReasoningCompleted = (
1147 server: WS,
1148 id: string,
1149 itemId: string,
1150 summary: string,
1151 encryptedContent: string
1152 ) => {
1153 const response = {
1154 id,
1155 object: "response",
1156 model: "o3-mini",
1157 created_at: 1,
1158 output: [],
1159 error: null,
1160 incomplete_details: null
1161 }
1162 const events = [
1163 { type: "response.created", sequence_number: 1, response },
1164 {
1165 type: "response.output_item.added",
1166 sequence_number: 2,
1167 output_index: 0,
1168 item: { type: "reasoning", id: itemId, summary: [], encrypted_content: null }
1169 },
1170 {
1171 type: "response.reasoning_summary_part.added",
1172 sequence_number: 3,
1173 output_index: 0,
1174 item_id: itemId,
1175 summary_index: 0,
1176 part: { type: "summary_text", text: summary }
1177 },
1178 {
1179 type: "response.reasoning_summary_text.delta",
1180 sequence_number: 4,
1181 output_index: 0,
1182 item_id: itemId,
1183 summary_index: 0,
1184 delta: summary
1185 },
1186 {
1187 type: "response.reasoning_summary_part.done",
1188 sequence_number: 5,
1189 output_index: 0,
1190 item_id: itemId,
1191 summary_index: 0,
1192 part: { type: "summary_text", text: summary }
1193 },
1194 {
1195 type: "response.output_item.done",
1196 sequence_number: 6,
1197 output_index: 0,
1198 item: {
1199 type: "reasoning",
1200 id: itemId,
1201 summary: [{ type: "summary_text", text: summary }],
1202 encrypted_content: encryptedContent
1203 }
1204 },
1205 { type: "response.completed", sequence_number: 7, response }
1206 ]
1207 for (const event of events) {
1208 server.send(event)
1209 }
1210 }
1211
1212 type MockResponse =
1213 | {
1214 readonly _tag: "Json"
1215 readonly body: typeof Generated.Response.Encoded | {
1216 readonly error: {
1217 readonly message: string
1218 readonly type?: string
1219 readonly code?: string | null
1220 }
1221 } | {
1222 readonly error: string
1223 readonly code?: string
1224 }
1225 readonly status?: number | undefined
1226 readonly headers?: Record<string, string> | undefined
1227 }
1228 | {
1229 readonly _tag: "Sse"
1230 readonly events: ReadonlyArray<typeof OpenAiSchema.ResponseStreamEvent.Encoded>
1231 readonly trailer?: string | undefined
1232 readonly keepOpen?: boolean | undefined
1233 readonly status?: number | undefined
1234 readonly headers?: Record<string, string> | undefined
1235 }
1236
1237 class MockOpenAiResponse extends Context.Service<MockOpenAiResponse, {
1238 readonly response: MockResponse
1239 }>()("MockOpenAiResponse") {}
1240
1241 class MockHttpClient extends Context.Service<MockHttpClient, {
1242 readonly requests: Effect.Effect<ReadonlyArray<HttpClientRequest.HttpClientRequest>>
1243 }>()("MockHttpClient") {
1244 static requests = MockHttpClient.use((client) => client.requests)
1245 }
1246
1247 const makeHttpClientContext = Effect.gen(function*() {
1248 const capturedRequests: Array<HttpClientRequest.HttpClientRequest> = []
1249 const mock = yield* MockOpenAiResponse
1250
1251 const httpClient = HttpClient.makeWith(
1252 Effect.fnUntraced(function*(requestEffect) {
1253 const request = yield* requestEffect
1254 capturedRequests.push(request)
1255 return makeResponse(request, mock.response)
1256 }),
1257 Effect.succeed as HttpClient.HttpClient.Preprocess<HttpClientError.HttpClientError, never>
1258 )
1259
1260 const mockHttpClient: MockHttpClient["Service"] = {
1261 requests: Effect.sync(() => capturedRequests)
1262 }
1263
1264 return Context.make(HttpClient.HttpClient, httpClient).pipe(
1265 Context.add(MockHttpClient, mockHttpClient)
1266 )
1267 })
1268
1269 const HttpClientLayer = Layer.effectContext(makeHttpClientContext)
1270
1271 const defaultResponse: MockResponse = {
1272 _tag: "Json",
1273 body: makeResponseBody()
1274 }
1275
1276 const makeTestLayer = (
1277 options: OpenAiClient.Options = { apiKey: Redacted.make("test-key") },
1278 response: MockResponse = defaultResponse
1279 ) =>
1280 OpenAiClient.layer(options).pipe(
1281 Layer.provideMerge(HttpClientLayer),
1282 Layer.provide(Layer.succeed(MockOpenAiResponse, { response }))
1283 )
1284
1285 const makeGeneratedTestLayer = (
1286 options: OpenAiClientGenerated.Options,
1287 response: MockResponse = defaultResponse
1288 ) =>
1289 OpenAiClientGenerated.layer(options).pipe(
1290 Layer.provideMerge(HttpClientLayer),
1291 Layer.provide(Layer.succeed(MockOpenAiResponse, { response }))
1292 )
1293
1294 const makeConfigTestLayer = (configProvider: ConfigProvider.ConfigProvider) =>
1295 OpenAiClient.layerConfig({
1296 apiKey: Config.Redacted("MY_API_KEY"),
1297 apiUrl: Config.String("MY_API_URL")
1298 }).pipe(
1299 Layer.provideMerge(HttpClientLayer),
1300 Layer.provide(Layer.succeed(MockOpenAiResponse, { response: defaultResponse })),
1301 Layer.provide(ConfigProvider.layer(configProvider))
1302 )
1303
1304 const makeTransportErrorHttpClient = (
1305 failures: Array<HttpClientError.HttpClientError> = [],
1306 reason: { readonly cause?: unknown } = { cause: new Error("Connection refused") }
1307 ): HttpClient.HttpClient =>
1308 HttpClient.makeWith<HttpClientError.HttpClientError, never, HttpClientError.HttpClientError, never>(
1309 (requestEffect) =>
1310 Effect.flatMap(requestEffect, (request) => {
1311 const error = new HttpClientError.HttpClientError({
1312 reason: new HttpClientError.TransportError({ request, ...reason })
1313 })
1314 failures.push(error)
1315 return Effect.fail(error)
1316 }),
1317 Effect.succeed
1318 )
1319
1320 function makeResponseBody(
1321 overrides: Partial<typeof Generated.Response.Encoded> = {}
1322 ): typeof Generated.Response.Encoded {
1323 return {
1324 id: "resp_test123",
1325 object: "response",
1326 created_at: 1,
1327 model: "gpt-4o-mini",
1328 status: "completed",
1329 output: [],
1330 metadata: null,
1331 temperature: null,
1332 top_p: null,
1333 tools: [],
1334 tool_choice: "auto",
1335 error: null,
1336 incomplete_details: null,
1337 instructions: null,
1338 parallel_tool_calls: false,
1339 ...overrides
1340 }
1341 }
1342
1343 const makeResponse = (
1344 request: HttpClientRequest.HttpClientRequest,
1345 response: MockResponse
1346 ): HttpClientResponse.HttpClientResponse => {
1347 const contentType = response._tag === "Json"
1348 ? "application/json"
1349 : "text/event-stream"
1350 const body = response._tag === "Json"
1351 ? JSON.stringify(response.body)
1352 : response.events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join("") + (response.trailer ?? "")
1353
1354 const httpResponse = HttpClientResponse.fromWeb(
1355 request,
1356 new Response(body, {
1357 status: response.status ?? 200,
1358 headers: {
1359 "content-type": contentType,
1360 ...response.headers
1361 }
1362 })
1363 )
1364 if (response._tag !== "Sse" || response.keepOpen !== true) return httpResponse
1365
1366 const stream = Stream.concat(
1367 Stream.succeed(new TextEncoder().encode(body)),
1368 Stream.never
1369 )
1370 // `fromWeb` stores the ReadableStream internally, so a proxy is needed to replace it with a non-terminating test stream.
1371 return new Proxy(httpResponse, {
1372 get(target, property) {
1373 if (property === "stream") return stream
1374 const value = Reflect.get(target, property, target)
1375 return typeof value === "function" ? value.bind(target) : value
1376 }
1377 })
1378 }