@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/launcher-service.js

@@ -6,144 +6,155 @@ import { Effect } from "effect";
 import { ActiveGateway } from "./services/active-gateway/service.js";
 import { LauncherSessions } from "./services/launcher-session/service.js";
 import { Tokens } from "./services/tokens/service.js";
-/** Owns coding-tool launch preparation against the live catalog. */
-export class LauncherApplicationService {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    handlers() {
-        const options = this.options;
-        return {
-            "launcher.prepare": (params, context) => Effect.gen(function* () {
-                const listed = yield* options.listModels({}, {
-                    signal: context.signal,
-                    requestId: "internal"
-                });
-                return yield* Effect.gen(function* () {
-                    const requestedModel = params.model?.trim();
-                    const modelProfile = requestedModel?.toLowerCase().startsWith("auto:")
-                        ? requestedModel.slice("auto:".length)
-                        : undefined;
-                    const routingProfile = params.routingProfile ?? modelProfile;
-                    if (params.routingProfile !== undefined && modelProfile !== undefined) {
-                        if (params.routingProfile !== modelProfile) {
-                            return yield* Effect.fail(new ControlError({
-                                code: "bad_request",
-                                message: "routingProfile conflicts with the model profile selector"
-                            }));
-                        }
-                    }
-                    else if (params.routingProfile !== undefined &&
-                        requestedModel !== undefined &&
-                        requestedModel.toLowerCase() !== "auto") {
+/** Bind coding-tool launch preparation to the live catalog's handler. */
+export function launcherHandlers({ listModels }) {
+    return {
+        "launcher.prepare": (params, context) => Effect.gen(function* () {
+            const listed = yield* listModels({}, {
+                signal: context.signal,
+                requestId: "internal"
+            });
+            return yield* Effect.gen(function* () {
+                const requestedModel = params.model?.trim();
+                const modelProfile = requestedModel?.toLowerCase().startsWith("auto:")
+                    ? requestedModel.slice("auto:".length)
+                    : undefined;
+                const routingProfile = params.routingProfile ?? modelProfile;
+                if (params.routingProfile !== undefined && modelProfile !== undefined) {
+                    if (params.routingProfile !== modelProfile) {
                         return yield* Effect.fail(new ControlError({
                             code: "bad_request",
-                            message: "routingProfile may be used only with model auto or an omitted model"
-                        }));
-                    }
-                    let launcherAuthToken;
-                    if (routingProfile !== undefined) {
-                        const cwd = resolve(params.cwd ?? ".");
-                        const repositoryRoot = yield* Effect.try({
-                            try: () => {
-                                const root = findRepositoryRoutingProfileRoot(cwd, routingProfile);
-                                if (root === undefined) {
-                                    throw new Error(`routing profile ${JSON.stringify(routingProfile)} was not found from ${cwd}`);
-                                }
-                                loadRepositoryRoutingProfile({ repositoryRoot: root, name: routingProfile });
-                                return root;
-                            },
-                            catch: (cause) => new ControlError({
-                                code: "not_found",
-                                message: cause instanceof Error
-                                    ? cause.message
-                                    : `routing profile ${JSON.stringify(routingProfile)} was not found`
-                            })
-                        });
-                        const launcherSessions = yield* LauncherSessions;
-                        launcherAuthToken = launcherSessions.open({
-                            repositoryRoot,
-                            profileName: routingProfile,
-                            role: context.principal === undefined || context.principal.role === "ephemeral"
-                                ? "owner"
-                                : context.principal.role
-                        });
-                    }
-                    let model = routingProfile === undefined
-                        ? (params.model ?? listed.defaultModel ?? listed.models[0]?.id)
-                        : `auto:${routingProfile}`;
-                    let codexSelection;
-                    if (params.tool === "codex" && routingProfile === undefined) {
-                        const gateway = yield* ActiveGateway;
-                        const candidates = listed.models.flatMap((entry) => {
-                            const info = gateway.router().modelInfo(entry.id);
-                            if (info === undefined)
-                                return [];
-                            return [
-                                {
-                                    id: info.id,
-                                    nativeId: info.nativeModel,
-                                    provider: info.provider,
-                                    billingScope: info.billingMode,
-                                    ...(info.createdAt !== undefined ? { createdAt: info.createdAt } : {}),
-                                    ...(info.providerPriority !== undefined
-                                        ? { providerPriority: info.providerPriority }
-                                        : {}),
-                                    ...(info.metadata?.architecture !== undefined
-                                        ? { architecture: info.metadata.architecture }
-                                        : {}),
-                                    ...(info.metadata?.supportedParameters !== undefined
-                                        ? { supportedParameters: info.metadata.supportedParameters }
-                                        : {}),
-                                    ...(info.reasoning !== null ? { reasoning: info.reasoning } : {})
-                                }
-                            ];
-                        });
-                        const selected = yield* resolveCodexStartupModel({
-                            models: candidates,
-                            ...(listed.defaultModel !== undefined
-                                ? { preferredModel: listed.defaultModel }
-                                : {}),
-                            ...(params.model !== undefined ? { requestedModel: params.model } : {}),
-                            signal: context.signal
-                        }).pipe(Effect.mapError((error) => {
-                            const message = error instanceof Error ? error.message : String(error);
-                            return new ControlError({
-                                code: params.model !== undefined && message.startsWith("unknown model")
-                                    ? "not_found"
-                                    : "unavailable",
-                                message
-                            });
+                            message: "routingProfile conflicts with the model profile selector"
                         }));
-                        model = selected.model;
-                        codexSelection = {
-                            compatibleModelIds: [...selected.compatibleModelIds],
-                            models: [...selected.models]
-                        };
                     }
-                    if (model === undefined ||
-                        (routingProfile === undefined && !listed.models.some((entry) => entry.id === model))) {
-                        return yield* Effect.fail(new ControlError({
+                }
+                else if (params.routingProfile !== undefined &&
+                    requestedModel !== undefined &&
+                    requestedModel.toLowerCase() !== "auto") {
+                    return yield* Effect.fail(new ControlError({
+                        code: "bad_request",
+                        message: "routingProfile may be used only with model auto or an omitted model"
+                    }));
+                }
+                let routingContext;
+                if (routingProfile !== undefined) {
+                    const cwd = resolve(params.cwd ?? ".");
+                    const repositoryRoot = yield* Effect.try({
+                        try: () => {
+                            const root = findRepositoryRoutingProfileRoot(cwd, routingProfile);
+                            if (root === undefined) {
+                                throw new Error(`routing profile ${JSON.stringify(routingProfile)} was not found from ${cwd}`);
+                            }
+                            loadRepositoryRoutingProfile({ repositoryRoot: root, name: routingProfile });
+                            return root;
+                        },
+                        catch: (cause) => new ControlError({
                             code: "not_found",
-                            message: params.model === undefined
-                                ? "no model is available"
-                                : `unknown model: ${params.model}`
-                        }));
-                    }
+                            message: cause instanceof Error
+                                ? cause.message
+                                : `routing profile ${JSON.stringify(routingProfile)} was not found`
+                        })
+                    });
+                    routingContext = { repositoryRoot, profileName: routingProfile };
+                }
+                let model = routingProfile === undefined
+                    ? (params.model ?? listed.defaultModel ?? listed.models[0]?.id)
+                    : `auto:${routingProfile}`;
+                let codexSelection;
+                if (params.tool === "codex" && routingProfile === undefined) {
                     const gateway = yield* ActiveGateway;
-                    const tokens = yield* Tokens;
-                    const authToken = launcherAuthToken ?? (yield* tokens.dataTokenForPrincipal(context.principal));
-                    return {
-                        tool: params.tool,
-                        model,
-                        gatewayUrl: gateway.dataUrl() ?? "",
-                        authToken,
-                        env: {},
-                        ...(codexSelection !== undefined ? { codexSelection } : {})
+                    const candidates = listed.models.flatMap((entry) => {
+                        const info = gateway.router().modelInfo(entry.id);
+                        if (info === undefined)
+                            return [];
+                        const candidate = {
+                            id: info.id,
+                            nativeId: info.nativeModel,
+                            provider: info.provider,
+                            billingScope: info.billingMode
+                        };
+                        if (info.createdAt !== undefined)
+                            candidate.createdAt = info.createdAt;
+                        if (info.providerPriority !== undefined) {
+                            candidate.providerPriority = info.providerPriority;
+                        }
+                        if (info.metadata?.architecture !== undefined) {
+                            candidate.architecture = info.metadata.architecture;
+                        }
+                        if (info.metadata?.supportedParameters !== undefined) {
+                            candidate.supportedParameters = info.metadata.supportedParameters;
+                        }
+                        const capabilities = {};
+                        for (const name of ["responses", "tools"]) {
+                            const status = info.capabilities[name];
+                            if (status === "supported" ||
+                                status === "unsupported" ||
+                                status === "degraded" ||
+                                status === "unknown") {
+                                capabilities[name] = status;
+                            }
+                        }
+                        if (Object.keys(capabilities).length > 0) {
+                            candidate.capabilities = capabilities;
+                        }
+                        if (info.reasoning !== null)
+                            candidate.reasoning = info.reasoning;
+                        return [candidate];
+                    });
+                    const selected = yield* resolveCodexStartupModel({
+                        models: candidates,
+                        ...(listed.defaultModel !== undefined ? { preferredModel: listed.defaultModel } : {}),
+                        ...(params.model !== undefined ? { requestedModel: params.model } : {}),
+                        signal: context.signal
+                    }).pipe(Effect.mapError((error) => {
+                        const message = error instanceof Error ? error.message : String(error);
+                        return new ControlError({
+                            code: params.model !== undefined && message.startsWith("unknown model")
+                                ? "not_found"
+                                : "unavailable",
+                            message
+                        });
+                    }));
+                    model = selected.model;
+                    codexSelection = {
+                        compatibleModelIds: [...selected.compatibleModelIds],
+                        models: [...selected.models]
                     };
-                });
-            })
-        };
-    }
+                }
+                if (model === undefined ||
+                    (routingProfile === undefined && !listed.models.some((entry) => entry.id === model))) {
+                    return yield* Effect.fail(new ControlError({
+                        code: "not_found",
+                        message: params.model === undefined
+                            ? "no model is available"
+                            : `unknown model: ${params.model}`
+                    }));
+                }
+                const gateway = yield* ActiveGateway;
+                const tokens = yield* Tokens;
+                const gatewayUrl = gateway.dataUrl() ?? "";
+                let authToken;
+                if (routingContext === undefined) {
+                    authToken = yield* tokens.dataTokenForPrincipal(context.principal);
+                }
+                else {
+                    const launcherSessions = yield* LauncherSessions;
+                    authToken = launcherSessions.open({
+                        ...routingContext,
+                        role: context.principal === undefined || context.principal.role === "ephemeral"
+                            ? "owner"
+                            : context.principal.role
+                    });
+                }
+                return {
+                    tool: params.tool,
+                    model,
+                    gatewayUrl,
+                    authToken,
+                    env: {},
+                    ...(codexSelection !== undefined ? { codexSelection } : {})
+                };
+            });
+        })
+    };
 }

package/dist/provider-modules.d.ts

@@ -0,0 +1,6 @@
+import { ProviderModuleRegistry } from "@velum-labs/routekit-provider-core";
+export declare const providerModules: ProviderModuleRegistry;
+export declare function validateProviderModules(registry: ProviderModuleRegistry): ProviderModuleRegistry;
+export declare function currentProviderModules(): ProviderModuleRegistry;
+/** Install an alternate registry for one in-process test and return its restore operation. */
+export declare function installProviderModulesForTest(registry: ProviderModuleRegistry): () => void;

package/dist/provider-modules.js

@@ -0,0 +1,55 @@
+import { anthropic } from "./internal-providers/provider-anthropic/index.js";
+import { azure } from "./internal-providers/provider-azure/index.js";
+import { bedrock } from "./internal-providers/provider-bedrock/index.js";
+import { claudeCode } from "./internal-providers/provider-claude-code/index.js";
+import { cliproxy } from "./internal-providers/provider-cliproxy/index.js";
+import { codex } from "./internal-providers/provider-codex/index.js";
+import { ProviderModuleRegistry } from "@velum-labs/routekit-provider-core";
+import { custom } from "./internal-providers/provider-custom/index.js";
+import { google } from "./internal-providers/provider-google/index.js";
+import { googleVertex } from "./internal-providers/provider-google-vertex/index.js";
+import { openai } from "./internal-providers/provider-openai/index.js";
+import { openaiCompatible } from "./internal-providers/provider-openai-compatible/index.js";
+import { openrouter } from "./internal-providers/provider-openrouter/index.js";
+import { providerModuleInfo } from "@velum-labs/routekit-registry";
+export const providerModules = new ProviderModuleRegistry([
+    openai,
+    anthropic,
+    bedrock,
+    google,
+    openrouter,
+    cliproxy,
+    claudeCode,
+    codex,
+    openaiCompatible,
+    custom,
+    azure,
+    googleVertex
+]);
+export function validateProviderModules(registry) {
+    for (const module of registry.list()) {
+        const catalog = providerModuleInfo(module.id);
+        if (catalog === undefined) {
+            throw new Error(`provider module "${module.id}" is missing its catalog row`);
+        }
+        if (catalog.protocol !== module.protocol ||
+            catalog.accountClass !== module.accountClass ||
+            catalog.billingMode !== module.billingMode) {
+            throw new Error(`provider module "${module.id}" disagrees with its catalog row`);
+        }
+    }
+    return registry;
+}
+validateProviderModules(providerModules);
+let activeProviderModules = providerModules;
+export function currentProviderModules() {
+    return activeProviderModules;
+}
+/** Install an alternate registry for one in-process test and return its restore operation. */
+export function installProviderModulesForTest(registry) {
+    const previous = activeProviderModules;
+    activeProviderModules = validateProviderModules(registry);
+    return () => {
+        activeProviderModules = previous;
+    };
+}

package/dist/provider-query-service.d.ts

@@ -1,7 +1,5 @@
 import type { EffectRouteKitControlHandlers } from "@velum-labs/routekit-control/effect";
 type ProviderHandlers = Pick<EffectRouteKitControlHandlers, "providers.status" | "models.list" | "models.info" | "calls.inspect" | "calls.leaderboard">;
 /** Owns provider health, catalog, inspection, and leaderboard queries. */
-export declare class ProviderQueryService {
-    handlers(): ProviderHandlers;
-}
+export declare const providerHandlers: ProviderHandlers;
 export {};

package/dist/provider-query-service.js

@@ -10,150 +10,147 @@ import { accountEntriesEffect, providerCredentialAvailable } from "./daemon-main
 import { writeSnapshotEffect } from "./daemon-state.js";
 import { aggregateInspections, buildLeaderboardResult, defaultLeaderboardWindow } from "./leaderboard.js";
 /** Owns provider health, catalog, inspection, and leaderboard queries. */
-export class ProviderQueryService {
-    handlers() {
-        return {
-            "providers.status": (_params, context) => Effect.gen(function* () {
-                const env = yield* DaemonEnv;
-                const state = yield* DaemonState;
-                const gateway = yield* ActiveGateway;
-                const accounts = yield* accountEntriesEffect(env.env);
-                const live = yield* gateway.router().providerStatuses(context.signal);
-                const result = {
-                    providers: configuredProviderIds(state.config).map((provider) => {
-                        const status = live.find((entry) => entry.provider === provider);
-                        return {
-                            provider,
-                            configured: true,
-                            credentialAvailable: providerCredentialAvailable(provider, accounts, env.env),
-                            models: status?.models ?? [],
-                            ...(status?.error !== undefined ? { error: status.error } : {})
-                        };
-                    })
-                };
-                yield* writeSnapshotEffect(env.home, "health", "providers", {
-                    checkedAt: new Date().toISOString(),
-                    providers: result.providers
-                });
-                return result;
-            }),
-            "models.list": (params) => Effect.gen(function* () {
-                const env = yield* DaemonEnv;
-                const state = yield* DaemonState;
-                const gateway = yield* ActiveGateway;
-                const catalog = gateway.router().modelCatalog();
-                const models = catalog
-                    .filter((model) => params.provider === undefined || model.id.startsWith(`${params.provider}/`))
-                    .map((model) => ({
-                    id: model.id,
-                    provider: model.provider,
-                    owned_by: model.provider,
-                    routekit_provider_priority: model.providerPriority,
-                    capabilities: { ...model.capabilities },
-                    ...(model.metadata?.architecture !== undefined
-                        ? {
-                            architecture: {
-                                modality: model.metadata.architecture.modality,
-                                input_modalities: model.metadata.architecture.inputModalities,
-                                output_modalities: model.metadata.architecture.outputModalities
-                            }
-                        }
-                        : {}),
-                    ...(model.metadata?.supportedParameters !== undefined
-                        ? { supported_parameters: model.metadata.supportedParameters }
-                        : {}),
-                    reasoning: model.reasoning === null || model.reasoning === undefined
-                        ? undefined
-                        : { ...model.reasoning }
-                }));
-                const result = {
-                    models,
-                    ...(state.config.defaultModel !== undefined
-                        ? { defaultModel: state.config.defaultModel }
-                        : catalog.some((model) => model.default)
-                            ? { defaultModel: catalog.find((model) => model.default)?.id }
-                            : {}),
-                    revision: state.revisions.config
-                };
-                yield* writeSnapshotEffect(env.home, "catalog", "models", {
-                    updatedAt: new Date().toISOString(),
-                    defaultModel: result.defaultModel,
-                    models
-                });
-                return result;
-            }),
-            "models.info": (params) => Effect.gen(function* () {
-                const gateway = yield* ActiveGateway;
-                const model = gateway.router().modelInfo(params.model);
-                if (model === undefined) {
-                    return yield* Effect.fail(new ControlError({
-                        code: "not_found",
-                        message: `unknown model: ${params.model}`
-                    }));
-                }
+export const providerHandlers = {
+    "providers.status": (_params, context) => Effect.gen(function* () {
+        const env = yield* DaemonEnv;
+        const state = yield* DaemonState;
+        const gateway = yield* ActiveGateway;
+        const accounts = yield* accountEntriesEffect(env.env);
+        const live = yield* gateway.router().providerStatuses(context.signal);
+        const result = {
+            providers: configuredProviderIds(state.config).map((provider) => {
+                const source = state.config.sources[provider];
+                const status = live.find((entry) => entry.provider === provider);
                 return {
-                    ...model,
-                    capabilities: { ...model.capabilities },
-                    reasoning: model.reasoning === null ? null : { ...model.reasoning }
+                    provider,
+                    configured: true,
+                    credentialAvailable: providerCredentialAvailable(source, accounts, env.env),
+                    models: status?.models ?? [],
+                    ...(status?.error !== undefined ? { error: status.error } : {})
                 };
-            }),
-            "calls.inspect": (params) => Effect.gen(function* () {
-                const attributions = yield* CallAttributions;
-                const inspection = attributions.get(params.callId);
-                if (inspection === undefined) {
-                    return yield* Effect.fail(new ControlError({
-                        code: "not_found",
-                        message: `unknown or expired model call: ${params.callId}`
-                    }));
-                }
-                return inspection;
-            }),
-            "calls.leaderboard": (params) => Effect.gen(function* () {
-                const attributions = yield* CallAttributions;
-                const leaderboard = yield* Leaderboard;
-                const config = leaderboard.config();
-                const by = params.by ?? "principal";
-                const sort = params.sort ?? "cost";
-                const limit = params.limit ?? 20;
-                const window = params.window ?? defaultLeaderboardWindow(config);
-                const nowIso = new Date().toISOString();
-                if (window === "live") {
-                    const aggregated = aggregateInspections(attributions.list(), {
-                        by,
-                        sort,
-                        limit
-                    });
-                    return buildLeaderboardResult({
-                        by,
-                        sort,
-                        source: "live",
-                        windowStart: aggregated.windowStart ?? nowIso,
-                        windowEnd: aggregated.windowEnd ?? nowIso,
-                        sampleSize: aggregated.sampleSize,
-                        truncated: attributions.truncated(),
-                        budget: config,
-                        rows: aggregated.rows
-                    });
-                }
-                if (!config.durable) {
-                    return yield* Effect.fail(new ControlError({
-                        code: "bad_request",
-                        message: "durable leaderboard rollups are disabled; set leaderboard.durable: true in router.yaml"
-                    }));
-                }
-                const aggregated = leaderboard.rollups.query({ by, sort, limit, window });
-                return buildLeaderboardResult({
-                    by,
-                    sort,
-                    source: "durable",
-                    windowStart: aggregated.windowStart,
-                    windowEnd: aggregated.windowEnd,
-                    sampleSize: aggregated.sampleSize,
-                    truncated: false,
-                    budget: config,
-                    rows: aggregated.rows
-                });
             })
         };
-    }
-}
+        yield* writeSnapshotEffect(env.home, "health", "providers", {
+            checkedAt: new Date().toISOString(),
+            providers: result.providers
+        });
+        return result;
+    }),
+    "models.list": (params) => Effect.gen(function* () {
+        const env = yield* DaemonEnv;
+        const state = yield* DaemonState;
+        const gateway = yield* ActiveGateway;
+        const catalog = gateway.router().modelCatalog();
+        const models = catalog
+            .filter((model) => params.provider === undefined || model.id.startsWith(`${params.provider}/`))
+            .map((model) => ({
+            id: model.id,
+            provider: model.provider,
+            owned_by: model.provider,
+            routekit_provider_priority: model.providerPriority,
+            capabilities: { ...model.capabilities },
+            ...(model.metadata?.architecture !== undefined
+                ? {
+                    architecture: {
+                        modality: model.metadata.architecture.modality,
+                        input_modalities: model.metadata.architecture.inputModalities,
+                        output_modalities: model.metadata.architecture.outputModalities
+                    }
+                }
+                : {}),
+            ...(model.metadata?.supportedParameters !== undefined
+                ? { supported_parameters: model.metadata.supportedParameters }
+                : {}),
+            reasoning: model.reasoning === null || model.reasoning === undefined
+                ? undefined
+                : { ...model.reasoning }
+        }));
+        const result = {
+            models,
+            ...(state.config.defaultModel !== undefined
+                ? { defaultModel: state.config.defaultModel }
+                : catalog.some((model) => model.default)
+                    ? { defaultModel: catalog.find((model) => model.default)?.id }
+                    : {}),
+            revision: state.revisions.config
+        };
+        yield* writeSnapshotEffect(env.home, "catalog", "models", {
+            updatedAt: new Date().toISOString(),
+            defaultModel: result.defaultModel,
+            models
+        });
+        return result;
+    }),
+    "models.info": (params) => Effect.gen(function* () {
+        const gateway = yield* ActiveGateway;
+        const model = gateway.router().modelInfo(params.model);
+        if (model === undefined) {
+            return yield* Effect.fail(new ControlError({
+                code: "not_found",
+                message: `unknown model: ${params.model}`
+            }));
+        }
+        return {
+            ...model,
+            capabilities: { ...model.capabilities },
+            reasoning: model.reasoning === null ? null : { ...model.reasoning }
+        };
+    }),
+    "calls.inspect": (params) => Effect.gen(function* () {
+        const attributions = yield* CallAttributions;
+        const inspection = attributions.get(params.callId);
+        if (inspection === undefined) {
+            return yield* Effect.fail(new ControlError({
+                code: "not_found",
+                message: `unknown or expired model call: ${params.callId}`
+            }));
+        }
+        return inspection;
+    }),
+    "calls.leaderboard": (params) => Effect.gen(function* () {
+        const attributions = yield* CallAttributions;
+        const leaderboard = yield* Leaderboard;
+        const config = leaderboard.config();
+        const by = params.by ?? "principal";
+        const sort = params.sort ?? "cost";
+        const limit = params.limit ?? 20;
+        const window = params.window ?? defaultLeaderboardWindow(config);
+        const nowIso = new Date().toISOString();
+        if (window === "live") {
+            const aggregated = aggregateInspections(attributions.list(), {
+                by,
+                sort,
+                limit
+            });
+            return buildLeaderboardResult({
+                by,
+                sort,
+                source: "live",
+                windowStart: aggregated.windowStart ?? nowIso,
+                windowEnd: aggregated.windowEnd ?? nowIso,
+                sampleSize: aggregated.sampleSize,
+                truncated: attributions.truncated(),
+                budget: config,
+                rows: aggregated.rows
+            });
+        }
+        if (!config.durable) {
+            return yield* Effect.fail(new ControlError({
+                code: "bad_request",
+                message: "durable leaderboard rollups are disabled; set leaderboard.durable: true in router.yaml"
+            }));
+        }
+        const aggregated = leaderboard.rollups.query({ by, sort, limit, window });
+        return buildLeaderboardResult({
+            by,
+            sort,
+            source: "durable",
+            windowStart: aggregated.windowStart,
+            windowEnd: aggregated.windowEnd,
+            sampleSize: aggregated.sampleSize,
+            truncated: false,
+            budget: config,
+            rows: aggregated.rows
+        });
+    })
+};

package/dist/router-generation-service.d.ts

@@ -1,7 +1,5 @@
 import type { EffectRouteKitControlHandlers } from "@velum-labs/routekit-control/effect";
 type RouterHandlers = Pick<EffectRouteKitControlHandlers, "daemon.reload" | "config.get" | "config.update" | "config.import" | "providers.set">;
 /** Owns config mutations and generation publication use cases. */
-export declare class RouterGenerationService {
-    handlers(): RouterHandlers;
-}
+export declare const routerGenerationHandlers: RouterHandlers;
 export {};