@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/test/daemon-data-plane.test.js

@@ -150,6 +150,7 @@ test("singleton daemon exposes authenticated control and a stable reloadable dat
     const upstream = await mockProvider();
     const daemon = await startRouteKitDaemon({
         packageVersion: "1.2.3",
+        sourceBuildId: "checkout-build",
         stateHome,
         configPath,
         port: 0,
@@ -174,6 +175,7 @@ test("singleton daemon exposes authenticated control and a stable reloadable dat
         assert.equal(record.dataUrl, daemon.dataUrl);
         assert.equal(record.protocolVersion, "control.v2");
         assert.equal(record.generation, 1);
+        assert.equal(record.sourceBuildId, "checkout-build");
         assert.equal(statSync(join(stateHome, "services", "daemon.json")).mode & 0o777, 0o600);
         assert.ok(record.authTokenFile !== undefined);
         const dataToken = readFileSync(record.authTokenFile, "utf8").trim();
@@ -431,53 +433,31 @@ test("singleton daemon exposes authenticated control and a stable reloadable dat
         rmSync(root, { recursive: true, force: true });
     }
 });
-test("local Codex preparation ranks an incompatible OpenAI default by native recency", async () => {
+test("local Codex preparation ranks Responses-compatible OpenAI models by native recency", async () => {
     const root = mkdtempSync(join(tmpdir(), "routekit-daemon-codex-ranking-"));
     const stateHome = join(root, "state");
     const configPath = join(root, "router.yaml");
     writeFileSync(configPath, "providers:\n  openai: {}\ndefaultModel: openai/text-embedding-test\n");
     const upstream = await mockProvider([
-        { id: "text-embedding-test", object: "model", created: 50 },
-        { id: "older-generation", object: "model", created: 100 },
-        { id: "newer-generation", object: "model", created: 200 }
-    ]);
-    const originalFetch = globalThis.fetch;
-    let openRouterFetches = 0;
-    globalThis.fetch = async (input, init) => {
-        const url = new URL(input instanceof Request ? input.url : input.toString());
-        if (url.hostname === "openrouter.ai") {
-            openRouterFetches += 1;
-            if (url.pathname === "/api/v1/models") {
-                return Response.json({
-                    data: [
-                        {
-                            id: "openai/older-generation",
-                            created: 900,
-                            architecture: {
-                                input_modalities: ["text"],
-                                output_modalities: ["text"]
-                            },
-                            supported_parameters: ["tools"]
-                        },
-                        {
-                            id: "openai/newer-generation",
-                            created: 800,
-                            architecture: {
-                                input_modalities: ["text"],
-                                output_modalities: ["text"]
-                            },
-                            supported_parameters: ["tools"]
-                        }
-                    ]
-                });
-            }
-            if (url.pathname === "/api/v1/embeddings/models") {
-                return Response.json({ data: [{ id: "openai/text-embedding-test" }] });
-            }
-            return Response.json({ data: [] });
+        {
+            id: "text-embedding-test",
+            object: "model",
+            created: 50,
+            capabilities: { responses: "unsupported" }
+        },
+        {
+            id: "older-generation",
+            object: "model",
+            created: 100,
+            capabilities: { responses: "supported" }
+        },
+        {
+            id: "newer-generation",
+            object: "model",
+            created: 200,
+            capabilities: { responses: "supported" }
         }
-        return await originalFetch(input, init);
-    };
+    ]);
     let daemon;
     try {
         daemon = await startRouteKitDaemon({
@@ -504,17 +484,16 @@ test("local Codex preparation ranks an incompatible OpenAI default by native rec
             model: "openai/older-generation"
         }));
         assert.equal(explicit.model, "openai/older-generation");
-        assert.equal(openRouterFetches, 0);
         const implicit = await runRouteKitEffect(client.call("launcher.prepare", { tool: "codex" }));
         assert.equal(implicit.model, "openai/newer-generation");
-        assert.equal(openRouterFetches, 4);
         assert.equal(implicit.codexSelection?.models.find((model) => model.id === "openai/older-generation")
-            ?.createdAt, 100, "native OpenAI creation time wins over OpenRouter");
+            ?.createdAt, 100, "native OpenAI creation time remains authoritative");
         assert.equal(implicit.codexSelection?.models.find((model) => model.id === "openai/newer-generation")
             ?.createdAt, 200);
+        assert.equal(implicit.codexSelection?.models.find((model) => model.id === "openai/newer-generation")
+            ?.capabilities?.responses, "supported");
     }
     finally {
-        globalThis.fetch = originalFetch;
         if (daemon !== undefined)
             await daemon.close();
         await upstream.close();

package/dist/test/daemon-fixtures.js

@@ -268,7 +268,7 @@ for (const kind of ["claude-code", "codex"]) {
                     assert.equal(after.configRevision, before.configRevision + 1);
                     assert.equal(after.accountRevision, before.accountRevision + 1);
                     const config = parseYaml((await runRouteKitEffect(client.call("config.get", {}))).document);
-                    assert.deepEqual(Object.keys(config.providers), []);
+                    assert.deepEqual(Object.keys(config.sources), []);
                     assert.equal(config.defaultModel, undefined);
                     assert.deepEqual((await runRouteKitEffect(client.call("providers.status", {}))).providers, []);
                     const listed = await runRouteKitEffect(client.call("models.list", {}));

package/dist/test/daemon-generation-transaction.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
@@ -7,7 +7,7 @@ import { RouteKitControlClient } from "@velum-labs/routekit-control";
 import { runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
 import { readDaemonRevisions } from "../daemon-state.js";
 import { startRouteKitDaemon } from "../index.js";
-import { mockProvider } from "./daemon-fixtures.js";
+import { mockProvider, nativeCredential, withMockNativeDiscovery } from "./daemon-fixtures.js";
 const INITIAL_DOCUMENT = "providers:\n  openai:\n    strategy: sticky\ndefaultModel: openai/mock-model\n";
 const NEXT_DOCUMENT = "providers:\n  openai:\n    strategy: round_robin\ndefaultModel: openai/other-model\n";
 test("generation transaction rolls back every pre-publication stage and keeps retirement best-effort", async () => {
@@ -89,3 +89,67 @@ test("generation transaction rolls back every pre-publication stage and keeps re
         rmSync(root, { recursive: true, force: true });
     }
 });
+test("commit rollback restores the previous native credential auth fingerprint and state", async () => {
+    const root = mkdtempSync(join(tmpdir(), "routekit-daemon-generation-auth-rollback-"));
+    const stateHome = join(root, "state");
+    const configPath = join(root, "router.yaml");
+    const accountsDirectory = join(stateHome, "subscriptions", "codex");
+    const accountPath = join(accountsDirectory, "work.json");
+    const authStatePath = join(stateHome, "subscriptions", "account-auth.v1.json");
+    mkdirSync(accountsDirectory, { recursive: true });
+    writeFileSync(accountPath, `${JSON.stringify(nativeCredential("codex"))}\n`);
+    writeFileSync(configPath, "providers:\n  codex: {}\ndefaultModel: codex/gpt-test-model\n");
+    let failCommit = false;
+    try {
+        await withMockNativeDiscovery("codex", async () => {
+            const daemon = await startRouteKitDaemon({
+                packageVersion: "1.2.3",
+                stateHome,
+                configPath,
+                port: 0,
+                portless: false,
+                onGenerationStage: (stage) => {
+                    if (failCommit && stage === "commit") {
+                        failCommit = false;
+                        throw new Error("injected native credential commit failure");
+                    }
+                },
+                env: {
+                    HOME: root,
+                    ROUTEKIT_HOME: stateHome,
+                    ROUTEKIT_PORTLESS: "0"
+                }
+            });
+            try {
+                const client = new RouteKitControlClient({
+                    url: daemon.record.url,
+                    token: daemon.record.controlToken
+                });
+                const before = await runRouteKitEffect(client.call("accounts.status", {}));
+                assert.equal(before.accounts[0]?.upstreamAuthState, "accepted");
+                const previousAuthState = readFileSync(authStatePath, "utf8");
+                const replacement = nativeCredential("codex");
+                replacement.tokens.access_token =
+                    "eyJhbGciOiJub25lIn0.eyJleHAiOjk5OTk5OTk5OTl9.replacement";
+                replacement.tokens.refresh_token = "replacement-refresh";
+                writeFileSync(accountPath, `${JSON.stringify(replacement)}\n`);
+                const daemonStatus = await runRouteKitEffect(client.call("daemon.status", {}));
+                failCommit = true;
+                await assert.rejects(runRouteKitEffect(client.call("daemon.reload", {
+                    expectedRevision: daemonStatus.configRevision
+                })));
+                const after = await runRouteKitEffect(client.call("accounts.status", {}));
+                assert.equal(after.accounts[0]?.upstreamAuthState, "accepted");
+                assert.equal(after.accounts[0]?.relayOpen, true);
+                assert.deepEqual(after.accounts[0]?.readinessReasons, []);
+                assert.equal(readFileSync(authStatePath, "utf8"), previousAuthState);
+            }
+            finally {
+                await daemon.close();
+            }
+        });
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/dist/test/daemon-runtime-state.test.js

@@ -3,8 +3,35 @@ import test from "node:test";
 import { parseRouterConfig } from "@velum-labs/routekit-config";
 import { ControlError } from "@velum-labs/routekit-runtime/control";
 import { runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
-import { Effect } from "effect";
+import { Deferred, Effect, Fiber } from "effect";
 import { DaemonRuntimeState } from "../daemon-runtime-state.js";
+import { DaemonState } from "../daemon-state-context.js";
+test("daemon state service shares its owner and waits for queued mutations", async () => {
+    const state = new DaemonRuntimeState({
+        config: parseRouterConfig({ providers: {} }),
+        document: "providers: {}\n",
+        revisions: { config: 0, accounts: 0, daemon: 0 }
+    });
+    await runRouteKitEffect(Effect.gen(function* () {
+        const service = yield* DaemonState;
+        assert.strictEqual(service, state);
+        const started = yield* Deferred.make();
+        const release = yield* Deferred.make();
+        const mutation = yield* service
+            .serializeEffect(Effect.gen(function* () {
+            yield* Deferred.succeed(started, undefined);
+            yield* Deferred.await(release);
+        }))
+            .pipe(Effect.forkChild);
+        yield* Deferred.await(started);
+        const waiting = yield* service.awaitMutations.pipe(Effect.forkChild);
+        const beforeRelease = yield* Effect.race(Fiber.join(waiting).pipe(Effect.as("completed")), Effect.sleep("1 millis").pipe(Effect.as("pending")));
+        assert.equal(beforeRelease, "pending");
+        yield* Deferred.succeed(release, undefined);
+        yield* Fiber.join(mutation);
+        yield* Fiber.join(waiting);
+    }).pipe(Effect.provide(DaemonState.layer(state))));
+});
 test("daemon runtime state serializes mutations and exposes a stable snapshot", async () => {
     const state = new DaemonRuntimeState({
         config: parseRouterConfig({ providers: {} }),

package/dist/test/effect-daemon.test.js

@@ -1,12 +1,50 @@
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { test } from "node:test";
 import { parseRouterConfig } from "@velum-labs/routekit-config";
 import { ControlError } from "@velum-labs/routekit-runtime/control";
 import { runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
 import { Effect } from "effect";
 import { createCliproxySidecar } from "../cliproxy-sidecar.js";
+import { makeRouteKitDaemonRuntime, runningRouteKitDaemon } from "../daemon-bootstrap.js";
+import { DaemonPolicy } from "../daemon-policy-context.js";
+import { DataPlane } from "../data-plane-context.js";
 import { DaemonRuntimeState } from "../daemon-runtime-state.js";
 const config = parseRouterConfig({ providers: {} });
+test("published daemon layer provides the data-plane and policy services", async () => {
+    const root = mkdtempSync(join(tmpdir(), "routekit-daemon-compat-services-"));
+    const home = join(root, "state");
+    const configPath = join(root, "router.yaml");
+    writeFileSync(configPath, "providers: {}\n");
+    const runtime = makeRouteKitDaemonRuntime({
+        packageVersion: "0.0.0",
+        stateHome: home,
+        configPath,
+        port: 0,
+        controlPort: 0,
+        portless: false,
+        env: { HOME: root, ROUTEKIT_HOME: home, ROUTEKIT_PORTLESS: "0" }
+    });
+    try {
+        const daemon = await runningRouteKitDaemon(runtime);
+        try {
+            const plane = await runtime.runPromise(DataPlane);
+            const policy = await runtime.runPromise(DaemonPolicy);
+            assert.equal(plane.path, daemon.record.authTokenFile);
+            assert.equal(plane.token.length > 0, true);
+            assert.equal(policy.wantsCliproxySidecar(config), false);
+        }
+        finally {
+            await daemon.close();
+        }
+    }
+    finally {
+        await runtime.dispose();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
 test("daemon runtime-state mutations serialize on the shared tail", async () => {
     const state = new DaemonRuntimeState({
         config,

package/dist/test/eval-routing-application-service.test.js

@@ -11,7 +11,7 @@ import { DaemonRuntimeState } from "../daemon-runtime-state.js";
 import { ActiveGateway } from "../services/active-gateway/service.js";
 import { DaemonEnv } from "../daemon-env-context.js";
 import { DaemonState } from "../daemon-state-context.js";
-import { EvalRoutingApplicationService } from "../eval-routing-service.js";
+import { evalRoutingHandlers } from "../eval-routing-service.js";
 test("legacy V2 publication is rejected because V2 is rollback-only", async () => {
     const home = mkdtempSync(join(tmpdir(), "routekit-routing-activation-"));
     const daemonEnv = Layer.succeed(DaemonEnv, DaemonEnv.of({
@@ -24,11 +24,11 @@ test("legacy V2 publication is rejected because V2 is rollback-only", async () =
         hosted: undefined
     }));
     const runtimeState = new DaemonRuntimeState({
-        config: {
-            providers: { openai: {} },
+        config: parseRouterConfig({
+            sources: { openai: { use: "openai" } },
             defaultModel: "openai/model-a",
             classifierModel: "openai/classifier"
-        },
+        }),
         document: "",
         revisions: { daemon: 1, config: 1, accounts: 1 }
     });
@@ -46,7 +46,7 @@ test("legacy V2 publication is rejected because V2 is rollback-only", async () =
         });
     })());
     const services = Layer.mergeAll(daemonEnv, DaemonState.layer(runtimeState), activeGateway);
-    const handlers = new EvalRoutingApplicationService().handlers();
+    const handlers = evalRoutingHandlers;
     const run = (effect) => runRouteKitEffect(effect.pipe(Effect.provide(services)));
     try {
         assert.deepEqual(await run(handlers["evalRouting.status"]({}, undefined)), {
@@ -123,7 +123,7 @@ test("V3 authority installs when its pinned models match the running gateway", a
         });
     })());
     const services = Layer.mergeAll(daemonEnv, DaemonState.layer(runtimeState), activeGateway);
-    const handler = new EvalRoutingApplicationService().handlers()["evalRouting.installAuthoritative"];
+    const handler = evalRoutingHandlers["evalRouting.installAuthoritative"];
     const run = (effect) => runRouteKitEffect(effect.pipe(Effect.provide(services)));
     const activationPath = join(repositoryRoot, ".routekit", "routing", "activations", `${activationV3.activationDigest}.json`);
     mkdirSync(join(repositoryRoot, ".routekit", "routing", "activations"), {

package/dist/test/eval-session-execution.test.d.ts

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