@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/internal-providers/provider-codex/test/http-submission.test.js

@@ -0,0 +1,142 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { SubscriptionAccountSet } from "@velum-labs/routekit-accounts";
+import { HttpSubmissionAuthority, HttpSubmissionError, runRouteKitEffect, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
+import { Effect } from "effect";
+import { CodexBackendRelay } from "../relay.js";
+import { codexProvider } from "../subscription.js";
+const MODEL = "gpt-5.3-codex";
+const TOKEN = "offline-native-codex-token";
+for (const disconnect of [false, true]) {
+    test(`native managed Codex relay observes ${disconnect ? "unknown without retry" : "raw completion"} at its credential-owning POST`, async (t) => {
+        const directory = await mkdtemp(join(tmpdir(), "routekit-native-codex-submission-"));
+        const intents = [];
+        const outcomes = [];
+        const posts = [];
+        const errors = [];
+        let accounts;
+        const wire = [
+            'event: response.output_text.delta\ndata: {"type":"response.output_text.delta","delta":"offline codex"}\n\n',
+            'event: response.completed\ndata: {"type":"response.completed","response":{"id":"offline-codex","status":"completed","output":[]}}\n\n'
+        ].join("");
+        const server = createServer((request, response) => {
+            void (async () => {
+                const chunks = [];
+                for await (const chunk of request)
+                    chunks.push(Buffer.from(chunk));
+                posts.push({
+                    body: JSON.parse(Buffer.concat(chunks).toString("utf8")),
+                    complete: request.complete,
+                    authorization: request.headers.authorization,
+                    accountId: request.headers["chatgpt-account-id"],
+                    intentsBeforePost: intents.length
+                });
+                assert.equal(request.url, "/responses");
+                if (disconnect) {
+                    response.destroy();
+                    return;
+                }
+                response.writeHead(200, { "content-type": "text/event-stream" });
+                response.end(wire);
+            })().catch((cause) => {
+                errors.push(cause);
+                response.destroy();
+            });
+        });
+        t.after(async () => {
+            try {
+                if (accounts !== undefined)
+                    await runRouteKitEffect(accounts.close());
+            }
+            finally {
+                try {
+                    await new Promise((resolve, reject) => {
+                        server.close((error) => (error === undefined ? resolve() : reject(error)));
+                        server.closeAllConnections();
+                    });
+                }
+                finally {
+                    await rm(directory, { recursive: true, force: true });
+                }
+            }
+            assert.deepEqual(errors, []);
+        });
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(0, "127.0.0.1", resolve);
+        });
+        const address = server.address();
+        assert.ok(address !== null && typeof address === "object");
+        await writeFile(join(directory, "account.json"), JSON.stringify({
+            tokens: { access_token: TOKEN, account_id: "offline-managed-codex-account" }
+        }), { mode: 0o600 });
+        accounts = await runRouteKitEffect(SubscriptionAccountSet.open(codexProvider(), {
+            source: { kind: "directory", path: directory },
+            publishedModels: [MODEL],
+            probeIntervalMs: 0
+        }));
+        const relay = new CodexBackendRelay({
+            backendUrl: `http://127.0.0.1:${address.port}`,
+            catalog: (_template, stock) => [...stock],
+            auth: { kind: "accounts", accounts }
+        });
+        assert.equal(relay.httpSubmission, undefined, "an overridden endpoint is not publicly certified");
+        assert.equal(new CodexBackendRelay({
+            catalog: (_template, stock) => [...stock],
+            auth: { kind: "accounts", accounts }
+        }).httpSubmission, "credential-owner-http-v1");
+        assert.equal(new CodexBackendRelay({ catalog: (_template, stock) => [...stock] }).httpSubmission, undefined, "the client-credential trust model must not inherit a managed-account declaration");
+        const authority = {
+            begin: (request) => Effect.sync(() => {
+                intents.push(request);
+                return { attemptId: `offline-native-${intents.length}` };
+            }),
+            settle: (_attemptId, outcome) => Effect.sync(() => {
+                outcomes.push(outcome);
+            })
+        };
+        let retries = 0;
+        const result = await runRouteKitEffect(relay
+            .relayResponses({
+            authorization: "Bearer offline-ingress-token",
+            "chatgpt-account-id": "offline-ingress-account"
+        }, { model: MODEL, input: "hello", stream: false }, undefined, {
+            responseMode: "buffered",
+            onAttribution: (update) => {
+                if (update.accountAttemptResult !== undefined)
+                    retries += 1;
+            }
+        })
+            .pipe(Effect.flatMap((response) => Effect.tryPromise({
+            try: () => response.text(),
+            catch: (cause) => cause instanceof HttpSubmissionError ? cause : toRouteKitFailure(cause)
+        })), Effect.catch((cause) => Effect.succeed(cause)), Effect.scoped, Effect.provideService(HttpSubmissionAuthority, authority)));
+        assert.equal(posts.length, 1);
+        assert.equal(posts[0]?.complete, true);
+        assert.equal(posts[0]?.intentsBeforePost, 1);
+        assert.equal(posts[0]?.authorization, `Bearer ${TOKEN}`);
+        assert.equal(posts[0]?.accountId, "offline-managed-codex-account");
+        assert.equal(posts[0]?.body.model, MODEL);
+        assert.equal(posts[0]?.body.stream, true);
+        assert.ok(Array.isArray(posts[0]?.body.input));
+        assert.equal(intents[0]?.model, MODEL);
+        assert.match(intents[0]?.accountIdentity ?? "", /^[a-f0-9]{64}$/u);
+        assert.equal(retries, 0);
+        assert.ok(accounts.snapshot().members.every((member) => member.inFlight === 0));
+        assert.equal(JSON.stringify(intents).includes(TOKEN), false);
+        if (disconnect) {
+            assert.ok(result instanceof HttpSubmissionError);
+            assert.equal(result.code, "unknown-submission");
+            assert.deepEqual(outcomes, [{ state: "unknown", reason: "transport-error" }]);
+        }
+        else {
+            assert.equal(result, wire, "the native relay must preserve exact upstream bytes");
+            assert.equal(outcomes[0]?.state, "completed");
+            assert.equal(outcomes[0]?.state === "completed" ? outcomes[0].terminal : undefined, "responses-terminal");
+        }
+    });
+}

package/dist/internal-providers/provider-codex/test/relay.test.d.ts

@@ -0,0 +1 @@
+export {};