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

main
ts 330 lines 11.8 KB
Raw
1 import { OpenAiClient, OpenAiEmbeddingModel } from "@effect/ai-openai"
2 import { assert, describe, it } from "@effect/vitest"
3 import { Effect, Layer, Redacted } from "effect"
4 import { EmbeddingModel } from "effect/ai"
5 import { HttpClient, type HttpClientError, type HttpClientRequest, HttpClientResponse } from "effect/http"
6
7 describe("OpenAiEmbeddingModel", () => {
8 it.effect("model provides dimensions service", () =>
9 Effect.gen(function*() {
10 const dimensions = yield* EmbeddingModel.Dimensions
11 assert.strictEqual(dimensions, 1536)
12 }).pipe(
13 Effect.provide(OpenAiEmbeddingModel.model("text-embedding-3-small", { dimensions: 1536 })),
14 Effect.provideService(OpenAiClient.OpenAiClient, noopOpenAiClient)
15 ))
16
17 it.effect("reorders embeddings by provider index", () =>
18 Effect.gen(function*() {
19 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
20
21 const clientLayer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
22 Layer.provide(Layer.succeed(
23 HttpClient.HttpClient,
24 makeHttpClient((request) => {
25 capturedRequest = request
26 return Effect.succeed(jsonResponse(request, {
27 data: [
28 { index: 1, embedding: [20, 21], object: "embedding" },
29 { index: 0, embedding: [10, 11], object: "embedding" }
30 ],
31 model: "text-embedding-3-small",
32 object: "list",
33 usage: {
34 prompt_tokens: 7,
35 total_tokens: 7
36 }
37 }))
38 })
39 ))
40 )
41
42 const response = yield* Effect.gen(function*() {
43 const model = yield* EmbeddingModel.EmbeddingModel
44 return yield* model.embedMany(["first", "second"])
45 }).pipe(
46 Effect.provide(OpenAiEmbeddingModel.layer({ model: "text-embedding-3-small" })),
47 Effect.provide(clientLayer)
48 )
49
50 assert.deepStrictEqual(response.embeddings.map((embedding) => embedding.vector), [[10, 11], [20, 21]])
51 assert.strictEqual(response.usage.inputTokens, 7)
52
53 assert.isDefined(capturedRequest)
54 if (capturedRequest === undefined) {
55 return
56 }
57
58 const requestBody = yield* getRequestBody(capturedRequest)
59 assert.strictEqual(requestBody.model, "text-embedding-3-small")
60 assert.deepStrictEqual(requestBody.input, ["first", "second"])
61 }))
62
63 it.effect("merges config and applies withConfigOverride precedence", () =>
64 Effect.gen(function*() {
65 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined
66
67 const clientLayer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
68 Layer.provide(Layer.succeed(
69 HttpClient.HttpClient,
70 makeHttpClient((request) => {
71 capturedRequest = request
72 return Effect.succeed(jsonResponse(request, {
73 data: [{ index: 0, embedding: [1, 2, 3], object: "embedding" }],
74 model: "override-model",
75 object: "list",
76 usage: {
77 prompt_tokens: 3,
78 total_tokens: 3
79 }
80 }))
81 })
82 ))
83 )
84
85 yield* Effect.gen(function*() {
86 const model = yield* EmbeddingModel.EmbeddingModel
87 yield* model.embed("hello")
88 }).pipe(
89 OpenAiEmbeddingModel.withConfigOverride({
90 model: "override-model",
91 dimensions: 1024,
92 user: "request-user"
93 }),
94 Effect.provide(OpenAiEmbeddingModel.layer({
95 model: "base-model",
96 config: {
97 dimensions: 256,
98 user: "provider-user"
99 }
100 })),
101 Effect.provide(clientLayer)
102 )
103
104 assert.isDefined(capturedRequest)
105 if (capturedRequest === undefined) {
106 return
107 }
108
109 const requestBody = yield* getRequestBody(capturedRequest)
110 assert.strictEqual(requestBody.model, "override-model")
111 assert.strictEqual(requestBody.dimensions, 1024)
112 assert.strictEqual(requestBody.user, "request-user")
113 assert.deepStrictEqual(requestBody.input, ["hello"])
114 }))
115
116 it.effect("concurrent embed calls batch by their withConfigOverride", () =>
117 Effect.gen(function*() {
118 const requests: Array<ReadonlyArray<string>> = []
119 const clientLayer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
120 Layer.provide(Layer.succeed(
121 HttpClient.HttpClient,
122 makeHttpClient((request) =>
123 Effect.gen(function*() {
124 const body = yield* getRequestBody(request)
125 requests.push(body.input)
126 return jsonResponse(request, {
127 data: body.input.map((_: string, index: number) => ({
128 index,
129 embedding: Array.from({ length: body.dimensions }, () => 1),
130 object: "embedding"
131 })),
132 model: body.model,
133 object: "list",
134 usage: { prompt_tokens: 1, total_tokens: 1 }
135 })
136 })
137 )
138 ))
139 )
140
141 const responses = yield* Effect.gen(function*() {
142 const model = yield* EmbeddingModel.EmbeddingModel
143 return yield* Effect.all([
144 model.embed("a").pipe(OpenAiEmbeddingModel.withConfigOverride({ dimensions: 2 })),
145 model.embed("b").pipe(OpenAiEmbeddingModel.withConfigOverride({ dimensions: 3 })),
146 model.embed("c").pipe(OpenAiEmbeddingModel.withConfigOverride({ dimensions: 2 }))
147 ], { concurrency: "unbounded" })
148 }).pipe(
149 Effect.provide(OpenAiEmbeddingModel.layer({ model: "text-embedding-3-small" })),
150 Effect.provide(clientLayer)
151 )
152
153 assert.deepStrictEqual(responses.map((response) => response.vector), [[1, 1], [1, 1, 1], [1, 1]])
154 assert.deepStrictEqual(requests, [["a", "c"], ["b"]])
155 }))
156
157 it.effect("fails with InvalidOutputError when provider returns duplicate indices", () =>
158 Effect.gen(function*() {
159 const clientLayer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
160 Layer.provide(Layer.succeed(
161 HttpClient.HttpClient,
162 makeHttpClient((request) =>
163 Effect.succeed(jsonResponse(request, {
164 data: [
165 { index: 0, embedding: [1], object: "embedding" },
166 { index: 0, embedding: [2], object: "embedding" }
167 ],
168 model: "text-embedding-3-small",
169 object: "list",
170 usage: {
171 prompt_tokens: 2,
172 total_tokens: 2
173 }
174 }))
175 )
176 ))
177 )
178
179 const error = yield* Effect.gen(function*() {
180 const model = yield* EmbeddingModel.EmbeddingModel
181 return yield* model.embedMany(["a", "b"]).pipe(Effect.flip)
182 }).pipe(
183 Effect.provide(OpenAiEmbeddingModel.layer({ model: "text-embedding-3-small" })),
184 Effect.provide(clientLayer)
185 )
186
187 assert.strictEqual(error._tag, "AiError")
188 assert.strictEqual(error.reason._tag, "InvalidOutputError")
189 }))
190
191 it.effect("fails with InvalidOutputError when provider returns out-of-range indices", () =>
192 Effect.gen(function*() {
193 const clientLayer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
194 Layer.provide(Layer.succeed(
195 HttpClient.HttpClient,
196 makeHttpClient((request) =>
197 Effect.succeed(jsonResponse(request, {
198 data: [
199 { index: 0, embedding: [1], object: "embedding" },
200 { index: 2, embedding: [2], object: "embedding" }
201 ],
202 model: "text-embedding-3-small",
203 object: "list",
204 usage: {
205 prompt_tokens: 2,
206 total_tokens: 2
207 }
208 }))
209 )
210 ))
211 )
212
213 const error = yield* Effect.gen(function*() {
214 const model = yield* EmbeddingModel.EmbeddingModel
215 return yield* model.embedMany(["a", "b"]).pipe(Effect.flip)
216 }).pipe(
217 Effect.provide(OpenAiEmbeddingModel.layer({ model: "text-embedding-3-small" })),
218 Effect.provide(clientLayer)
219 )
220
221 assert.strictEqual(error._tag, "AiError")
222 assert.strictEqual(error.reason._tag, "InvalidOutputError")
223 }))
224
225 it.effect("fails with InvalidOutputError when provider returns wrong embedding count", () =>
226 Effect.gen(function*() {
227 const clientLayer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
228 Layer.provide(Layer.succeed(
229 HttpClient.HttpClient,
230 makeHttpClient((request) =>
231 Effect.succeed(jsonResponse(request, {
232 data: [{ index: 0, embedding: [1], object: "embedding" }],
233 model: "text-embedding-3-small",
234 object: "list",
235 usage: {
236 prompt_tokens: 1,
237 total_tokens: 1
238 }
239 }))
240 )
241 ))
242 )
243
244 const error = yield* Effect.gen(function*() {
245 const model = yield* EmbeddingModel.EmbeddingModel
246 return yield* model.embedMany(["a", "b"]).pipe(Effect.flip)
247 }).pipe(
248 Effect.provide(OpenAiEmbeddingModel.layer({ model: "text-embedding-3-small" })),
249 Effect.provide(clientLayer)
250 )
251
252 assert.strictEqual(error._tag, "AiError")
253 assert.strictEqual(error.reason._tag, "InvalidOutputError")
254 }))
255
256 it.effect("fails with InvalidOutputError when provider returns base64 embeddings", () =>
257 Effect.gen(function*() {
258 const clientLayer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
259 Layer.provide(Layer.succeed(
260 HttpClient.HttpClient,
261 makeHttpClient((request) =>
262 Effect.succeed(jsonResponse(request, {
263 data: [{ index: 0, embedding: "AQID", object: "embedding" }],
264 model: "text-embedding-3-small",
265 object: "list",
266 usage: {
267 prompt_tokens: 1,
268 total_tokens: 1
269 }
270 }))
271 )
272 ))
273 )
274
275 const error = yield* Effect.gen(function*() {
276 const model = yield* EmbeddingModel.EmbeddingModel
277 return yield* model.embed("a").pipe(Effect.flip)
278 }).pipe(
279 Effect.provide(OpenAiEmbeddingModel.layer({ model: "text-embedding-3-small" })),
280 Effect.provide(clientLayer)
281 )
282
283 assert.strictEqual(error._tag, "AiError")
284 assert.strictEqual(error.reason._tag, "InvalidOutputError")
285 }))
286 })
287
288 const makeHttpClient = (
289 handler: (
290 request: HttpClientRequest.HttpClientRequest
291 ) => Effect.Effect<HttpClientResponse.HttpClientResponse, HttpClientError.HttpClientError>
292 ) =>
293 HttpClient.makeWith(
294 Effect.fnUntraced(function*(requestEffect) {
295 const request = yield* requestEffect
296 return yield* handler(request)
297 }),
298 Effect.succeed as HttpClient.HttpClient.Preprocess<HttpClientError.HttpClientError, never>
299 )
300
301 const jsonResponse = (
302 request: HttpClientRequest.HttpClientRequest,
303 body: unknown
304 ): HttpClientResponse.HttpClientResponse =>
305 HttpClientResponse.fromWeb(
306 request,
307 new Response(JSON.stringify(body), {
308 status: 200,
309 headers: {
310 "content-type": "application/json"
311 }
312 })
313 )
314
315 const getRequestBody = Effect.fnUntraced(function*(request: HttpClientRequest.HttpClientRequest) {
316 const body = request.body
317 if (body._tag === "Uint8Array") {
318 const text = new TextDecoder().decode(body.body)
319 return JSON.parse(text)
320 }
321 return yield* Effect.die(new Error("Expected Uint8Array body"))
322 })
323
324 const noopOpenAiClient: OpenAiClient.Service = {
325 client: undefined as unknown as OpenAiClient.Service["client"],
326 createDecisions: () => Effect.die(new Error("noop")),
327 createResponse: () => Effect.die(new Error("noop")),
328 createResponseStream: () => Effect.die(new Error("noop")),
329 createEmbedding: () => Effect.die(new Error("noop"))
330 }