@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/test/routekit-upstream-sources.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { parseRouterConfig } from "@velum-labs/routekit-config";
+import { routeKitUpstreamSources } from "../services/gateway-generation/service.js";
+test("RouteKit upstream wraps only the explicitly delegated snapshot providers", () => {
+    const config = parseRouterConfig({
+        providers: { openai: {}, anthropic: {} },
+        defaultModel: "openai/test-model"
+    });
+    const sources = routeKitUpstreamSources(config, {
+        ROUTEKIT_UPSTREAM_GATEWAY_URL: "https://gateway.example",
+        ROUTEKIT_UPSTREAM_GATEWAY_TOKEN: "gateway-token",
+        ROUTEKIT_UPSTREAM_PROVIDER_IDS: "openai"
+    });
+    assert.deepEqual(Object.keys(sources), ["openai"]);
+    assert.equal(sources.openai?.sourceId, "openai");
+    assert.equal(sources.anthropic, undefined);
+});
+test("RouteKit upstream ignores delegated providers absent from the current local config", () => {
+    const config = parseRouterConfig({
+        providers: { anthropic: {} },
+        defaultModel: "anthropic/test-model"
+    });
+    const sources = routeKitUpstreamSources(config, {
+        ROUTEKIT_UPSTREAM_GATEWAY_URL: "https://gateway.example",
+        ROUTEKIT_UPSTREAM_GATEWAY_TOKEN: "gateway-token",
+        ROUTEKIT_UPSTREAM_PROVIDER_IDS: "openai"
+    });
+    assert.deepEqual(sources, {});
+});
+test("RouteKit upstream fails closed without an explicit delegated provider set", () => {
+    const config = parseRouterConfig({
+        providers: { openai: {} },
+        defaultModel: "openai/test-model"
+    });
+    assert.throws(() => routeKitUpstreamSources(config, {
+        ROUTEKIT_UPSTREAM_GATEWAY_URL: "https://gateway.example",
+        ROUTEKIT_UPSTREAM_GATEWAY_TOKEN: "gateway-token"
+    }), /ROUTEKIT_UPSTREAM_PROVIDER_IDS is required/u);
+});

package/dist/test/runtime-composition-types.test.js

