@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 499 lines 14.8 KB
Raw
1 import { Generated, OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai"
2 import * as OpenAiSchema from "@effect/ai-openai/OpenAiSchema"
3 import { assert, describe, it } from "@effect/vitest"
4 import { Effect, Layer, Schema, Stream } from "effect"
5 import { LanguageModel } from "effect/ai"
6 import * as Sse from "effect/encoding/Sse"
7 import { HttpClientRequest, HttpClientResponse } from "effect/http"
8
9 const makeResponse = (overrides: Record<string, unknown> = {}) => ({
10 id: "resp_123",
11 object: "response",
12 model: "gpt-4o-mini",
13 status: "completed",
14 created_at: 1,
15 output: [],
16 ...overrides
17 })
18
19 describe("OpenAiSchema", () => {
20 describe("web search sources", () => {
21 it("preserves API sources in response history", () => {
22 const item = {
23 type: "web_search_call",
24 id: "ws_123",
25 status: "completed",
26 action: { type: "search", sources: [{ type: "api", name: "oai-weather" }] }
27 } as const
28
29 assert.deepStrictEqual(Schema.decodeUnknownSync(Generated.InputItem)(item), item)
30 })
31
32 it.each([
33 { type: "url" },
34 { type: "api" },
35 { type: "api", name: null },
36 { type: "unknown", name: "oai-weather" }
37 ])("rejects malformed search sources: %j", (source) => {
38 const item = {
39 type: "web_search_call",
40 id: "ws_123",
41 status: "completed",
42 action: { type: "search", sources: [source] }
43 }
44
45 assert.throws(() => Schema.decodeUnknownSync(Generated.WebSearchToolCall)(item))
46 assert.throws(() => Schema.decodeUnknownSync(Generated.InputItem)(item))
47 })
48 })
49
50 it("accepts max reasoning effort", () => {
51 const decoded = Schema.decodeUnknownSync(OpenAiSchema.CreateResponse)({
52 reasoning: { effort: "max" }
53 })
54
55 assert.strictEqual(decoded.reasoning?.effort, "max")
56 })
57
58 it("accepts safety and prompt cache retention request options", () => {
59 const decoded = Schema.decodeUnknownSync(OpenAiSchema.CreateResponse)({
60 safety_identifier: "user-hash-123",
61 prompt_cache_retention: "24h"
62 })
63
64 assert.deepStrictEqual(decoded, {
65 safety_identifier: "user-hash-123",
66 prompt_cache_retention: "24h"
67 })
68 })
69
70 it("decodes a representative response payload", () => {
71 const decoded = Schema.decodeUnknownSync(OpenAiSchema.Response)({
72 ...makeResponse(),
73 output: [
74 {
75 id: "msg_1",
76 type: "message",
77 role: "assistant",
78 status: "completed",
79 content: [
80 {
81 type: "output_text",
82 text: "hello",
83 annotations: [
84 {
85 type: "url_citation",
86 url: "https://example.com",
87 start_index: 0,
88 end_index: 5,
89 title: "example"
90 }
91 ]
92 },
93 {
94 type: "refusal",
95 refusal: "cannot comply"
96 }
97 ]
98 },
99 {
100 id: "fc_1",
101 type: "function_call",
102 call_id: "call_1",
103 name: "lookup",
104 arguments: "{}",
105 status: "completed"
106 },
107 {
108 id: "reasoning_1",
109 type: "reasoning",
110 summary: [
111 {
112 type: "summary_text",
113 text: "thinking"
114 }
115 ]
116 }
117 ],
118 usage: {
119 input_tokens: 10,
120 output_tokens: 20,
121 total_tokens: 30
122 }
123 })
124
125 assert.strictEqual(decoded.id, "resp_123")
126 assert.strictEqual(decoded.output.length, 3)
127 assert.strictEqual(decoded.output[0].type, "message")
128 if (decoded.output[0].type === "message") {
129 assert.strictEqual(decoded.output[0].content[0].type, "output_text")
130 }
131 })
132
133 it("decodes image generation lifecycle statuses", () => {
134 for (const status of ["generating", "failed"]) {
135 const decoded = Schema.decodeUnknownSync(OpenAiSchema.Response)({
136 ...makeResponse(),
137 output: [{
138 id: "image_1",
139 type: "image_generation_call",
140 status,
141 result: null
142 }]
143 })
144
145 assert.strictEqual(decoded.output[0].type, "image_generation_call")
146 if (decoded.output[0].type === "image_generation_call") {
147 assert.strictEqual(decoded.output[0].status, status)
148 }
149 }
150 })
151
152 it("decodes required stream events", () => {
153 const response = makeResponse({ status: "in_progress" })
154 const applyPatchItem = {
155 id: "ap_1",
156 type: "apply_patch_call",
157 call_id: "call_ap",
158 operation: {
159 type: "update_file",
160 path: "README.md",
161 diff: "@@"
162 }
163 }
164
165 const events = [
166 { type: "response.created", sequence_number: 1, response },
167 {
168 type: "response.completed",
169 sequence_number: 2,
170 response: makeResponse()
171 },
172 { type: "response.incomplete", sequence_number: 3, response: makeResponse({ status: "incomplete" }) },
173 { type: "response.failed", sequence_number: 4, response: makeResponse({ status: "failed" }) },
174 { type: "response.output_item.added", sequence_number: 5, output_index: 0, item: applyPatchItem },
175 { type: "response.output_item.done", sequence_number: 6, output_index: 0, item: applyPatchItem },
176 {
177 type: "response.output_text.delta",
178 sequence_number: 7,
179 item_id: "msg_1",
180 output_index: 0,
181 content_index: 0,
182 delta: "hel"
183 },
184 {
185 type: "response.output_text.annotation.added",
186 sequence_number: 8,
187 item_id: "msg_1",
188 output_index: 0,
189 content_index: 0,
190 annotation_index: 0,
191 annotation: {
192 type: "file_path",
193 file_id: "file_1",
194 index: 0
195 }
196 },
197 {
198 type: "response.reasoning_summary_part.added",
199 sequence_number: 9,
200 item_id: "reasoning_1",
201 output_index: 1,
202 summary_index: 0,
203 part: { type: "summary_text", text: "thinking" }
204 },
205 {
206 type: "response.reasoning_summary_part.done",
207 sequence_number: 10,
208 item_id: "reasoning_1",
209 output_index: 1,
210 summary_index: 0,
211 part: { type: "summary_text", text: "thinking" }
212 },
213 {
214 type: "response.reasoning_summary_text.delta",
215 sequence_number: 11,
216 item_id: "reasoning_1",
217 output_index: 1,
218 summary_index: 0,
219 delta: "..."
220 },
221 {
222 type: "response.function_call_arguments.delta",
223 sequence_number: 12,
224 item_id: "fc_1",
225 output_index: 2,
226 delta: "{"
227 },
228 {
229 type: "response.function_call_arguments.done",
230 sequence_number: 13,
231 item_id: "fc_1",
232 output_index: 2,
233 arguments: "{}"
234 },
235 {
236 type: "response.code_interpreter_call_code.delta",
237 sequence_number: 14,
238 item_id: "code_1",
239 output_index: 3,
240 delta: "print"
241 },
242 {
243 type: "response.code_interpreter_call_code.done",
244 sequence_number: 15,
245 item_id: "code_1",
246 output_index: 3,
247 code: "print('ok')"
248 },
249 {
250 type: "response.apply_patch_call_operation_diff.delta",
251 sequence_number: 16,
252 item_id: "ap_1",
253 output_index: 4,
254 delta: "@@"
255 },
256 {
257 type: "response.apply_patch_call_operation_diff.done",
258 sequence_number: 17,
259 item_id: "ap_1",
260 output_index: 4,
261 delta: "@@"
262 },
263 {
264 type: "response.image_generation_call.partial_image",
265 sequence_number: 18,
266 item_id: "img_1",
267 output_index: 5,
268 partial_image_b64: "AQID"
269 }
270 ]
271
272 for (const event of events) {
273 const decoded = Schema.decodeUnknownSync(OpenAiSchema.ResponseStreamEvent)(event)
274 assert.strictEqual(decoded.type, event.type)
275 }
276 })
277
278 it.effect("keeps keepalive and unknown events tolerant in SSE decoding", () =>
279 Effect.gen(function*() {
280 const sseBody = [
281 {
282 type: "response.created",
283 sequence_number: 1,
284 response: makeResponse({ status: "in_progress" })
285 },
286 {
287 type: "keepalive",
288 sequence_number: 2,
289 heartbeat: true
290 },
291 {
292 type: "provider.future_event",
293 sequence_number: 3,
294 nested: { ok: true }
295 },
296 {
297 type: "response.completed",
298 sequence_number: 4,
299 response: makeResponse({ status: "completed" })
300 }
301 ].map((event) => `data: ${JSON.stringify(event)}\n\n`).join("")
302
303 const events = yield* Stream.fromIterable([sseBody]).pipe(
304 Stream.pipeThroughChannel(Sse.decodeDataSchema(OpenAiSchema.ResponseStreamEvent)),
305 Stream.map((event) => event.data),
306 Stream.runCollect
307 )
308
309 const decoded = globalThis.Array.from(events)
310 assert.strictEqual(decoded.length, 4)
311 assert.strictEqual(decoded[1].type, "keepalive")
312 assert.strictEqual(decoded[2].type, "provider.future_event")
313 if (decoded[1].type === "keepalive") {
314 assert.strictEqual(decoded[1].sequence_number, 2)
315 }
316 }))
317
318 it.effect("does not silently decode malformed known events as unknown", () =>
319 Effect.gen(function*() {
320 const malformed = yield* Schema.decodeUnknownEffect(OpenAiSchema.ResponseStreamEvent)({
321 type: "response.completed",
322 sequence_number: 1
323 }).pipe(Effect.flip)
324
325 assert.isDefined(malformed)
326 }))
327
328 it("decodes the error event whether the payload is flat or nested under `error`", () => {
329 const flat = Schema.decodeUnknownSync(OpenAiSchema.ResponseStreamEvent)({
330 type: "error",
331 code: "ERR",
332 message: "boom",
333 param: null,
334 sequence_number: 1
335 })
336 assert.deepStrictEqual(flat, {
337 type: "error",
338 code: "ERR",
339 message: "boom",
340 param: null,
341 sequence_number: 1
342 })
343
344 const nested = Schema.decodeUnknownSync(OpenAiSchema.ResponseStreamEvent)({
345 type: "error",
346 error: {
347 type: "insufficient_quota",
348 code: "credit_balance_exhausted",
349 message: "You have no credits remaining.",
350 param: null
351 },
352 sequence_number: 2
353 })
354 assert.deepStrictEqual(nested, {
355 type: "error",
356 code: "credit_balance_exhausted",
357 message: "You have no credits remaining.",
358 param: null,
359 sequence_number: 2
360 })
361
362 const nestedWithStatus = Schema.decodeUnknownSync(OpenAiSchema.ResponseStreamEvent)({
363 type: "error",
364 error: {
365 code: "rate_limited",
366 message: "Too many requests.",
367 param: null
368 },
369 sequence_number: 3,
370 status: 429
371 })
372 assert.deepStrictEqual(nestedWithStatus, {
373 type: "error",
374 code: "rate_limited",
375 message: "Too many requests.",
376 param: null,
377 sequence_number: 3,
378 status: 429
379 })
380 })
381
382 it.effect("rejects error events missing spec-required fields", () =>
383 Effect.gen(function*() {
384 const malformed = [
385 { type: "error" },
386 { type: "error", error: {}, sequence_number: 3 },
387 { type: "error", error: { code: "x" }, sequence_number: 3 }
388 ]
389 for (const event of malformed) {
390 const failure = yield* Schema.decodeUnknownEffect(OpenAiSchema.ResponseStreamEvent)(event).pipe(Effect.flip)
391 assert.isDefined(failure)
392 }
393 }))
394
395 it.effect("surfaces nested error events in SSE decoding instead of aborting the stream", () =>
396 Effect.gen(function*() {
397 const sseBody = [
398 {
399 type: "response.created",
400 sequence_number: 1,
401 response: makeResponse({ status: "in_progress" })
402 },
403 {
404 type: "error",
405 error: {
406 type: "insufficient_quota",
407 code: "credit_balance_exhausted",
408 message: "You have no credits remaining.",
409 param: null
410 },
411 sequence_number: 2
412 }
413 ].map((event) => `data: ${JSON.stringify(event)}\n\n`).join("")
414
415 const events = yield* Stream.fromIterable([sseBody]).pipe(
416 Stream.pipeThroughChannel(Sse.decodeDataSchema(OpenAiSchema.ResponseStreamEvent)),
417 Stream.map((event) => event.data),
418 Stream.runCollect
419 )
420
421 const decoded = globalThis.Array.from(events)
422 assert.strictEqual(decoded.length, 2)
423 assert.deepStrictEqual(decoded[1], {
424 type: "error",
425 code: "credit_balance_exhausted",
426 message: "You have no credits remaining.",
427 param: null,
428 sequence_number: 2
429 })
430 }))
431
432 it("decodes embedding response variants (numeric + string/base64)", () => {
433 const numeric = Schema.decodeUnknownSync(OpenAiSchema.CreateEmbeddingResponse)({
434 object: "list",
435 model: "text-embedding-3-small",
436 data: [{ object: "embedding", index: 0, embedding: [0.1, 0.2] }],
437 usage: { prompt_tokens: 2, total_tokens: 2 }
438 })
439 const base64 = Schema.decodeUnknownSync(OpenAiSchema.CreateEmbeddingResponse)({
440 object: "list",
441 model: "text-embedding-3-small",
442 data: [{ object: "embedding", index: 0, embedding: "AQID" }],
443 usage: { prompt_tokens: 2, total_tokens: 2 }
444 })
445
446 assert.strictEqual(numeric.data[0].embedding[0], 0.1)
447 assert.strictEqual(base64.data[0].embedding, "AQID")
448 })
449
450 it.effect("exposes the response.failed error payload", () => {
451 const response = HttpClientResponse.fromWeb(
452 HttpClientRequest.get("https://api.openai.com/v1/responses"),
453 new Response()
454 )
455 const failed = Schema.decodeUnknownSync(OpenAiSchema.ResponseStreamEvent)({
456 type: "response.failed",
457 sequence_number: 1,
458 response: {
459 id: "resp_1",
460 object: "response",
461 created_at: 1,
462 model: "gpt-4o-mini",
463 status: "failed",
464 output: [],
465 error: { code: "server_error", message: "provider exploded" }
466 }
467 })
468 const client = Layer.succeed(
469 OpenAiClient.OpenAiClient,
470 OpenAiClient.OpenAiClient.of({
471 client: undefined as any,
472 createDecisions: () => Effect.die("unexpected"),
473 createResponse: () => Effect.die("unexpected"),
474 createResponseStream: () =>
475 Effect.succeed([
476 response,
477 Stream.make(failed)
478 ]),
479 createEmbedding: () => Effect.die("unexpected")
480 })
481 )
482
483 return LanguageModel.streamText({ prompt: "test" }).pipe(
484 Stream.runCollect,
485 Effect.tap((parts) =>
486 Effect.sync(() => {
487 const error = Array.from(parts).find((part) => part.type === "error")
488 const finish = Array.from(parts).find((part) => part.type === "finish")
489 assert.isDefined(error)
490 assert.deepStrictEqual(error.error, { code: "server_error", message: "provider exploded" })
491 assert.isDefined(finish)
492 assert.strictEqual(finish.reason, "error")
493 })
494 ),
495 Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
496 Effect.provide(client)
497 )
498 })
499 })