@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/daemon-maintenance.d.ts

@@ -1,61 +1,37 @@
 import type { AccountStoreEntry } from "@velum-labs/routekit-accounts";
-import { type RouterConfig } from "@velum-labs/routekit-config";
+import { type RouterConfig, type SourceConfig } from "@velum-labs/routekit-config";
 import { ControlError } from "@velum-labs/routekit-runtime/control";
 import { Effect } from "effect";
 export declare function canonicalConfigDocument(path?: string): string;
-export declare function canonicalConfigDocumentEffect(path?: string): Effect.Effect<string, import("@velum-labs/routekit-runtime/effect").RouteKitFailure | ControlError, never>;
+export declare function canonicalConfigDocumentEffect(path?: string): Effect.Effect<string, ControlError | import("@velum-labs/routekit-runtime/effect").RouteKitFailure, never>;
 export declare function parseConfigDocument(document: string): RouterConfig;
 export declare function parseConfigDocumentEffect(document: string): Effect.Effect<{
-    providers: {
-        openai?: {
+    sources: Record<string, {
+        pool?: "sticky" | "round_robin" | "capacity_weighted" | {
             strategy: "sticky" | "round_robin" | "capacity_weighted";
             switchThreshold: number;
             probeIntervalMs?: number | undefined;
             fallbackCooldownSeconds?: number | undefined;
         } | undefined;
-        anthropic?: {
-            strategy: "sticky" | "round_robin" | "capacity_weighted";
-            switchThreshold: number;
-            probeIntervalMs?: number | undefined;
-            fallbackCooldownSeconds?: number | undefined;
-        } | undefined;
-        bedrock?: {
-            strategy: "sticky" | "round_robin" | "capacity_weighted";
-            switchThreshold: number;
-            probeIntervalMs?: number | undefined;
-            fallbackCooldownSeconds?: number | undefined;
-        } | undefined;
-        google?: {
-            strategy: "sticky" | "round_robin" | "capacity_weighted";
-            switchThreshold: number;
-            probeIntervalMs?: number | undefined;
-            fallbackCooldownSeconds?: number | undefined;
-        } | undefined;
-        openrouter?: {
-            strategy: "sticky" | "round_robin" | "capacity_weighted";
-            switchThreshold: number;
-            probeIntervalMs?: number | undefined;
-            fallbackCooldownSeconds?: number | undefined;
-        } | undefined;
-        cliproxy?: {
-            strategy: "sticky" | "round_robin" | "capacity_weighted";
-            switchThreshold: number;
-            probeIntervalMs?: number | undefined;
-            fallbackCooldownSeconds?: number | undefined;
-        } | undefined;
-        codex?: {
-            strategy: "sticky" | "round_robin" | "capacity_weighted";
-            switchThreshold: number;
-            probeIntervalMs?: number | undefined;
-            fallbackCooldownSeconds?: number | undefined;
-        } | undefined;
-        "claude-code"?: {
-            strategy: "sticky" | "round_robin" | "capacity_weighted";
-            switchThreshold: number;
-            probeIntervalMs?: number | undefined;
-            fallbackCooldownSeconds?: number | undefined;
+        use: string;
+        auth?: {
+            kind: "env-bearer";
+            env: string;
+        } | {
+            kind: "env-header";
+            env: string;
+            header: string;
+        } | {
+            kind: "aws-sdk";
+        } | {
+            kind: "adc";
+        } | {
+            kind: "oauth-file";
+            path?: string | undefined;
         } | undefined;
-    };
+        baseUrl?: string | undefined;
+        options?: Record<string, unknown> | undefined;
+    }>;
     defaultModel?: string | undefined;
     classifierModel?: string | undefined;
     compositionalRouting?: {
@@ -96,16 +72,18 @@ export declare function parseConfigDocumentEffect(document: string): Effect.Effe
         durable: boolean;
         durableRetentionDays: number;
     } | undefined;
-}, import("@velum-labs/routekit-runtime/effect").RouteKitFailure | ControlError, never>;
+} & {
+    readonly providers: Record<import("@velum-labs/routekit-config").SourceId, SourceConfig>;
+}, ControlError | import("@velum-labs/routekit-runtime/effect").RouteKitFailure, never>;
 export declare function revisionConflict(expected: number, actual: number): never;
 type WithoutPath<T> = T extends {
     path: string;
 } ? Omit<T, "path"> : never;
 export type AccountEntry = WithoutPath<AccountStoreEntry>;
 export declare function accountEntries(env: NodeJS.ProcessEnv): AccountEntry[];
-export declare function accountEntriesEffect(env: NodeJS.ProcessEnv): Effect.Effect<AccountEntry[], import("@velum-labs/routekit-runtime/effect").RouteKitFailure | ControlError, never>;
+export declare function accountEntriesEffect(env: NodeJS.ProcessEnv): Effect.Effect<AccountEntry[], ControlError | import("@velum-labs/routekit-runtime/effect").RouteKitFailure, never>;
 export declare function accountEntriesWithPaths(env: NodeJS.ProcessEnv): AccountStoreEntry[];
-export declare function providerCredentialAvailable(provider: string, accounts: readonly AccountEntry[], env: NodeJS.ProcessEnv): boolean;
+export declare function providerCredentialAvailable(source: SourceConfig, accounts: readonly AccountEntry[], env: NodeJS.ProcessEnv): boolean;
 export declare function safeCredentialBlob(kind: "claude-code" | "codex", value: unknown): Record<string, unknown>;
 export declare function safeCliproxyCredentialBlob(kind: string, value: unknown): Record<string, unknown>;
 export declare function safeCliproxyLabel(label: string): string;

package/dist/daemon-maintenance.js

@@ -59,13 +59,17 @@ export function accountEntriesEffect(env) {
 export function accountEntriesWithPaths(env) {
     return accountStoreEntries(env);
 }
-export function providerCredentialAvailable(provider, accounts, env) {
+export function providerCredentialAvailable(source, accounts, env) {
+    const provider = source.use;
     if (provider === "claude-code" || provider === "codex") {
         return accounts.some((entry) => entry.subscriptionKind === provider);
     }
     if (provider === "cliproxy") {
         return (env[CLIPROXY_API_KEY_ENV] ?? "").length > 0 || cliproxyApiKey(env) !== undefined;
     }
+    if (source.auth?.kind === "env-bearer" || source.auth?.kind === "env-header") {
+        return (env[source.auth.env] ?? "").length > 0;
+    }
     const info = PROVIDERS[provider];
     if (info?.keyEnv === undefined)
         return true;

package/dist/daemon-options.d.ts

@@ -1,10 +1,11 @@
 import type { RouteKitControlParams, RouteKitControlResults } from "@velum-labs/routekit-control";
 import type { WorkloadJwtVerifierOptions } from "@velum-labs/routekit-gateway";
 import type { DaemonBootstrapHostedOptions } from "./daemon-bootstrap-preflight.js";
-import type { DaemonGenerationManagerOptions } from "./daemon-generations.js";
+import type { DaemonGenerationSettings } from "./daemon-generations.js";
 import type { TelemetryTransportFactory } from "./telemetry.js";
 export type RouteKitDaemonOptions = {
     packageVersion: string;
+    sourceBuildId?: string;
     env?: NodeJS.ProcessEnv;
     stateHome?: string;
     configPath?: string;
@@ -22,5 +23,5 @@ export type RouteKitDaemonOptions = {
     telemetryTransportFactory?: TelemetryTransportFactory;
     telemetryFlushIntervalMs?: number;
     onAccountTransactionPhase?: (phase: "prepared" | "credentials-written" | "router-swapped" | "committed") => void;
-    onGenerationStage?: DaemonGenerationManagerOptions["onStage"];
+    onGenerationStage?: DaemonGenerationSettings["onStage"];
 };

package/dist/daemon-policy-context.d.ts

@@ -6,4 +6,5 @@ export type DaemonPolicyValue = {
 declare const DaemonPolicy_base: Context.ServiceClass<DaemonPolicy, "@velum-labs/routekit-daemon/DaemonPolicy", DaemonPolicyValue>;
 export declare class DaemonPolicy extends DaemonPolicy_base {
 }
+export declare const wantsCliproxySidecar: (config: RouterConfig) => boolean;
 export {};

package/dist/daemon-policy-context.js

@@ -1,3 +1,4 @@
 import { Context } from "effect";
 export class DaemonPolicy extends Context.Service()("@velum-labs/routekit-daemon/DaemonPolicy") {
 }
+export const wantsCliproxySidecar = (config) => Object.values(config.sources).some((source) => source.use === "cliproxy");

package/dist/daemon-runtime-state.d.ts

@@ -30,7 +30,7 @@ export declare class DaemonRuntimeState {
     markClosed(): void;
     pause(): void;
     resume(): void;
-    awaitMutations(): Effect.Effect<void>;
+    get awaitMutations(): Effect.Effect<void>;
     serializeEffect<T, E = never, R = never>(operation: Effect.Effect<T, E, R>): Effect.Effect<T, E | Error, R>;
     snapshot(): DaemonRuntimeSnapshot;
 }

package/dist/daemon-runtime-state.js

@@ -74,9 +74,8 @@ export class DaemonRuntimeState {
         if (this.#lifecycle === "paused")
             this.#lifecycle = "running";
     }
-    awaitMutations() {
-        const self = this;
-        return Effect.suspend(() => self.#mutationTail);
+    get awaitMutations() {
+        return Effect.suspend(() => this.#mutationTail);
     }
     serializeEffect(operation) {
         const self = this;

package/dist/daemon-state-context.d.ts

@@ -1,7 +1,7 @@
 import { Context, Layer } from "effect";
 import type { DaemonRuntimeState } from "./daemon-runtime-state.js";
 export type DaemonStateService = Omit<DaemonRuntimeState, "awaitMutations"> & {
-    readonly awaitMutations: ReturnType<DaemonRuntimeState["awaitMutations"]>;
+    readonly awaitMutations: DaemonRuntimeState["awaitMutations"];
 };
 declare const DaemonState_base: Context.ServiceClass<DaemonState, "@velum-labs/routekit-daemon/DaemonState", DaemonStateService>;
 export declare class DaemonState extends DaemonState_base {

package/dist/daemon-state-context.js

@@ -1,43 +1,6 @@
 import { Context, Layer } from "effect";
 export class DaemonState extends Context.Service()("@velum-labs/routekit-daemon/DaemonState") {
     static layer(state) {
-        return Layer.succeed(DaemonState, DaemonState.of({
-            get config() {
-                return state.config;
-            },
-            set config(config) {
-                state.config = config;
-            },
-            get document() {
-                return state.document;
-            },
-            set document(document) {
-                state.document = document;
-            },
-            get revisions() {
-                return state.revisions;
-            },
-            set revisions(revisions) {
-                state.revisions = revisions;
-            },
-            get lifecycle() {
-                return state.lifecycle;
-            },
-            get draining() {
-                return state.draining;
-            },
-            get closed() {
-                return state.closed;
-            },
-            beginShutdown: state.beginShutdown.bind(state),
-            beginRetire: state.beginRetire.bind(state),
-            markDraining: state.markDraining.bind(state),
-            markClosed: state.markClosed.bind(state),
-            pause: state.pause.bind(state),
-            resume: state.resume.bind(state),
-            awaitMutations: state.awaitMutations(),
-            serializeEffect: state.serializeEffect.bind(state),
-            snapshot: state.snapshot.bind(state)
-        }));
+        return Layer.succeed(DaemonState, state);
     }
 }

package/dist/doctor-service.d.ts

@@ -1,7 +1,5 @@
 import type { EffectRouteKitControlHandlers } from "@velum-labs/routekit-control/effect";
 type DoctorHandlers = Pick<EffectRouteKitControlHandlers, "doctor.run">;
 /** Owns daemon diagnostic checks for local configuration and live providers. */
-export declare class DoctorApplicationService {
-    handlers(): DoctorHandlers;
-}
+export declare const doctorHandlers: DoctorHandlers;
 export {};

package/dist/doctor-service.js

@@ -5,99 +5,95 @@ import { accountEntries } from "./daemon-maintenance.js";
 import { AccountRecovery } from "./account-recovery-context.js";
 import { ActiveGateway } from "./services/active-gateway/service.js";
 import { DaemonEnv } from "./daemon-env-context.js";
-import { DaemonPolicy } from "./daemon-policy-context.js";
+import { wantsCliproxySidecar } from "./daemon-policy-context.js";
 import { DaemonState } from "./daemon-state-context.js";
 import { Sidecar } from "./sidecar-context.js";
 /** Owns daemon diagnostic checks for local configuration and live providers. */
-export class DoctorApplicationService {
-    handlers() {
-        return {
-            "doctor.run": (_params, context) => Effect.gen(function* () {
-                const env = yield* DaemonEnv;
-                const state = yield* DaemonState;
-                const sidecar = yield* Sidecar;
-                const gateway = yield* ActiveGateway;
-                const recovery = yield* AccountRecovery;
-                const policy = yield* DaemonPolicy;
-                const providers = yield* gateway.router().providerStatuses(context.signal);
-                const configuredProviders = configuredProviderIds(state.config);
-                const accounts = accountEntries(env.env);
-                const missingProviders = [
-                    ...new Set(accounts
-                        .filter((entry) => {
-                        const provider = entry.connector === "cliproxy" ? "cliproxy" : entry.subscriptionKind;
-                        return state.config.providers[provider] === undefined;
-                    })
-                        .map((entry) => entry.subscriptionKind))
-                ];
-                const providerOnly = ["claude-code", "codex", "cliproxy"].filter((provider) => state.config.providers[provider] !== undefined &&
-                    !accounts.some((entry) => provider === "cliproxy"
-                        ? entry.connector === "cliproxy"
-                        : entry.subscriptionKind === provider));
-                const consistent = missingProviders.length === 0 && providerOnly.length === 0;
-                const cliproxyCheck = policy.wantsCliproxySidecar(state.config)
-                    ? [
-                        {
-                            name: "cliproxy sidecar",
-                            ok: yield* sidecar.reachable(),
-                            detail: sidecar.managed()
-                                ? sidecar.running()
-                                    ? "managed; running"
-                                    : "managed; not running"
-                                : "external"
-                        }
-                    ]
-                    : [];
-                return {
-                    checks: [
-                        {
-                            name: "canonical config",
-                            ok: existsSync(env.configPath),
-                            detail: env.configPath
-                        },
-                        { name: "control plane", ok: gateway.control() !== undefined },
-                        {
-                            name: "model gateway",
-                            ok: gateway.proxy() !== undefined,
-                            detail: gateway.dataUrl()
-                        },
-                        {
-                            name: "provider configuration",
-                            ok: configuredProviders.length > 0,
-                            detail: configuredProviders.length > 0
-                                ? `${configuredProviders.length} provider(s) configured`
-                                : "no providers configured; run `routekit providers add <provider>`"
-                        },
-                        {
-                            name: "account activation recovery",
-                            ok: true,
-                            detail: recovery.recovered > 0
-                                ? `recovered ${recovery.recovered} interrupted operation(s)`
-                                : "clean"
-                        },
-                        {
-                            name: "account/provider consistency",
-                            ok: consistent,
-                            detail: consistent
-                                ? "consistent"
-                                : [
-                                    ...(missingProviders.length > 0
-                                        ? [`routing disabled: ${missingProviders.join(", ")}`]
-                                        : []),
-                                    ...(providerOnly.length > 0
-                                        ? [`credential missing: ${providerOnly.join(", ")}`]
-                                        : [])
-                                ].join("; ")
-                        },
-                        ...cliproxyCheck,
-                        ...providers.map((provider) => ({
-                            name: `${provider.provider} live discovery`,
-                            ok: provider.ok,
-                            detail: provider.error ?? `${provider.models.length} model(s)`
-                        }))
-                    ]
-                };
+export const doctorHandlers = {
+    "doctor.run": (_params, context) => Effect.gen(function* () {
+        const env = yield* DaemonEnv;
+        const state = yield* DaemonState;
+        const sidecar = yield* Sidecar;
+        const gateway = yield* ActiveGateway;
+        const recovery = yield* AccountRecovery;
+        const providers = yield* gateway.router().providerStatuses(context.signal);
+        const configuredProviders = configuredProviderIds(state.config);
+        const configuredModules = new Set(Object.values(state.config.sources).map((source) => source.use));
+        const accounts = accountEntries(env.env);
+        const missingProviders = [
+            ...new Set(accounts
+                .filter((entry) => {
+                const provider = entry.connector === "cliproxy" ? "cliproxy" : entry.subscriptionKind;
+                return !configuredModules.has(provider);
             })
+                .map((entry) => entry.subscriptionKind))
+        ];
+        const providerOnly = ["claude-code", "codex", "cliproxy"].filter((provider) => configuredModules.has(provider) &&
+            !accounts.some((entry) => provider === "cliproxy"
+                ? entry.connector === "cliproxy"
+                : entry.subscriptionKind === provider));
+        const consistent = missingProviders.length === 0 && providerOnly.length === 0;
+        const cliproxyCheck = wantsCliproxySidecar(state.config)
+            ? [
+                {
+                    name: "cliproxy sidecar",
+                    ok: yield* sidecar.reachable(),
+                    detail: sidecar.managed()
+                        ? sidecar.running()
+                            ? "managed; running"
+                            : "managed; not running"
+                        : "external"
+                }
+            ]
+            : [];
+        return {
+            checks: [
+                {
+                    name: "canonical config",
+                    ok: existsSync(env.configPath),
+                    detail: env.configPath
+                },
+                { name: "control plane", ok: gateway.control() !== undefined },
+                {
+                    name: "model gateway",
+                    ok: gateway.proxy() !== undefined,
+                    detail: gateway.dataUrl()
+                },
+                {
+                    name: "provider configuration",
+                    ok: configuredProviders.length > 0,
+                    detail: configuredProviders.length > 0
+                        ? `${configuredProviders.length} provider(s) configured`
+                        : "no providers configured; run `routekit providers add <provider>`"
+                },
+                {
+                    name: "account activation recovery",
+                    ok: true,
+                    detail: recovery.recovered > 0
+                        ? `recovered ${recovery.recovered} interrupted operation(s)`
+                        : "clean"
+                },
+                {
+                    name: "account/provider consistency",
+                    ok: consistent,
+                    detail: consistent
+                        ? "consistent"
+                        : [
+                            ...(missingProviders.length > 0
+                                ? [`routing disabled: ${missingProviders.join(", ")}`]
+                                : []),
+                            ...(providerOnly.length > 0
+                                ? [`credential missing: ${providerOnly.join(", ")}`]
+                                : [])
+                        ].join("; ")
+                },
+                ...cliproxyCheck,
+                ...providers.map((provider) => ({
+                    name: `${provider.provider} live discovery`,
+                    ok: provider.ok,
+                    detail: provider.error ?? `${provider.models.length} model(s)`
+                }))
+            ]
         };
-    }
-}
+    })
+};

package/dist/effect/daemon-live.d.ts

@@ -1,22 +1,23 @@
 import { AccountActivity, AccountAuth } from "@velum-labs/routekit-accounts/effect";
 import { Layer } from "effect";
-import type { RouteKitDaemonOptions } from "../daemon-options.js";
 import { AccountRecovery } from "../account-recovery-context.js";
-import { ActiveGateway } from "../services/active-gateway/service.js";
-import { CallAttributions } from "../services/call-attributions/service.js";
 import { DaemonEnv } from "../daemon-env-context.js";
 import { DaemonHost } from "../daemon-host-context.js";
+import type { RouteKitDaemonOptions } from "../daemon-options.js";
 import { DaemonPolicy } from "../daemon-policy-context.js";
-import { DaemonRuntime } from "../services/daemon-runtime/service.js";
 import { DaemonState } from "../daemon-state-context.js";
 import { DataPlane } from "../data-plane-context.js";
+import { Leaderboard } from "../leaderboard-context.js";
+import { ActiveGateway } from "../services/active-gateway/service.js";
+import { CallAttributions } from "../services/call-attributions/service.js";
+import { DaemonRuntime } from "../services/daemon-runtime/service.js";
 import { EvalSessions } from "../services/eval-session/service.js";
 import { Generations } from "../services/generations/service.js";
-import { Leaderboard } from "../leaderboard-context.js";
-import { Sidecar } from "../sidecar-context.js";
 import { Telemetry } from "../services/telemetry/service.js";
 import { Tokens } from "../services/tokens/service.js";
+import { Sidecar } from "../sidecar-context.js";
 export type DaemonLiveOptions = RouteKitDaemonOptions;
+/** Published daemon Effect services; private construction services stay internal. */
 export type DaemonLive = DaemonRuntime | DaemonEnv | DaemonState | Sidecar | Tokens | EvalSessions | Telemetry | ActiveGateway | AccountActivity | AccountAuth | Generations | DataPlane | AccountRecovery | CallAttributions | Leaderboard | DaemonPolicy | DaemonHost;
 /** Construct and own the complete daemon worker lifetime. */
 export declare function daemonLive(options: DaemonLiveOptions): Layer.Layer<DaemonLive, Error>;