@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/router-generation-service.js

@@ -9,16 +9,25 @@ import { Generations } from "./services/generations/service.js";
 const updateProviderDocument = (document, provider, enabled) => Effect.try({
     try: () => {
         const raw = parseYaml(document);
-        const providers = typeof raw.providers === "object" &&
-            raw.providers !== null &&
-            !Array.isArray(raw.providers)
-            ? { ...raw.providers }
-            : {};
+        const sources = typeof raw.sources === "object" && raw.sources !== null && !Array.isArray(raw.sources)
+            ? { ...raw.sources }
+            : typeof raw.providers === "object" &&
+                raw.providers !== null &&
+                !Array.isArray(raw.providers)
+                ? Object.fromEntries(Object.entries(raw.providers).map(([id, policy]) => [
+                    id,
+                    {
+                        use: id,
+                        ...(typeof policy === "object" && policy !== null ? { pool: policy } : {})
+                    }
+                ]))
+                : {};
         if (enabled)
-            providers[provider] ??= {};
+            sources[provider] ??= { use: provider };
         else
-            delete providers[provider];
-        raw.providers = providers;
+            delete sources[provider];
+        raw.sources = sources;
+        delete raw.providers;
         return stringifyYaml(raw);
     },
     catch: toRouteKitFailure
@@ -28,74 +37,70 @@ const revisionConflict = (expected, actual) => new ControlError({
     message: `revision conflict: expected ${expected}, current ${actual}`,
     details: { expected, actual }
 });
-/** Owns config mutations and generation publication use cases. */
-export class RouterGenerationService {
-    handlers() {
-        const snapshot = (configPath, runtimeState) => ({
-            path: configPath,
-            document: runtimeState.document,
-            revision: runtimeState.revisions.config
-        });
-        const update = (params) => Effect.gen(function* () {
-            const env = yield* DaemonEnv;
-            const runtimeState = yield* DaemonState;
-            const generations = yield* Generations;
-            return yield* runtimeState.serializeEffect(Effect.gen(function* () {
-                if (params.expectedRevision !== runtimeState.revisions.config) {
-                    return yield* Effect.fail(revisionConflict(params.expectedRevision, runtimeState.revisions.config));
-                }
-                const config = yield* parseConfigDocumentEffect(params.document);
-                yield* generations.replace(config, params.document, {
-                    write: true,
-                    configRevision: true
-                });
-                return snapshot(env.configPath, runtimeState);
-            }));
+const snapshot = (configPath, runtimeState) => ({
+    path: configPath,
+    document: runtimeState.document,
+    revision: runtimeState.revisions.config
+});
+const update = (params) => Effect.gen(function* () {
+    const env = yield* DaemonEnv;
+    const runtimeState = yield* DaemonState;
+    const generations = yield* Generations;
+    return yield* runtimeState.serializeEffect(Effect.gen(function* () {
+        if (params.expectedRevision !== runtimeState.revisions.config) {
+            return yield* Effect.fail(revisionConflict(params.expectedRevision, runtimeState.revisions.config));
+        }
+        const config = yield* parseConfigDocumentEffect(params.document);
+        yield* generations.replace(config, params.document, {
+            write: true,
+            configRevision: true
         });
-        return {
-            "daemon.reload": (params) => Effect.gen(function* () {
-                const env = yield* DaemonEnv;
-                const runtimeState = yield* DaemonState;
-                const generations = yield* Generations;
-                return yield* runtimeState.serializeEffect(Effect.gen(function* () {
-                    if (params.expectedRevision !== undefined &&
-                        params.expectedRevision !== runtimeState.revisions.config) {
-                        return yield* Effect.fail(revisionConflict(params.expectedRevision, runtimeState.revisions.config));
-                    }
-                    const document = yield* canonicalConfigDocumentEffect(env.configPath);
-                    const config = yield* parseConfigDocumentEffect(document);
-                    yield* generations.replace(config, document, {
-                        write: false,
-                        configRevision: true
-                    });
-                    return {
-                        reloaded: true,
-                        configRevision: runtimeState.revisions.config,
-                        accountRevision: runtimeState.revisions.accounts
-                    };
-                }));
-            }),
-            "config.get": () => Effect.gen(function* () {
-                const env = yield* DaemonEnv;
-                const runtimeState = yield* DaemonState;
-                return snapshot(env.configPath, runtimeState);
-            }),
-            "config.update": update,
-            "config.import": update,
-            "providers.set": (params) => Effect.gen(function* () {
-                const env = yield* DaemonEnv;
-                const runtimeState = yield* DaemonState;
-                const generations = yield* Generations;
-                return yield* runtimeState.serializeEffect(Effect.gen(function* () {
-                    const document = yield* updateProviderDocument(runtimeState.document, params.provider, params.enabled);
-                    const config = yield* parseConfigDocumentEffect(document);
-                    yield* generations.replace(config, document, {
-                        write: true,
-                        configRevision: true
-                    });
-                    return snapshot(env.configPath, runtimeState);
-                }));
-            })
-        };
-    }
-}
+        return snapshot(env.configPath, runtimeState);
+    }));
+});
+/** Owns config mutations and generation publication use cases. */
+export const routerGenerationHandlers = {
+    "daemon.reload": (params) => Effect.gen(function* () {
+        const env = yield* DaemonEnv;
+        const runtimeState = yield* DaemonState;
+        const generations = yield* Generations;
+        return yield* runtimeState.serializeEffect(Effect.gen(function* () {
+            if (params.expectedRevision !== undefined &&
+                params.expectedRevision !== runtimeState.revisions.config) {
+                return yield* Effect.fail(revisionConflict(params.expectedRevision, runtimeState.revisions.config));
+            }
+            const document = yield* canonicalConfigDocumentEffect(env.configPath);
+            const config = yield* parseConfigDocumentEffect(document);
+            yield* generations.replace(config, document, {
+                write: false,
+                configRevision: true
+            });
+            return {
+                reloaded: true,
+                configRevision: runtimeState.revisions.config,
+                accountRevision: runtimeState.revisions.accounts
+            };
+        }));
+    }),
+    "config.get": () => Effect.gen(function* () {
+        const env = yield* DaemonEnv;
+        const runtimeState = yield* DaemonState;
+        return snapshot(env.configPath, runtimeState);
+    }),
+    "config.update": update,
+    "config.import": update,
+    "providers.set": (params) => Effect.gen(function* () {
+        const env = yield* DaemonEnv;
+        const runtimeState = yield* DaemonState;
+        const generations = yield* Generations;
+        return yield* runtimeState.serializeEffect(Effect.gen(function* () {
+            const document = yield* updateProviderDocument(runtimeState.document, params.provider, params.enabled);
+            const config = yield* parseConfigDocumentEffect(document);
+            yield* generations.replace(config, document, {
+                write: true,
+                configRevision: true
+            });
+            return snapshot(env.configPath, runtimeState);
+        }));
+    })
+};

package/dist/services/eval-session/service.d.ts

@@ -1,7 +1,9 @@
-import type { EvalSessionLimits, EvalSessionPurpose, RouteKitControlResults } from "@velum-labs/routekit-control";
+import type { EvalSessionEvidenceRequired, EvalSessionExecutionEvidence, EvalSessionLimits, EvalSessionPurpose, HttpSubmissionBinding, RouteKitControlParams, RouteKitControlResults } from "@velum-labs/routekit-control";
 import type { EffectRouteKitControlHandlers } from "@velum-labs/routekit-control/effect";
 import type { GatewayPrincipal } from "@velum-labs/routekit-gateway";
-import { Context, Layer } from "effect";
+import { type HttpSubmissionAuthorityService, HttpSubmissionError } from "@velum-labs/routekit-runtime/effect";
+import { Context, Effect, Layer } from "effect";
+import { type EvalSessionExecutionStore } from "../../eval-session-execution-store.js";
 export type OpenEvalSessionInput = {
     purpose: EvalSessionPurpose;
     operationId: string;
@@ -10,27 +12,37 @@ export type OpenEvalSessionInput = {
     expiresInSeconds: number;
     gatewayUrl: string;
     targetIdentity: string;
+    evidenceRequired?: EvalSessionEvidenceRequired;
 };
 export type EvalSessionManagerOptions = {
     now?: () => number;
     random?: (bytes: number) => Buffer;
+    store?: EvalSessionExecutionStore;
 };
-/** Daemon-owned, memory-only registry for short-lived eval credentials. */
+/** Ephemeral bearer credentials with a separate durable, payload-free execution authority. */
 export declare class EvalSessionManager {
     #private;
     constructor(options?: EvalSessionManagerOptions);
     open(input: OpenEvalSessionInput): RouteKitControlResults["evalSession.open"];
+    initialize(): Effect.Effect<void, HttpSubmissionError>;
+    openEffect(input: OpenEvalSessionInput): Effect.Effect<RouteKitControlResults["evalSession.open"], HttpSubmissionError>;
     close(sessionId: string): boolean;
+    closeEffect(sessionId: string): Effect.Effect<boolean, HttpSubmissionError>;
+    bindIngress(sessionId: string, input: {
+        requestDigest: string;
+        model: string;
+    }): Effect.Effect<HttpSubmissionBinding, HttpSubmissionError>;
+    resolveSubmission(binding: HttpSubmissionBinding): Effect.Effect<HttpSubmissionAuthorityService, HttpSubmissionError>;
+    executionEvidence(identity: RouteKitControlParams["evalSession.executionEvidence"]): Effect.Effect<EvalSessionExecutionEvidence, HttpSubmissionError>;
+    shutdown(): Effect.Effect<void, HttpSubmissionError>;
     closeAll(): void;
     resolve(presented: string): GatewayPrincipal | undefined;
 }
 declare const EvalSessions_base: Context.ServiceClass<EvalSessions, "@velum-labs/routekit-daemon/EvalSessions", EvalSessionManager>;
 export declare class EvalSessions extends EvalSessions_base {
-    static layer(options?: EvalSessionManagerOptions): Layer.Layer<EvalSessions, never, never>;
+    static layer(options?: EvalSessionManagerOptions): Layer.Layer<EvalSessions, HttpSubmissionError, never>;
 }
-type EvalSessionHandlers = Pick<EffectRouteKitControlHandlers, "evalSession.open" | "evalSession.close">;
+type EvalSessionHandlers = Pick<EffectRouteKitControlHandlers, "evalSession.open" | "evalSession.close" | "evalSession.executionEvidence">;
 /** Owns short-lived, model-restricted eval data-plane sessions. */
-export declare class EvalSessionApplicationService {
-    handlers(): EvalSessionHandlers;
-}
+export declare const evalSessionHandlers: EvalSessionHandlers;
 export {};