@@ -2,6 +2,17 @@ import test from "node:test";
 import { daemonLive } from "../effect/daemon-live.js";
 test("daemon runtime composition rejects prebuilt coordinator bags at compile time", () => {
     if (false) {
+        const layer = daemonLive({
+            packageVersion: "0.0.0"
+        });
+        void layer;
+        const dataPlane = undefined;
+        const policy = undefined;
+        void dataPlane;
+        void policy;
+        // @ts-expect-error launcher credentials are private, not part of the published DaemonLive API.
+        const launcher = undefined;
+        void launcher;
         // @ts-expect-error daemonLive constructs TokenStore; callers cannot inject one.
         daemonLive({ packageVersion: "0.0.0", tokenStore: {} });
         // @ts-expect-error daemonLive constructs/acquires the sidecar adapter.

package/dist/token-application-service.d.ts

@@ -1,7 +1,5 @@
 import type { EffectRouteKitControlHandlers } from "@velum-labs/routekit-control/effect";
 type TokenHandlers = Pick<EffectRouteKitControlHandlers, "tokens.issue" | "tokens.list" | "tokens.revoke">;
 /** Binds token use cases to the control protocol. */
-export declare class TokenApplicationService {
-    handlers(): TokenHandlers;
-}
+export declare const tokenHandlers: TokenHandlers;
 export {};

package/dist/token-application-service.js

@@ -7,53 +7,47 @@ import { Tokens } from "./services/tokens/service.js";
 const tokenFailure = (error, operation) => {
     const message = error instanceof Error ? error.message : String(error);
     return new ControlError({
-        code: operation === "revoke" && message.startsWith("unknown token")
-            ? "not_found"
-            : "bad_request",
+        code: operation === "revoke" && message.startsWith("unknown token") ? "not_found" : "bad_request",
         message
     });
 };
 /** Binds token use cases to the control protocol. */
-export class TokenApplicationService {
-    handlers() {
+export const tokenHandlers = {
+    "tokens.issue": (params, context) => Effect.gen(function* () {
+        const env = yield* DaemonEnv;
+        const tokens = yield* Tokens;
+        const issued = yield* tokens
+            .issue({
+            label: params.label,
+            plane: params.plane,
+            role: "admin",
+            createdBy: params.createdBy ?? context.principal?.label ?? "control"
+        })
+            .pipe(Effect.mapError((error) => tokenFailure(error, "issue")));
         return {
-            "tokens.issue": (params, context) => Effect.gen(function* () {
-                const env = yield* DaemonEnv;
-                const tokens = yield* Tokens;
-                const issued = yield* tokens
-                    .issue({
-                    label: params.label,
-                    plane: params.plane,
-                    role: "admin",
-                    createdBy: params.createdBy ?? context.principal?.label ?? "control"
-                })
-                    .pipe(Effect.mapError((error) => tokenFailure(error, "issue")));
-                return {
-                    id: issued.id,
-                    label: issued.label,
-                    plane: issued.plane,
-                    role: issued.role,
-                    token: issued.token,
-                    ...(issued.plane === "control"
-                        ? {
-                            joinCredential: encodeJoinCredential({
-                                publicRecordPath: daemonPublicRecordPath(env.home),
-                                token: issued.token
-                            })
-                        }
-                        : {})
-                };
-            }),
-            "tokens.list": (params) => Effect.gen(function* () {
-                const tokens = yield* Tokens;
-                return { tokens: yield* tokens.list(params.plane) };
-            }),
-            "tokens.revoke": (params) => Effect.gen(function* () {
-                const tokens = yield* Tokens;
-                return yield* tokens
-                    .revoke(params.id)
-                    .pipe(Effect.mapError((error) => tokenFailure(error, "revoke")));
-            })
+            id: issued.id,
+            label: issued.label,
+            plane: issued.plane,
+            role: issued.role,
+            token: issued.token,
+            ...(issued.plane === "control"
+                ? {
+                    joinCredential: encodeJoinCredential({
+                        publicRecordPath: daemonPublicRecordPath(env.home),
+                        token: issued.token
+                    })
+                }
+                : {})
         };
-    }
-}
+    }),
+    "tokens.list": (params) => Effect.gen(function* () {
+        const tokens = yield* Tokens;
+        return { tokens: yield* tokens.list(params.plane) };
+    }),
+    "tokens.revoke": (params) => Effect.gen(function* () {
+        const tokens = yield* Tokens;
+        return yield* tokens
+            .revoke(params.id)
+            .pipe(Effect.mapError((error) => tokenFailure(error, "revoke")));
+    })
+};

package/dist/worker.js

@@ -107,7 +107,9 @@ export async function runRouteKitDaemonWorker(options) {
     const ipc = WorkerIpc.layer((message) => hostRequests.accept(message));
     const application = Layer.unwrap(Effect.map(WorkerIpc, () => daemonLive(daemonOptions))).pipe(Layer.provideMerge(ipc));
     const runtime = ManagedRuntime.make(application);
-    const runWorker = (daemon, workerIpc) => Effect.scoped(Effect.gen(function* () {
+    const runWorker = Effect.scoped(Effect.gen(function* () {
+        const daemon = yield* DaemonRuntime;
+        const workerIpc = yield* WorkerIpc;
         const snapshot = yield* daemon.snapshot;
         send({
             type: "worker.ready",
@@ -118,6 +120,7 @@ export async function runRouteKitDaemonWorker(options) {
                 : { workerProcessIdentity: daemon.record.processIdentity }),
             workerStartedAt: daemon.record.startedAt,
             packageVersion: options.packageVersion,
+            ...(options.sourceBuildId === undefined ? {} : { sourceBuildId: options.sourceBuildId }),
             generation,
             configRevision: snapshot.configRevision,
             accountRevision: snapshot.accountRevision,
@@ -181,8 +184,7 @@ export async function runRouteKitDaemonWorker(options) {
     }));
     let exitCode = 0;
     try {
-        const [daemon, workerIpc] = await runtime.runPromise(Effect.all([DaemonRuntime, WorkerIpc]));
-        await runtime.runPromise(runWorker(daemon, workerIpc));
+        await runtime.runPromise(runWorker);
     }
     catch (error) {
         exitCode = 1;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-daemon",
   "private": false,
-  "version": "1.3.2",
+  "version": "1.5.0",
   "description": "Singleton RouteKit control daemon and stable model gateway.",
   "repository": {
     "type": "git",
@@ -41,21 +41,45 @@
     "service"
   ],
   "dependencies": {
+    "@aws-sdk/credential-providers": "3.1095.0",
+    "@openrouter/sdk": "1.2.106",
+    "oauth4webapi": "3.8.7",
     "effect": "4.0.0-rc.108",
     "posthog-node": "5.46.1",
     "yaml": "2.9.0",
-    "@velum-labs/routekit-accounts": "1.3.2",
-    "@velum-labs/routekit-config": "1.3.2",
-    "@velum-labs/routekit-control": "1.3.2",
-    "@velum-labs/routekit-eval-contracts": "1.3.2",
-    "@velum-labs/routekit-eval-store": "1.3.2",
-    "@velum-labs/routekit-gateway": "1.3.2",
-    "@velum-labs/routekit-registry": "1.3.2",
-    "@velum-labs/routekit-runtime": "1.3.2",
-    "@velum-labs/routekit-telemetry-core": "1.3.2"
+    "@aws-sdk/client-bedrock": "3.1095.0",
+    "@aws-sdk/client-bedrock-runtime": "3.1095.0",
+    "google-auth-library": "11.0.2",
+    "zod": "4.4.3",
+    "@velum-labs/routekit-accounts": "1.5.0",
+    "@velum-labs/routekit-config": "1.5.0",
+    "@velum-labs/routekit-control": "1.5.0",
+    "@velum-labs/routekit-contracts": "1.5.0",
+    "@velum-labs/routekit-eval-contracts": "1.5.0",
+    "@velum-labs/routekit-eval-store": "1.5.0",
+    "@velum-labs/routekit-gateway": "1.5.0",
+    "@velum-labs/routekit-provider-core": "1.5.0",
+    "@velum-labs/routekit-registry": "1.5.0",
+    "@velum-labs/routekit-runtime": "1.5.0",
+    "@velum-labs/routekit-telemetry-core": "1.5.0"
+  },
+  "devDependencies": {
+    "@velum-labs/routekit-provider-anthropic": "1.5.0",
+    "@velum-labs/routekit-provider-azure": "1.5.0",
+    "@velum-labs/routekit-provider-bedrock": "1.5.0",
+    "@velum-labs/routekit-provider-claude-code": "1.5.0",
+    "@velum-labs/routekit-provider-cliproxy": "1.5.0",
+    "@velum-labs/routekit-provider-codex": "1.5.0",
+    "@velum-labs/routekit-provider-custom": "1.5.0",
+    "@velum-labs/routekit-provider-fake-openai": "1.5.0",
+    "@velum-labs/routekit-provider-google": "1.5.0",
+    "@velum-labs/routekit-provider-google-vertex": "1.5.0",
+    "@velum-labs/routekit-provider-openai": "1.5.0",
+    "@velum-labs/routekit-provider-openai-compatible": "1.5.0",
+    "@velum-labs/routekit-provider-openrouter": "1.5.0"
   },
   "scripts": {
-    "build": "tsc -b",
+    "build": "node --input-type=module -e \"import { rmSync } from 'node:fs'; for (const path of ['dist', 'tsconfig.tsbuildinfo']) rmSync(path, { recursive: true, force: true })\" && tsc -b && node ../../scripts/embed-private-provider-packages.mjs daemon provider-anthropic provider-azure provider-bedrock provider-claude-code provider-cliproxy provider-codex provider-custom provider-google provider-google-vertex provider-openai provider-openai-compatible provider-openrouter",
     "test": "node --test \"dist/test/*.test.js\""
   }
 }

package/dist/application-services.d.ts

@@ -1,10 +0,0 @@
-import type { RouteKitControlHandlers } from "@velum-labs/routekit-control";
-import { ControlMethodRegistry } from "@velum-labs/routekit-control";
-/**
- * Builds the daemon's control registry straight from the protocol method table.
- *
- * Authorization, mutation classification, and idempotency policy are protocol
- * facts, not daemon opinions, so the daemon binds handlers and inherits the
- * rest. A method added to the table is registered here with no edit.
- */
-export declare function createDaemonControlMethodRegistry(handlers: RouteKitControlHandlers): ControlMethodRegistry;

package/dist/application-services.js

@@ -1,22 +0,0 @@
-import { ControlMethodRegistry, controlAuthorization, controlIdempotency, controlMutation, ROUTEKIT_CONTROL_METHODS, routeKitControlSchemas } from "@velum-labs/routekit-control";
-/**
- * Builds the daemon's control registry straight from the protocol method table.
- *
- * Authorization, mutation classification, and idempotency policy are protocol
- * facts, not daemon opinions, so the daemon binds handlers and inherits the
- * rest. A method added to the table is registered here with no edit.
- */
-export function createDaemonControlMethodRegistry(handlers) {
-    const registry = new ControlMethodRegistry();
-    for (const method of ROUTEKIT_CONTROL_METHODS) {
-        registry.register({
-            method,
-            ...routeKitControlSchemas(method),
-            authorization: controlAuthorization(method),
-            mutation: controlMutation(method),
-            idempotency: controlIdempotency(method),
-            handler: handlers[method]
-        });
-    }
-    return registry;
-}

package/dist/daemon-lifecycle.d.ts

@@ -1,54 +0,0 @@
-import type { AccountActivityService, AccountAuthService } from "@velum-labs/routekit-accounts/effect";
-import type { RouteKitControlHandlers } from "@velum-labs/routekit-control";
-import type { SwitchingGatewayProxy } from "@velum-labs/routekit-gateway";
-import type { RunningControlServer } from "@velum-labs/routekit-runtime/control";
-import { type RouteKitPlatform } from "@velum-labs/routekit-runtime/effect";
-import { Effect, type ManagedRuntime } from "effect";
-import type { DaemonRuntimeState } from "./daemon-runtime-state.js";
-import type { RunningGatewayGeneration } from "./services/gateway-generation/service.js";
-import type { DaemonTelemetry, GatewayTelemetryAggregator } from "./telemetry.js";
-type Supervisor = "systemd" | "launchd" | "detached" | "unknown";
-export type DaemonLifecycleOptions = {
-    runtimeState: DaemonRuntimeState;
-    handlers: RouteKitControlHandlers;
-    drainGraceMs: number;
-    packageVersion: string;
-    supervisor: Supervisor;
-    getProxy(): SwitchingGatewayProxy | undefined;
-    getActiveRouter(): RunningGatewayGeneration | undefined;
-    getControl(): RunningControlServer | undefined;
-    accountActivity?: AccountActivityService;
-    accountAuth?: AccountAuthService;
-    daemonTelemetry?: DaemonTelemetry;
-    gatewayTelemetry?: GatewayTelemetryAggregator;
-    closeSidecar(): Effect.Effect<void, Error>;
-    cleanupRegistration(): void;
-    /** Disposed last so in-flight Effect work can finish during teardown. */
-    effectRuntime?: ManagedRuntime.ManagedRuntime<any, never>;
-};
-export declare function captureDaemonStarted(input: {
-    daemonTelemetry?: DaemonTelemetry;
-    packageVersion: string;
-    supervisor: Supervisor;
-}): void;
-export declare function createDaemonLifecycle(options: DaemonLifecycleOptions): {
-    close(): Effect.Effect<void, Error, RouteKitPlatform>;
-    retire(graceMs?: number): Effect.Effect<void, Error, RouteKitPlatform>;
-    pauseMutations(): Effect.Effect<ReturnType<DaemonRuntimeState["snapshot"]>, Error>;
-    resumeMutations(): void;
-    snapshot(): ReturnType<DaemonRuntimeState["snapshot"]>;
-    reload(): Effect.Effect<void, Error>;
-};
-export declare function cleanupFailedDaemon(input: {
-    gatewayTelemetry?: GatewayTelemetryAggregator;
-    daemonTelemetry?: DaemonTelemetry;
-    proxy?: SwitchingGatewayProxy;
-    activeRouter?: RunningGatewayGeneration;
-    accountActivity?: AccountActivityService;
-    accountAuth?: AccountAuthService;
-    closeSidecar(): Effect.Effect<void, Error>;
-    control?: RunningControlServer;
-    cleanupRegistration(): void;
-    effectRuntime?: ManagedRuntime.ManagedRuntime<any, never>;
-}): Effect.Effect<void, Error, RouteKitPlatform>;
-export {};

package/dist/daemon-lifecycle.js

@@ -1,177 +0,0 @@
-import { extendCleanupGrace, registerCleanup } from "@velum-labs/routekit-runtime/lifecycle";
-import { ResourceDisposalTimeoutError } from "@velum-labs/routekit-runtime/lifecycle";
-import { routeKitError, runRouteKitEffect, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
-import { Cause, Deferred, Effect, Exit, Scope } from "effect";
-export function captureDaemonStarted(input) {
-    input.daemonTelemetry?.capture("routekit.daemon_lifecycle", {
-        action: "started",
-        outcome: "success",
-        supervisor: input.supervisor,
-        version: input.packageVersion
-    });
-}
-function callbackFinalizer(run) {
-    return Effect.tryPromise({
-        try: async () => {
-            await run();
-        },
-        catch: toRouteKitFailure
-    });
-}
-function closeDaemonResources(finalizers, shutdownBudgetMs) {
-    return Effect.gen(function* () {
-        const platform = yield* Effect.context();
-        const scope = yield* Scope.make("sequential");
-        const errors = [];
-        const deadline = shutdownBudgetMs === undefined ? undefined : Date.now() + shutdownBudgetMs;
-        for (const finalizer of finalizers) {
-            yield* Scope.addFinalizer(scope, Effect.suspend(() => {
-                const remaining = deadline === undefined ? undefined : Math.max(0, deadline - Date.now());
-                const bounded = remaining === undefined
-                    ? finalizer
-                    : finalizer.pipe(Effect.timeoutOrElse({
-                        duration: remaining,
-                        orElse: () => Effect.fail(new ResourceDisposalTimeoutError(shutdownBudgetMs))
-                    }));
-                return Effect.exit(bounded.pipe(Effect.provide(platform))).pipe(Effect.flatMap((closed) => Exit.isFailure(closed)
-                    ? Effect.sync(() => {
-                        errors.push(Cause.squash(closed.cause));
-                    })
-                    : Effect.void));
-            }));
-        }
-        yield* Scope.close(scope, Exit.void);
-        if (errors.length > 0) {
-            return yield* Effect.fail(new AggregateError(errors, "one or more daemon resource finalizers failed"));
-        }
-    });
-}
-export function createDaemonLifecycle(options) {
-    const shutdownResources = (mode, graceMs) => {
-        const finalizers = [
-            // Native Scope finalizers run in LIFO order. Register the Effect runtime
-            // first so it disposes last, after every Effect-owned resource.
-            callbackFinalizer(async () => await options.effectRuntime?.dispose()),
-            callbackFinalizer(() => options.cleanupRegistration()),
-            callbackFinalizer(() => options.gatewayTelemetry?.close()),
-            callbackFinalizer(async () => await options.daemonTelemetry?.shutdown()),
-            options.closeSidecar()
-        ];
-        if (options.accountAuth !== undefined) {
-            finalizers.push(options.accountAuth.close);
-        }
-        if (options.accountActivity !== undefined) {
-            finalizers.push(options.accountActivity.close);
-        }
-        const activeRouter = options.getActiveRouter();
-        if (activeRouter !== undefined)
-            finalizers.push(activeRouter.close);
-        const proxy = options.getProxy();
-        if (proxy !== undefined) {
-            finalizers.push(mode === "retire" ? proxy.retire(graceMs) : proxy.drain(graceMs));
-        }
-        const control = options.getControl();
-        if (control !== undefined) {
-            finalizers.push(mode === "retire" ? control.retire(Math.min(graceMs, 2_000)) : control.close);
-        }
-        return closeDaemonResources(finalizers, graceMs + 10_000);
-    };
-    let removeSighupListener = () => { };
-    let shutdownLatch;
-    let shutdownOwner;
-    const shutdown = (mode, graceMs) => {
-        if (shutdownOwner !== undefined)
-            return Deferred.await(shutdownLatch);
-        shutdownLatch = Deferred.makeUnsafe();
-        shutdownOwner = Effect.gen(function* () {
-            if (mode === "close")
-                options.runtimeState.beginShutdown();
-            else
-                options.runtimeState.beginRetire();
-            yield* options.runtimeState.awaitMutations();
-            if (mode === "close") {
-                yield* Effect.sync(() => {
-                    try {
-                        options.daemonTelemetry?.capture("routekit.daemon_lifecycle", {
-                            action: "stopped",
-                            outcome: "success",
-                            supervisor: options.supervisor,
-                            version: options.packageVersion
-                        });
-                    }
-                    catch (error) {
-                        process.stderr.write(`routekit daemon stop telemetry failed: ${error instanceof Error ? error.message : String(error)}\n`);
-                    }
-                });
-            }
-            options.runtimeState.markDraining();
-            yield* shutdownResources(mode, graceMs).pipe(Effect.mapError((cause) => routeKitError(cause)));
-        }).pipe(Effect.ensuring(Effect.sync(() => {
-            removeSighupListener();
-            options.runtimeState.markClosed();
-        })), Effect.matchEffect({
-            onFailure: (error) => Deferred.fail(shutdownLatch, error).pipe(Effect.andThen(Effect.fail(error))),
-            onSuccess: () => Deferred.succeed(shutdownLatch, undefined)
-        }));
-        return shutdownOwner;
-    };
-    const close = () => shutdown("close", options.drainGraceMs);
-    extendCleanupGrace(options.drainGraceMs + 10_000);
-    registerCleanup(() => runRouteKitEffect(close()).catch(() => undefined));
-    const onSighup = () => {
-        void runRouteKitEffect(reload(options.handlers, "sighup")).catch((error) => {
-            process.stderr.write(`routekit daemon reload failed: ${error instanceof Error ? error.message : String(error)}\n`);
-        });
-    };
-    process.on("SIGHUP", onSighup);
-    removeSighupListener = () => process.off("SIGHUP", onSighup);
-    return {
-        close,
-        retire: (graceMs = options.drainGraceMs) => shutdown("retire", graceMs),
-        pauseMutations: () => Effect.gen(function* () {
-            yield* Effect.try({
-                try: () => {
-                    options.runtimeState.pause();
-                },
-                catch: toRouteKitFailure
-            });
-            yield* options.runtimeState.awaitMutations();
-            return options.runtimeState.snapshot();
-        }),
-        resumeMutations: () => {
-            options.runtimeState.resume();
-        },
-        snapshot: () => options.runtimeState.snapshot(),
-        reload: () => reload(options.handlers, "direct")
-    };
-}
-export function cleanupFailedDaemon(input) {
-    const finalizers = [
-        callbackFinalizer(async () => await input.effectRuntime?.dispose()),
-        callbackFinalizer(() => input.cleanupRegistration())
-    ];
-    if (input.control !== undefined)
-        finalizers.push(input.control.close);
-    finalizers.push(input.closeSidecar());
-    if (input.accountAuth !== undefined) {
-        finalizers.push(input.accountAuth.close);
-    }
-    if (input.accountActivity !== undefined) {
-        finalizers.push(input.accountActivity.close);
-    }
-    if (input.activeRouter !== undefined)
-        finalizers.push(input.activeRouter.close);
-    if (input.proxy !== undefined)
-        finalizers.push(input.proxy.close);
-    finalizers.push(callbackFinalizer(async () => await input.daemonTelemetry?.shutdown()), callbackFinalizer(() => input.gatewayTelemetry?.close()));
-    return closeDaemonResources(finalizers);
-}
-function reload(handlers, requestId) {
-    return Effect.tryPromise({
-        try: () => Promise.resolve(handlers["daemon.reload"]({}, {
-            signal: new AbortController().signal,
-            requestId
-        })).then(() => undefined),
-        catch: toRouteKitFailure
-    });
-}

package/dist/test/application-services.test.js

@@ -1,135 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { ROUTEKIT_CONTROL_METHODS } from "@velum-labs/routekit-control";
-import { createDaemonControlMethodRegistry } from "../application-services.js";
-import { AccountEnrollService } from "../account-enroll-service.js";
-import { AccountMutationService } from "../account-mutation-service.js";
-import { AccountQueryService } from "../account-query-service.js";
-import { DaemonLifecycleService } from "../daemon-lifecycle-service.js";
-import { DoctorApplicationService } from "../doctor-service.js";
-import { EvalRoutingApplicationService } from "../eval-routing-service.js";
-import { EvalSessionApplicationService } from "../services/eval-session/service.js";
-import { LauncherSessionManager } from "../services/launcher-session/service.js";
-import { LauncherApplicationService } from "../launcher-service.js";
-import { ProviderQueryService } from "../provider-query-service.js";
-import { RouterGenerationService } from "../router-generation-service.js";
-import { TelemetryApplicationService } from "../telemetry-application-service.js";
-import { TokenApplicationService } from "../token-application-service.js";
-const handlers = new Proxy({}, {
-    get: (_target, method) => async () => String(method)
-});
-test("daemon application services register disjoint owned method groups", () => {
-    const registry = createDaemonControlMethodRegistry(handlers);
-    const definitions = registry.list();
-    const methods = definitions.map(({ method }) => method);
-    assert.equal(new Set(methods).size, methods.length);
-    assert.equal(methods.length, ROUTEKIT_CONTROL_METHODS.length);
-    const enroll = registry.definition("accounts.enroll");
-    assert.deepEqual({
-        method: enroll.method,
-        paramsSchema: enroll.paramsSchema.name,
-        resultSchema: enroll.resultSchema.name,
-        authorization: enroll.authorization,
-        mutation: enroll.mutation,
-        idempotency: enroll.idempotency
-    }, {
-        method: "accounts.enroll",
-        paramsSchema: "accounts.enroll.params",
-        resultSchema: "accounts.enroll.result",
-        authorization: "authenticated",
-        mutation: "mutation",
-        idempotency: "optional"
-    });
-    assert.equal(registry.definition("models.list").mutation, "query");
-    assert.equal(registry.definition("daemon.reload").mutation, "mutation");
-    assert.equal(registry.definition("daemon.roll").authorization, "ephemeral");
-});
-test("application services expose concrete bounded handler groups", () => {
-    const accountQuery = new AccountQueryService().handlers();
-    const accountEnroll = new AccountEnrollService().handlers();
-    const accountMutation = new AccountMutationService().handlers();
-    const provider = new ProviderQueryService().handlers();
-    const router = new RouterGenerationService().handlers();
-    assert.deepEqual(Object.keys(accountQuery).sort(), [
-        "accounts.list",
-        "accounts.status",
-        "accounts.usage"
-    ]);
-    assert.deepEqual(Object.keys(accountEnroll).sort(), [
-        "accounts.enroll",
-        "accounts.enrollActivate"
-    ]);
-    assert.deepEqual(Object.keys(accountMutation).sort(), [
-        "accounts.redeemReset",
-        "accounts.remove",
-        "accounts.rename",
-        "accounts.resetCredits",
-        "accounts.sync"
-    ]);
-    assert.deepEqual(Object.keys(provider).sort(), [
-        "calls.inspect",
-        "calls.leaderboard",
-        "models.info",
-        "models.list",
-        "providers.status"
-    ]);
-    assert.deepEqual(Object.keys(router).sort(), [
-        "config.get",
-        "config.import",
-        "config.update",
-        "daemon.reload",
-        "providers.set"
-    ]);
-    assert.deepEqual(Object.keys(new DaemonLifecycleService().handlers()).sort(), [
-        "daemon.prepareShutdown",
-        "daemon.roll",
-        "daemon.status"
-    ]);
-    assert.deepEqual(Object.keys(new DoctorApplicationService().handlers()), ["doctor.run"]);
-    assert.deepEqual(Object.keys(new LauncherApplicationService({ listModels: (() => undefined) }).handlers()), ["launcher.prepare"]);
-    assert.deepEqual(Object.keys(new TokenApplicationService().handlers()).sort(), [
-        "tokens.issue",
-        "tokens.list",
-        "tokens.revoke"
-    ]);
-    assert.deepEqual(Object.keys(new EvalSessionApplicationService().handlers()).sort(), [
-        "evalSession.close",
-        "evalSession.open"
-    ]);
-    assert.deepEqual(Object.keys(new EvalRoutingApplicationService().handlers()).sort(), [
-        "evalRouting.activate",
-        "evalRouting.installAuthoritative",
-        "evalRouting.rollbackAuthoritative",
-        "evalRouting.status"
-    ]);
-    assert.deepEqual(Object.keys(new TelemetryApplicationService().handlers()).sort(), [
-        "telemetry.captureCommand",
-        "telemetry.get",
-        "telemetry.resetIdentity",
-        "telemetry.schema",
-        "telemetry.set"
-    ]);
-});
-test("launcher sessions bind repository profile context without durable token state", () => {
-    let byte = 0;
-    const sessions = new LauncherSessionManager({
-        random: (length) => Buffer.alloc(length, byte++)
-    });
-    const token = sessions.open({
-        repositoryRoot: "/workspace/repository",
-        profileName: "quality",
-        role: "owner"
-    });
-    assert.deepEqual(sessions.resolve(token), {
-        id: `launcher_${Buffer.alloc(16, 1).toString("base64url")}`,
-        label: "launcher:quality",
-        role: "owner",
-        routing: {
-            repositoryRoot: "/workspace/repository",
-            profileName: "quality"
-        }
-    });
-    assert.equal(sessions.resolve("wrong"), undefined);
-    sessions.closeAll();
-    assert.equal(sessions.resolve(token), undefined);
-});