@velum-labs/routekit-gateway 1.2.0 → 1.3.1

package/README.md

@@ -26,3 +26,10 @@ API-key providers use registry-defined credentials and URLs. Multi-account
 subscription providers and relays are in `@velum-labs/routekit-accounts`; they expose the
 same source interface with per-model account eligibility and quota-aware
 selection. RouteKit hosts wire this package into the singleton daemon gateway.
+
+Compositional routing accepts explicit named repository selectors as
+`model: "auto:<name>"`, or as `x-routekit-routing-profile: <name>` with
+`model: "auto"`. The host supplies trusted repository context (the singleton
+uses its repository-bound launcher credential); request headers never select a
+filesystem root. The gateway rejects malformed, unbound, and conflicting
+selectors before routing.

package/dist/adapters/anthropic-models.js

@@ -62,7 +62,7 @@ export function resolveClaudeModelSelection(requested, modelIds = [], modelRoute
     }
     if (requested.startsWith(CLAUDE_PICKER_PREFIX)) {
         const candidate = requested.slice(CLAUDE_PICKER_PREFIX.length);
-        if (modelIds.includes(candidate)) {
+        if (modelIds.includes(candidate) || candidate.startsWith("auto:")) {
             return {
                 status: "resolved",
                 model: candidate,

package/dist/endpoints/responses-endpoint.js

@@ -5,7 +5,7 @@ import { prepareResponsesReasoningInput, wrapResponsesReasoningResponse } from "
 import { handleResponses } from "../adapters/responses.js";
 import { decodeValidatedResponsesRequest, validateResponsesRequest } from "../adapters/validate.js";
 import { gatewayTry } from "../effect/gateway.js";
-import { compositionalRoutingAttribution, evalAutoRouterRejection, evalRequestAttribution, resolveConfiguredAutoRoutingModel } from "../routing/eval-policy.js";
+import { compositionalRoutingAttribution, evalAutoRouterRejection, evalRequestAttribution, isAutoRoutingModel, resolveConfiguredAutoRoutingModel } from "../routing/eval-policy.js";
 import { extractClassifiableRequestText } from "../routing/classifier.js";
 import { UnknownModelError } from "../routing/router.js";
 import { deriveRoutingRequirements } from "../routing/requirements.js";
@@ -62,7 +62,7 @@ function executeResponsesRequest(dependencies, request) {
             });
             return;
         }
-        if (decodedBody.model?.trim().toLowerCase() === "auto" &&
+        if (isAutoRoutingModel(decodedBody.model) &&
             decodedBody.previous_response_id != null) {
             context.transport.writeJson(400, {
                 error: {

package/dist/http/auth.d.ts

@@ -5,6 +5,10 @@ export type GatewayPrincipal = {
     id: string;
     label: string;
     role: "owner" | "admin" | "eval";
+    routing?: {
+        repositoryRoot: string;
+        profileName: string;
+    };
     evalSession?: {
         sessionId: string;
         allowedModels: readonly string[];

package/dist/http/auth.js

@@ -4,6 +4,8 @@
  * so neither content nor length differences are observable through timing.
  */
 import { createPublicKey, timingSafeEqual, verify } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { ROUTING_PROFILE_NAME_PATTERN } from "@velum-labs/routekit-config-core";
 /** Trusted principal header injected by the switching proxy after auth. */
 export const ROUTEKIT_PRINCIPAL_HEADER = "x-routekit-principal";
 function decodeJwtPart(value) {
@@ -198,10 +200,28 @@ export function parsePrincipalHeader(value) {
             : undefined;
         if (parsed.role === "eval" && evalSession === undefined)
             return undefined;
+        const routing = parsed.role !== "eval" &&
+            parsed.routing !== undefined &&
+            typeof parsed.routing === "object" &&
+            parsed.routing !== null &&
+            typeof parsed.routing.repositoryRoot === "string" &&
+            parsed.routing.repositoryRoot.length > 0 &&
+            parsed.routing.repositoryRoot.length <= 4_096 &&
+            isAbsolute(parsed.routing.repositoryRoot) &&
+            typeof parsed.routing.profileName === "string" &&
+            ROUTING_PROFILE_NAME_PATTERN.test(parsed.routing.profileName)
+            ? {
+                repositoryRoot: parsed.routing.repositoryRoot,
+                profileName: parsed.routing.profileName
+            }
+            : undefined;
+        if (parsed.routing !== undefined && routing === undefined)
+            return undefined;
         return {
             id: parsed.id,
             label: parsed.label,
             role: parsed.role,
+            ...(routing === undefined ? {} : { routing }),
             ...(evalSession === undefined ? {} : { evalSession })
         };
     }

package/dist/index.d.ts

@@ -34,7 +34,7 @@ export { endpointHealthProbe, probeEndpointHealth, providerAuthHeaders } from ".
 export type { EndpointPipeline } from "./endpoint-pipeline.js";
 export { runEndpointPipeline } from "./endpoint-pipeline.js";
 export type { CompositionalRoutingObservation, CompositionalRoutingPolicyReader, CompositionalRoutingRuntime } from "./routing/eval-policy.js";
-export { AutoRoutingUnavailableError, compositionalRoutingAttribution, compositionalRoutingPolicyReaderFromActivation, EvalAutoRoutingForbiddenError, RoutingPolicyReadError, resolveCompositionalAutoRoutingModel, resolveConfiguredAutoRoutingModel } from "./routing/eval-policy.js";
+export { AutoRoutingUnavailableError, compositionalRoutingAttribution, compositionalRoutingPolicyReaderFromActivation, EvalAutoRoutingForbiddenError, isAutoRoutingModel, RoutingPolicyReadError, resolveCompositionalAutoRoutingModel, resolveConfiguredAutoRoutingModel } from "./routing/eval-policy.js";
 export { invokeObservedModelCall } from "./model-call-service.js";
 export type { OpenAiBackendOptions } from "./providers/openai-backend.js";
 export { OpenAiBackend } from "./providers/openai-backend.js";

package/dist/index.js

@@ -17,7 +17,7 @@ export { CompositionalRoutingError, routeCompositionalRequest } from "./routing/
 export { DEFAULT_MODEL_PRICING, estimateCost, formatUsd, lookupPricing, meterCall, parseUsage, parseUsageFromSse } from "./observability/cost.js";
 export { endpointHealthProbe, probeEndpointHealth, providerAuthHeaders } from "./endpoint-health-service.js";
 export { runEndpointPipeline } from "./endpoint-pipeline.js";
-export { AutoRoutingUnavailableError, compositionalRoutingAttribution, compositionalRoutingPolicyReaderFromActivation, EvalAutoRoutingForbiddenError, RoutingPolicyReadError, resolveCompositionalAutoRoutingModel, resolveConfiguredAutoRoutingModel } from "./routing/eval-policy.js";
+export { AutoRoutingUnavailableError, compositionalRoutingAttribution, compositionalRoutingPolicyReaderFromActivation, EvalAutoRoutingForbiddenError, isAutoRoutingModel, RoutingPolicyReadError, resolveCompositionalAutoRoutingModel, resolveConfiguredAutoRoutingModel } from "./routing/eval-policy.js";
 export { invokeObservedModelCall } from "./model-call-service.js";
 export { OpenAiBackend } from "./providers/openai-backend.js";
 export { buildModelCallRecord, MODEL_CALL_ID_HEADER, modelCallId, readProducerVersion, resolveProducerGitSha, responseBodyHash, UNKNOWN_GIT_SHA } from "./observability/provenance.js";

package/dist/routing/eval-policy.d.ts

@@ -17,10 +17,10 @@ export declare class RoutingPolicyReadError extends RoutingPolicyReadError_base<
 }
 /** Read-only online projection of the authoritative routing activation. */
 export type CompositionalRoutingPolicyReader = Readonly<{
-    getActivation(): Effect.Effect<AnyPublishedRoutingActivation | undefined, RoutingPolicyReadError, RouteKitPlatform>;
+    getActivation(profileName?: string, repositoryRoot?: string): Effect.Effect<AnyPublishedRoutingActivation | undefined, RoutingPolicyReadError, RouteKitPlatform>;
 }>;
 export declare function compositionalRoutingPolicyReaderFromActivation(activation: AnyPublishedRoutingActivation | undefined): CompositionalRoutingPolicyReader;
-export declare function authoritativeRoutingActivation(reader: CompositionalRoutingPolicyReader): Effect.Effect<AnyPublishedRoutingActivation | undefined, RoutingPolicyReadError, RouteKitPlatform>;
+export declare function authoritativeRoutingActivation(reader: CompositionalRoutingPolicyReader, profileName?: string, repositoryRoot?: string): Effect.Effect<AnyPublishedRoutingActivation | undefined, RoutingPolicyReadError, RouteKitPlatform>;
 declare const AutoRoutingUnavailableError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "AutoRoutingUnavailableError";
 } & Readonly<A>;
@@ -58,6 +58,7 @@ export type CompositionalRoutingRuntime = Readonly<{
 export declare function compositionalRoutingAttribution(observation: Extract<CompositionalRoutingObservation, {
     status: "decided";
 }>): NonNullable<RequestAttribution["compositional_routing"]>;
+export declare function isAutoRoutingModel(model: unknown): boolean;
 export declare function evalPolicyBypassRequested(headers: IncomingHttpHeaders): boolean;
 export declare function evalRequestAttribution(headers: IncomingHttpHeaders): NonNullable<RequestAttribution["eval"]> | undefined;
 /** Reject eval traffic that would fall through to the auto-router. */
@@ -76,6 +77,7 @@ export declare function resolveCompositionalAutoRoutingModel(options: Readonly<{
     objective: RoutingObjectivePolicy;
     maximumUnknownWeight: number;
     constraints?: RoutingScoreConstraints;
+    profileName?: string;
     onDecision?(decision: AutoRoutingDecision, classifierCallId?: string): void;
 }>): Effect.Effect<string | undefined, AutoRoutingUnavailableError | EvalAutoRoutingForbiddenError, RouteKitPlatform>;
 /** Apply the authoritative dimension-decomposition and evidence-matrix auto-router. */

package/dist/routing/eval-policy.js

@@ -1,4 +1,5 @@
-import { COMPOSITIONAL_ROUTING_VERSION, EVAL_ATTRIBUTION_HEADER, EVAL_POLICY_BYPASS_HEADER, isForbiddenEvalModel } from "@velum-labs/routekit-eval-contracts";
+import { ROUTING_PROFILE_NAME_PATTERN } from "@velum-labs/routekit-config-core";
+import { COMPOSITIONAL_ROUTING_VERSION, EVAL_ATTRIBUTION_HEADER, EVAL_POLICY_BYPASS_HEADER, isForbiddenEvalModel, ROUTING_PROFILE_HEADER } from "@velum-labs/routekit-eval-contracts";
 import { Data, Effect } from "effect";
 import { parsePrincipalHeader, ROUTEKIT_PRINCIPAL_HEADER } from "../http/auth.js";
 import { classifyRequestDimensions, validateDecompositionResult } from "../routing/classifier.js";
@@ -12,8 +13,8 @@ export function compositionalRoutingPolicyReaderFromActivation(activation) {
         getActivation: () => Effect.succeed(activation)
     };
 }
-export function authoritativeRoutingActivation(reader) {
-    return reader.getActivation();
+export function authoritativeRoutingActivation(reader, profileName, repositoryRoot) {
+    return reader.getActivation(profileName, repositoryRoot);
 }
 export class AutoRoutingUnavailableError extends Data.TaggedError("AutoRoutingUnavailableError") {
 }
@@ -91,6 +92,56 @@ function firstHeader(headers, name) {
     const normalized = raw?.trim();
     return normalized === undefined || normalized.length === 0 ? undefined : normalized;
 }
+function autoRoutingModelProfile(model) {
+    const normalized = model?.trim();
+    if (normalized === undefined || normalized.length === 0)
+        return { auto: false };
+    if (normalized.toLowerCase() === "auto")
+        return { auto: true, valid: true };
+    if (!normalized.toLowerCase().startsWith("auto:"))
+        return { auto: false };
+    const profileName = normalized.slice("auto:".length);
+    return {
+        auto: true,
+        profileName,
+        valid: ROUTING_PROFILE_NAME_PATTERN.test(profileName)
+    };
+}
+export function isAutoRoutingModel(model) {
+    return typeof model === "string" && autoRoutingModelProfile(model).auto;
+}
+function autoRoutingSelector(headers, model) {
+    const parsedModel = autoRoutingModelProfile(model);
+    if (!parsedModel.auto)
+        return undefined;
+    if (!parsedModel.valid) {
+        throw new Error(`model routing profile must match ${String(ROUTING_PROFILE_NAME_PATTERN)}`);
+    }
+    const modelProfile = parsedModel.profileName;
+    const headerProfile = firstHeader(headers, ROUTING_PROFILE_HEADER);
+    const principal = parsePrincipalHeader(firstHeader(headers, ROUTEKIT_PRINCIPAL_HEADER));
+    const boundProfile = principal?.routing?.profileName;
+    if (headerProfile !== undefined && !ROUTING_PROFILE_NAME_PATTERN.test(headerProfile)) {
+        throw new Error(`routing profile header must match ${String(ROUTING_PROFILE_NAME_PATTERN)}`);
+    }
+    if (modelProfile !== undefined && headerProfile !== undefined && modelProfile !== headerProfile) {
+        throw new Error(`model routing profile ${JSON.stringify(modelProfile)} conflicts with header profile ${JSON.stringify(headerProfile)}`);
+    }
+    const requestedProfile = modelProfile ?? headerProfile;
+    if (requestedProfile !== undefined &&
+        boundProfile !== undefined &&
+        requestedProfile !== boundProfile) {
+        throw new Error(`requested routing profile ${JSON.stringify(requestedProfile)} conflicts with launcher profile ${JSON.stringify(boundProfile)}`);
+    }
+    return {
+        ...((requestedProfile ?? boundProfile) === undefined
+            ? {}
+            : { profileName: requestedProfile ?? boundProfile }),
+        ...(principal?.routing?.repositoryRoot === undefined
+            ? {}
+            : { repositoryRoot: principal.routing.repositoryRoot })
+    };
+}
 export function evalPolicyBypassRequested(headers) {
     const raw = firstHeader(headers, EVAL_POLICY_BYPASS_HEADER);
     if (raw !== "1" && raw?.toLowerCase() !== "true")
@@ -135,7 +186,7 @@ export function evalRequestAttribution(headers) {
 export function evalAutoRouterRejection(headers, model) {
     if (!evalPolicyBypassRequested(headers))
         return undefined;
-    if (typeof model !== "string" || isForbiddenEvalModel(model)) {
+    if (typeof model !== "string" || isForbiddenEvalModel(model) || isAutoRoutingModel(model)) {
         return "eval requests must name an explicit provider/model id";
     }
     const principal = evalSessionPrincipal(headers);
@@ -148,7 +199,7 @@ export function evalAutoRouterRejection(headers, model) {
  * Resolve `model: "auto"` against the model-by-dimension evidence matrix.
  */
 export function resolveCompositionalAutoRoutingModel(options) {
-    if (options.model?.trim().toLowerCase() !== "auto") {
+    if (!isAutoRoutingModel(options.model)) {
         return Effect.succeed(options.model);
     }
     if (evalPolicyBypassRequested(options.headers)) {
@@ -173,33 +224,35 @@ export function resolveCompositionalAutoRoutingModel(options) {
     const classifier = options.classifier;
     return Effect.gen(function* () {
         const readSnapshot = yield* Effect.try({
-            try: () => reader.getActivation(),
+            try: () => reader.getActivation(options.profileName),
             catch: (cause) => new AutoRoutingUnavailableError({
-                profileId: undefined,
+                profileId: options.profileName,
                 message: "failed to read the compositional routing snapshot",
                 cause
             })
         });
         const snapshot = yield* readSnapshot.pipe(Effect.mapError((cause) => new AutoRoutingUnavailableError({
-            profileId: undefined,
+            profileId: options.profileName,
             message: "failed to read the compositional routing snapshot",
             cause
         })));
         if (snapshot === undefined) {
             return yield* new AutoRoutingUnavailableError({
-                profileId: undefined,
-                message: "no compositional routing snapshot is available"
+                profileId: options.profileName,
+                message: options.profileName === undefined
+                    ? "no compositional routing snapshot is available"
+                    : `no compositional routing snapshot is available for profile ${JSON.stringify(options.profileName)}`
             });
         }
         if (snapshot.version !== COMPOSITIONAL_ROUTING_VERSION) {
             return yield* new AutoRoutingUnavailableError({
-                profileId: undefined,
+                profileId: options.profileName,
                 message: "the compositional routing snapshot is not a V2 activation"
             });
         }
         if (classifier.model !== undefined && classifier.model !== snapshot.classifierModel) {
             return yield* new AutoRoutingUnavailableError({
-                profileId: undefined,
+                profileId: options.profileName,
                 message: `published routing activation requires classifier ${JSON.stringify(snapshot.classifierModel)}, but the running router is bound to ${JSON.stringify(classifier.model)}`
             });
         }
@@ -207,7 +260,7 @@ export function resolveCompositionalAutoRoutingModel(options) {
             request: requestText,
             dimensions: snapshot.dimensions
         }).pipe(Effect.mapError((error) => new AutoRoutingUnavailableError({
-            profileId: undefined,
+            profileId: options.profileName,
             message: error.message,
             cause: error
         })));
@@ -216,7 +269,7 @@ export function resolveCompositionalAutoRoutingModel(options) {
             basisDigest: snapshot.basisDigest,
             dimensions: snapshot.dimensions
         }).pipe(Effect.mapError((error) => new AutoRoutingUnavailableError({
-            profileId: undefined,
+            profileId: options.profileName,
             message: error.message,
             cause: error
         })));
@@ -234,7 +287,7 @@ export function resolveCompositionalAutoRoutingModel(options) {
             maximumUnknownWeight: snapshot.maximumUnknownWeight,
             ...(snapshot.constraints === undefined ? {} : { constraints: snapshot.constraints })
         }).pipe(Effect.mapError((cause) => new AutoRoutingUnavailableError({
-            profileId: undefined,
+            profileId: options.profileName,
             message: cause.message,
             cause
         })));
@@ -284,7 +337,7 @@ function resolveAuthoritativeV3(options) {
         options.onDecision(decision, classifierCallId);
         return decision.selectedModel;
     }).pipe(Effect.mapError((cause) => new AutoRoutingUnavailableError({
-        profileId: undefined,
+        profileId: options.profileName,
         message: cause instanceof V3AuthoritativeRoutingFailure
             ? `authoritative compositional routing failed: ${cause.reason}`
             : "authoritative compositional routing failed",
@@ -294,7 +347,18 @@ function resolveAuthoritativeV3(options) {
 /** Apply the authoritative dimension-decomposition and evidence-matrix auto-router. */
 export function resolveConfiguredAutoRoutingModel(options) {
     const runtime = options.compositionalRouting;
-    if (options.model?.trim().toLowerCase() !== "auto")
+    let selector;
+    try {
+        selector = autoRoutingSelector(options.headers, options.model);
+    }
+    catch (cause) {
+        return Effect.fail(new AutoRoutingUnavailableError({
+            profileId: undefined,
+            message: cause instanceof Error ? cause.message : String(cause),
+            cause
+        }));
+    }
+    if (selector === undefined)
         return Effect.succeed(options.model);
     if (evalPolicyBypassRequested(options.headers))
         return Effect.fail(new EvalAutoRoutingForbiddenError({
@@ -309,15 +373,15 @@ export function resolveConfiguredAutoRoutingModel(options) {
         runtime.onObservation?.(observation);
         options.onCompositionalObservation?.(observation);
     };
-    const resolved = authoritativeRoutingActivation(runtime.policyReader).pipe(Effect.mapError((cause) => new AutoRoutingUnavailableError({
-        profileId: undefined,
+    const resolved = authoritativeRoutingActivation(runtime.policyReader, selector.profileName, selector.repositoryRoot).pipe(Effect.mapError((cause) => new AutoRoutingUnavailableError({
+        profileId: selector.profileName,
         message: "failed to read the compositional routing deployment",
         cause
     })), Effect.flatMap((activation) => {
         if (activation?.version === 3) {
             if (options.requestBody === undefined || options.dialect === undefined)
                 return Effect.fail(new AutoRoutingUnavailableError({
-                    profileId: undefined,
+                    profileId: selector.profileName,
                     message: "authoritative compositional routing requires a request body and dialect"
                 }));
             return resolveAuthoritativeV3({
@@ -327,6 +391,7 @@ export function resolveConfiguredAutoRoutingModel(options) {
                 requirements: options.requirements,
                 classifier: runtime.classifier,
                 availableModels: runtime.availableModels,
+                ...(selector.profileName === undefined ? {} : { profileName: selector.profileName }),
                 onDecision: (decision, classifierCallId) => observe({
                     status: "decided",
                     decision,
@@ -346,6 +411,7 @@ export function resolveConfiguredAutoRoutingModel(options) {
             objective: runtime.objective,
             maximumUnknownWeight: runtime.maximumUnknownWeight,
             ...(runtime.constraints === undefined ? {} : { constraints: runtime.constraints }),
+            ...(selector.profileName === undefined ? {} : { profileName: selector.profileName }),
             onDecision: (decision, classifierCallId) => observe({
                 status: "decided",
                 decision,

package/dist/routing-api.d.ts

@@ -1,5 +1,6 @@
 export type { DimensionDecompositionOperation, LanguageModelDimensionClassifierOptions, ObservedDecompositionResult } from "./routing/classifier.js";
 export { CLASSIFIABLE_REQUEST_TEXT_LIMIT, ClassificationError, classifyRequestDimensions, extractClassifiableRequestText, makeFakeDimensionDecomposition, makeLanguageModelDimensionClassifier, parseDecompositionResult, validateDecompositionInput, validateDecompositionResult } from "./routing/classifier.js";
+export { isAutoRoutingModel } from "./routing/eval-policy.js";
 export { fakeDimensionRequestDecomposerLayer, languageModelDimensionRequestDecomposerLayer } from "./routing/dimension-request-decomposer.js";
 export type { RequestDecomposerService } from "./services/request-decomposer/service.js";
 export { RequestDecomposer } from "./services/request-decomposer/service.js";

package/dist/routing-api.js

@@ -1,4 +1,5 @@
 export { CLASSIFIABLE_REQUEST_TEXT_LIMIT, ClassificationError, classifyRequestDimensions, extractClassifiableRequestText, makeFakeDimensionDecomposition, makeLanguageModelDimensionClassifier, parseDecompositionResult, validateDecompositionInput, validateDecompositionResult } from "./routing/classifier.js";
+export { isAutoRoutingModel } from "./routing/eval-policy.js";
 export { fakeDimensionRequestDecomposerLayer, languageModelDimensionRequestDecomposerLayer } from "./routing/dimension-request-decomposer.js";
 export { RequestDecomposer } from "./services/request-decomposer/service.js";
 export { isSubscriptionProvider, modelPolicyAllowsModel, modelPolicyRuleMatches, NoModelAvailableError, RoutingBackend, UnknownModelError } from "./routing/router.js";

package/dist/test/anthropic.test.js

@@ -44,6 +44,12 @@ test("Claude selection accepts picker ids and unique native ids but rejects coll
         clientModel: "anthropic.routekit.codex/gpt-5.5",
         selection: { mode: "auto" }
     });
+    assert.deepEqual(resolveClaudeModelSelection("anthropic.routekit.auto:quality", []), {
+        status: "resolved",
+        model: "auto:quality",
+        clientModel: "anthropic.routekit.auto:quality",
+        selection: { mode: "auto" }
+    });
     assert.deepEqual(resolveClaudeModelSelection("gpt-5.5", ["openai/gpt-5.5", "fast"], [
         { publicId: "openai/gpt-5.5", nativeId: "gpt-5.5", provider: "openai", reasoning },
         { publicId: "fast", nativeId: "gpt-5.5", provider: "openai", reasoning }

package/dist/test/auth.test.js

@@ -47,6 +47,23 @@ test("parsePrincipalHeader accepts only well-formed JSON principals", () => {
         label: "bob",
         role: "admin"
     });
+    assert.deepEqual(parsePrincipalHeader(JSON.stringify({
+        id: "launcher-token",
+        label: "launcher:quality",
+        role: "owner",
+        routing: {
+            repositoryRoot: "/workspace/repository",
+            profileName: "quality"
+        }
+    })), {
+        id: "launcher-token",
+        label: "launcher:quality",
+        role: "owner",
+        routing: {
+            repositoryRoot: "/workspace/repository",
+            profileName: "quality"
+        }
+    });
     assert.deepEqual(parsePrincipalHeader(JSON.stringify({
         id: "eval-token",
         label: "eval-session",
@@ -67,6 +84,7 @@ test("parsePrincipalHeader accepts only well-formed JSON principals", () => {
         }
     });
     assert.equal(parsePrincipalHeader('{"id":"eval-token","label":"eval-session","role":"eval"}'), undefined);
+    assert.equal(parsePrincipalHeader('{"id":"launcher","label":"launcher:quality","role":"owner","routing":{"repositoryRoot":"relative","profileName":"quality"}}'), undefined);
     assert.equal(parsePrincipalHeader('{"id":"a","label":"bob","role":"root"}'), undefined);
     assert.equal(parsePrincipalHeader("not-json"), undefined);
 });

package/dist/test/compositional-routing.test.js

@@ -3,7 +3,9 @@ import { readFileSync } from "node:fs";
 import test from "node:test";
 import { Effect } from "effect";
 import { activationRevisionDigest, COMPOSITIONAL_ROUTING_VERSION } from "@velum-labs/routekit-eval-contracts";
+import { ROUTING_PROFILE_HEADER } from "@velum-labs/routekit-eval-contracts";
 import { runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
+import { ROUTEKIT_PRINCIPAL_HEADER } from "../http/auth.js";
 import { CompositionalRoutingError, routeCompositionalRequest } from "../routing/compositional.js";
 import { AutoRoutingUnavailableError, compositionalRoutingPolicyReaderFromActivation, resolveCompositionalAutoRoutingModel, resolveConfiguredAutoRoutingModel } from "../routing/eval-policy.js";
 import { fakeDimensionRequestDecomposerLayer } from "../routing/dimension-request-decomposer.js";
@@ -291,6 +293,97 @@ test("configured auto routing uses only dimension decomposition and matrix scori
     assert.equal(resolved, "openai/beta");
     assert.deepEqual(observations, ["decided:openai/beta"]);
 });
+test("configured auto routing selects a named profile from model or header", async () => {
+    const selectedProfiles = [];
+    const policyReader = {
+        getActivation: (profileName) => {
+            selectedProfiles.push(profileName);
+            return Effect.succeed(snapshot());
+        }
+    };
+    const compositionalRouting = {
+        policyReader,
+        classifier: fakeRequestDecomposer({
+            weights: decomposition().weights,
+            unknownWeight: 0
+        }),
+        availableModels,
+        objective: { kind: "highest-quality" },
+        maximumUnknownWeight: 0.25
+    };
+    assert.equal(await runRouteKitEffect(resolveConfiguredAutoRoutingModel({
+        headers: {},
+        model: "auto:quality",
+        requestText: "Implement a change",
+        requirements,
+        compositionalRouting
+    })), "openai/beta");
+    assert.equal(await runRouteKitEffect(resolveConfiguredAutoRoutingModel({
+        headers: { [ROUTING_PROFILE_HEADER]: "cost" },
+        model: "auto",
+        requestText: "Implement a change",
+        requirements,
+        compositionalRouting
+    })), "openai/beta");
+    assert.deepEqual(selectedProfiles, ["quality", "cost"]);
+    await assert.rejects(runRouteKitEffect(resolveConfiguredAutoRoutingModel({
+        headers: { [ROUTING_PROFILE_HEADER]: "cost" },
+        model: "auto:quality",
+        requestText: "Implement a change",
+        requirements,
+        compositionalRouting
+    })), /conflicts with header profile/);
+});
+test("configured auto routing uses trusted launcher context and rejects profile changes", async () => {
+    const reads = [];
+    const routingPrincipal = JSON.stringify({
+        id: "launcher-token",
+        label: "launcher:quality",
+        role: "owner",
+        routing: {
+            repositoryRoot: "/workspace/repository",
+            profileName: "quality"
+        }
+    });
+    const compositionalRouting = {
+        policyReader: {
+            getActivation: (profileName, repositoryRoot) => {
+                reads.push({ profileName, repositoryRoot });
+                return Effect.succeed(snapshot());
+            }
+        },
+        classifier: fakeRequestDecomposer({
+            weights: decomposition().weights,
+            unknownWeight: 0
+        }),
+        availableModels,
+        objective: { kind: "highest-quality" },
+        maximumUnknownWeight: 0.25
+    };
+    assert.equal(await runRouteKitEffect(resolveConfiguredAutoRoutingModel({
+        headers: { [ROUTEKIT_PRINCIPAL_HEADER]: routingPrincipal },
+        model: "auto",
+        requestText: "Implement a change",
+        requirements,
+        compositionalRouting
+    })), "openai/beta");
+    assert.deepEqual(reads, [
+        {
+            profileName: "quality",
+            repositoryRoot: "/workspace/repository"
+        }
+    ]);
+    await assert.rejects(runRouteKitEffect(resolveConfiguredAutoRoutingModel({
+        headers: {
+            [ROUTEKIT_PRINCIPAL_HEADER]: routingPrincipal,
+            [ROUTING_PROFILE_HEADER]: "cost"
+        },
+        model: "auto",
+        requestText: "Implement a change",
+        requirements,
+        compositionalRouting
+    })), /conflicts with launcher profile/);
+});
 test("configured auto routing fails closed and observes missing evidence", async () => {
     const observations = [];
     await assert.rejects(runRouteKitEffect(resolveConfiguredAutoRoutingModel({
@@ -494,7 +587,6 @@ test("authoritative V3 incomplete callers fail closed and are observed", async (
             onObservation: (observation) => observations.push(observation)
         }
     })), (error) => error instanceof AutoRoutingUnavailableError &&
-        error.message ===
-            "authoritative compositional routing requires a request body and dialect");
+        error.message === "authoritative compositional routing requires a request body and dialect");
     assert.deepEqual(observations.map((observation) => observation.status), ["failed"]);
 });

package/dist/test/eval-policy.test.js

@@ -27,6 +27,7 @@ test("eval bypass requires a trusted eval-session principal", () => {
 test("eval sessions reject auto and models outside their allowlist", () => {
     const headers = evalHeaders(["openai/gpt-5.6-luna"]);
     assert.match(evalAutoRouterRejection(headers, "auto") ?? "", /explicit provider\/model/);
+    assert.match(evalAutoRouterRejection(headers, "auto:quality") ?? "", /explicit provider\/model/);
     assert.match(evalAutoRouterRejection(headers, "openai/gpt-5.6-terra") ?? "", /not authorized/);
     assert.equal(evalAutoRouterRejection(headers, "openai/gpt-5.6-luna"), undefined);
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "1.2.0",
+  "version": "1.3.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -45,12 +45,12 @@
     "@aws-sdk/client-bedrock": "3.1095.0",
     "@aws-sdk/client-bedrock-runtime": "3.1095.0",
     "effect": "4.0.0-rc.108",
-    "@velum-labs/routekit-config-core": "1.2.0",
-    "@velum-labs/routekit-contracts": "1.2.0",
-    "@velum-labs/routekit-eval-contracts": "1.2.0",
-    "@velum-labs/routekit-eval-core": "1.2.0",
-    "@velum-labs/routekit-registry": "1.2.0",
-    "@velum-labs/routekit-runtime": "1.2.0"
+    "@velum-labs/routekit-config-core": "1.3.1",
+    "@velum-labs/routekit-contracts": "1.3.1",
+    "@velum-labs/routekit-eval-contracts": "1.3.1",
+    "@velum-labs/routekit-eval-core": "1.3.1",
+    "@velum-labs/routekit-registry": "1.3.1",
+    "@velum-labs/routekit-runtime": "1.3.1"
   },
   "keywords": [
     "routekit",