@hasna/switcher 0.1.2 → 0.1.4

package/dist/generated/api.d.ts

@@ -345,6 +345,30 @@ export interface components {
             /** @enum {string} */
             harness: "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "gemini" | "aider" | "kilo";
             model: string;
+            modelPolicy?: {
+                /**
+                 * @default 1
+                 * @enum {number}
+                 */
+                version: 1;
+                roles?: {
+                    subagent?: string;
+                    fast?: string;
+                    planning?: string;
+                    review?: string;
+                    summary?: string;
+                    compaction?: string;
+                    weak?: string;
+                    editor?: string;
+                };
+                allowedModels?: string[];
+                aliases?: {
+                    [key: string]: string;
+                };
+                fallbacks?: {
+                    [key: string]: string[];
+                };
+            };
         };
         Profile: {
             id: string;
@@ -353,6 +377,30 @@ export interface components {
             /** @enum {string} */
             harness: "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "gemini" | "aider" | "kilo";
             model: string;
+            modelPolicy?: {
+                /**
+                 * @default 1
+                 * @enum {number}
+                 */
+                version: 1;
+                roles?: {
+                    subagent?: string;
+                    fast?: string;
+                    planning?: string;
+                    review?: string;
+                    summary?: string;
+                    compaction?: string;
+                    weak?: string;
+                    editor?: string;
+                };
+                allowedModels?: string[];
+                aliases?: {
+                    [key: string]: string;
+                };
+                fallbacks?: {
+                    [key: string]: string[];
+                };
+            };
             version: number;
             updatedAt: string;
         };
@@ -368,6 +416,44 @@ export interface components {
             supportedParameters?: string[];
             supportedGenerationMethods?: string[];
         };
+        ModelPolicy: {
+            /**
+             * @default 1
+             * @enum {number}
+             */
+            version: 1;
+            roles?: {
+                subagent?: string;
+                fast?: string;
+                planning?: string;
+                review?: string;
+                summary?: string;
+                compaction?: string;
+                weak?: string;
+                editor?: string;
+            };
+            allowedModels?: string[];
+            aliases?: {
+                [key: string]: string;
+            };
+            fallbacks?: {
+                [key: string]: string[];
+            };
+        };
+        RoutingEvent: {
+            /** Format: date-time */
+            at: string;
+            requestId: string;
+            requestedModel: string;
+            resolvedModel?: string;
+            reportedModel?: string;
+            /** @enum {string} */
+            decision: "allow" | "alias" | "reject" | "fallback";
+            /** @enum {string} */
+            role?: "main" | "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor";
+            reason?: string;
+            upstreamStatus?: number;
+        };
         ModelPage: {
             data: {
                 id: string;
@@ -451,6 +537,30 @@ export interface components {
                 /** @enum {string} */
                 harness: "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "gemini" | "aider" | "kilo";
                 model: string;
+                modelPolicy?: {
+                    /**
+                     * @default 1
+                     * @enum {number}
+                     */
+                    version: 1;
+                    roles?: {
+                        subagent?: string;
+                        fast?: string;
+                        planning?: string;
+                        review?: string;
+                        summary?: string;
+                        compaction?: string;
+                        weak?: string;
+                        editor?: string;
+                    };
+                    allowedModels?: string[];
+                    aliases?: {
+                        [key: string]: string;
+                    };
+                    fallbacks?: {
+                        [key: string]: string[];
+                    };
+                };
                 version: number;
                 updatedAt: string;
             };
@@ -475,22 +585,89 @@ export interface components {
             warnings: string[];
         };
         RunInput: {
+            /** @enum {number} */
+            modelPolicyVersion: 1;
             profileId: string;
             /** @enum {string} */
             harness: "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "gemini" | "aider" | "kilo";
             model: string;
+            modelPolicy?: {
+                /**
+                 * @default 1
+                 * @enum {number}
+                 */
+                version: 1;
+                roles?: {
+                    subagent?: string;
+                    fast?: string;
+                    planning?: string;
+                    review?: string;
+                    summary?: string;
+                    compaction?: string;
+                    weak?: string;
+                    editor?: string;
+                };
+                allowedModels?: string[];
+                aliases?: {
+                    [key: string]: string;
+                };
+                fallbacks?: {
+                    [key: string]: string[];
+                };
+            };
             planToken: string;
         };
         RunUpdate: {
             /** @enum {string} */
             status: "exited" | "failed" | "interrupted";
             exitCode: number;
+            routingEvents?: {
+                /** Format: date-time */
+                at: string;
+                requestId: string;
+                requestedModel: string;
+                resolvedModel?: string;
+                reportedModel?: string;
+                /** @enum {string} */
+                decision: "allow" | "alias" | "reject" | "fallback";
+                /** @enum {string} */
+                role?: "main" | "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor";
+                reason?: string;
+                upstreamStatus?: number;
+            }[];
+            routingEventsDropped?: number;
         };
         Run: {
+            /** @enum {number} */
+            modelPolicyVersion?: 1;
             profileId: string;
             /** @enum {string} */
             harness: "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "gemini" | "aider" | "kilo";
             model: string;
+            modelPolicy?: {
+                /**
+                 * @default 1
+                 * @enum {number}
+                 */
+                version: 1;
+                roles?: {
+                    subagent?: string;
+                    fast?: string;
+                    planning?: string;
+                    review?: string;
+                    summary?: string;
+                    compaction?: string;
+                    weak?: string;
+                    editor?: string;
+                };
+                allowedModels?: string[];
+                aliases?: {
+                    [key: string]: string;
+                };
+                fallbacks?: {
+                    [key: string]: string[];
+                };
+            };
             planToken: string;
             version: number;
             updatedAt: string;
@@ -503,6 +680,21 @@ export interface components {
             startedAt: string;
             endedAt?: string;
             exitCode?: number;
+            routingEvents?: {
+                /** Format: date-time */
+                at: string;
+                requestId: string;
+                requestedModel: string;
+                resolvedModel?: string;
+                reportedModel?: string;
+                /** @enum {string} */
+                decision: "allow" | "alias" | "reject" | "fallback";
+                /** @enum {string} */
+                role?: "main" | "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor";
+                reason?: string;
+                upstreamStatus?: number;
+            }[];
+            routingEventsDropped?: number;
         };
         Health: {
             /** @enum {string} */

package/dist/harness-types.d.ts

@@ -1,4 +1,7 @@
 import type { Model, Provider, Profile } from "./domain";
+import type { CompiledModelPolicy, ModelPolicy } from "./model-policy";
+import type { NativeModelPolicy } from "./native-model-policy";
+import type { RoutingEvent } from "./inference-gateway";
 export type HarnessId = Profile["harness"];
 export type HarnessLaunchInput = {
     harness: HarnessId;
@@ -14,6 +17,12 @@ export type HarnessLaunchInput = {
     cwd: string;
     version?: string;
     sessionDir?: string;
+    providerId?: string;
+    providerBaseUrl?: string;
+    modelPolicy?: ModelPolicy;
+    compiledPolicy?: CompiledModelPolicy;
+    nativePolicy?: NativeModelPolicy;
+    onRoutingEvent?: (event: RoutingEvent) => void;
 };
 export type PreparedLaunch = {
     executable: string;

package/dist/hermes-model-policy.d.ts

@@ -0,0 +1,30 @@
+export type HermesModelRoles = {
+    subagent?: string;
+    fast?: string;
+    planning?: string;
+    review?: string;
+    summary?: string;
+    compaction?: string;
+    weak?: string;
+    editor?: string;
+};
+export type HermesModelPolicyFragment = {
+    auxiliary: Record<string, {
+        api_mode: string;
+        provider: "custom";
+        model: string;
+        base_url: string;
+        api_key_env: "SWITCHER_HERMES_AUX_API_KEY";
+        fallback_chain: [];
+    }>;
+    delegation: {
+        model: string;
+        provider: "custom";
+        base_url: string;
+    };
+    env: {
+        apiKeyEnv: "SWITCHER_HERMES_AUX_API_KEY";
+    };
+};
+/** Compile verified Hermes auxiliary config fields without serializing credentials. */
+export declare function compileHermesModelPolicy(currentModel: string, roles: HermesModelRoles, baseUrl: string, apiMode?: string): HermesModelPolicyFragment;

package/dist/index.js

@@ -1,10 +1,56 @@
 // src/domain.ts
+import { z as z2 } from "zod";
+
+// src/model-policy-schema.ts
 import { z } from "zod";
-var harnessSchema = z.enum(["claude", "codex", "grok", "opencode", "opencode2", "pi", "omp", "dsh", "cline", "hermes", "prime-agent", "gemini", "aider", "kilo"]);
-var protocolSchema = z.enum(["anthropic-messages", "openai-responses", "openai-chat", "gemini-generate-content"]);
-var idSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/);
-var label = z.string().min(1).max(200);
-var envRef = z.string().regex(/^SWITCHER_PROVIDER_[A-Z0-9_]+$/);
+var policyModelIdSchema = z.string().min(1).max(300).regex(/^[^\u0000-\u001f\u007f]+$/);
+var modelPolicyRoleSchema = z.enum(["subagent", "fast", "planning", "review", "summary", "compaction", "weak", "editor"]);
+var boundedModelList = z.array(policyModelIdSchema).max(500);
+var aliasSchema = z.string().regex(/^[A-Za-z0-9._/-]{1,120}$/).refine((v) => !["__proto__", "prototype", "constructor"].includes(v));
+var boundedModelMap = z.record(aliasSchema, policyModelIdSchema).superRefine((value, ctx) => {
+  if (Object.keys(value).length > 200)
+    ctx.addIssue({ code: "custom", message: "Model policy maps may contain at most 200 entries." });
+});
+var fallbacksSchema = z.record(policyModelIdSchema, z.array(policyModelIdSchema).max(20)).superRefine((value, ctx) => {
+  if (Object.keys(value).length > 200)
+    ctx.addIssue({ code: "custom", message: "Model policy fallback maps may contain at most 200 entries." });
+});
+var modelPolicySchema = z.object({
+  version: z.literal(1).default(1),
+  roles: z.object({
+    subagent: policyModelIdSchema.optional(),
+    fast: policyModelIdSchema.optional(),
+    planning: policyModelIdSchema.optional(),
+    review: policyModelIdSchema.optional(),
+    summary: policyModelIdSchema.optional(),
+    compaction: policyModelIdSchema.optional(),
+    weak: policyModelIdSchema.optional(),
+    editor: policyModelIdSchema.optional()
+  }).strict().optional(),
+  allowedModels: boundedModelList.optional(),
+  aliases: boundedModelMap.optional(),
+  fallbacks: fallbacksSchema.optional()
+}).strict();
+var routingDecisionSchema = z.enum(["allow", "alias", "reject", "fallback"]);
+var routingEventRoleSchema = z.enum(["main", ...modelPolicyRoleSchema.options]);
+var routingEventSchema = z.object({
+  at: z.string().datetime({ offset: true }),
+  requestId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  requestedModel: policyModelIdSchema,
+  resolvedModel: policyModelIdSchema.optional(),
+  reportedModel: policyModelIdSchema.optional(),
+  decision: routingDecisionSchema,
+  role: routingEventRoleSchema.optional(),
+  reason: z.string().regex(/^[a-z][a-z0-9_]{0,63}$/).optional(),
+  upstreamStatus: z.number().int().min(100).max(599).optional()
+}).strict();
+var routingEventsSchema = z.array(routingEventSchema).max(1000);
+// src/domain.ts
+var harnessSchema = z2.enum(["claude", "codex", "grok", "opencode", "opencode2", "pi", "omp", "dsh", "cline", "hermes", "prime-agent", "gemini", "aider", "kilo"]);
+var protocolSchema = z2.enum(["anthropic-messages", "openai-responses", "openai-chat", "gemini-generate-content"]);
+var idSchema = z2.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/);
+var label = z2.string().min(1).max(200);
+var envRef = z2.string().regex(/^SWITCHER_PROVIDER_[A-Z0-9_]+$/);
 function endpoint(value) {
   let url;
   try {
@@ -17,74 +63,79 @@ function endpoint(value) {
     throw new Fault(400, "invalid_url", "URL must use HTTPS, contain no credentials/query/fragment, or use HTTP on loopback.");
   return url.href.replace(/\/+$/, "");
 }
-var urlSchema = z.string().max(2000).superRefine((v, ctx) => {
+var urlSchema = z2.string().max(2000).superRefine((v, ctx) => {
   try {
     endpoint(v);
   } catch {
     ctx.addIssue({ code: "custom", message: "Invalid endpoint URL" });
   }
 }).transform(endpoint);
-var modelSchema = z.object({
-  id: z.string().min(1).max(300),
+var modelSchema = z2.object({
+  id: z2.string().min(1).max(300),
   name: label,
-  description: z.string().max(8000).optional(),
-  available: z.boolean().optional(),
-  contextWindow: z.number().int().positive().optional(),
-  maxOutputTokens: z.number().int().positive().optional(),
-  inputModalities: z.array(z.string().max(50)).max(20).optional(),
-  outputModalities: z.array(z.string().max(50)).max(20).optional(),
-  supportedParameters: z.array(z.string().max(100)).max(100).optional(),
-  supportedGenerationMethods: z.array(z.string().min(1).max(100)).max(100).optional()
+  description: z2.string().max(8000).optional(),
+  available: z2.boolean().optional(),
+  contextWindow: z2.number().int().positive().optional(),
+  maxOutputTokens: z2.number().int().positive().optional(),
+  inputModalities: z2.array(z2.string().max(50)).max(20).optional(),
+  outputModalities: z2.array(z2.string().max(50)).max(20).optional(),
+  supportedParameters: z2.array(z2.string().max(100)).max(100).optional(),
+  supportedGenerationMethods: z2.array(z2.string().min(1).max(100)).max(100).optional()
 }).strict();
-var providerInputSchema = z.object({
+var providerInputSchema = z2.object({
   id: idSchema,
   name: label,
   baseUrl: urlSchema,
   protocol: protocolSchema,
   credentialEnv: envRef.optional(),
-  authStyle: z.enum(["bearer", "x-api-key", "api-key"]).default("bearer"),
+  authStyle: z2.enum(["bearer", "x-api-key", "api-key"]).default("bearer"),
   catalogBaseUrl: urlSchema.optional(),
-  catalogFormat: z.enum(["openai", "ollama", "mistral", "together", "fireworks", "dashscope", "gemini", "none"]).optional(),
-  catalogAuthStyle: z.enum(["bearer", "x-api-key", "api-key", "none"]).optional(),
+  catalogFormat: z2.enum(["openai", "ollama", "mistral", "together", "fireworks", "dashscope", "gemini", "none"]).optional(),
+  catalogAuthStyle: z2.enum(["bearer", "x-api-key", "api-key", "none"]).optional(),
   catalogCredentialEnv: envRef.optional(),
-  catalogAccountId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/).optional(),
-  modelsPath: z.string().regex(/^[a-zA-Z0-9_/-]+$/).max(200).default("models"),
-  manualModels: z.array(modelSchema).max(1e4).default([])
+  catalogAccountId: z2.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/).optional(),
+  modelsPath: z2.string().regex(/^[a-zA-Z0-9_/-]+$/).max(200).default("models"),
+  manualModels: z2.array(modelSchema).max(1e4).default([])
 }).strict().refine((p) => !p.modelsPath.split("/").includes("..") && !p.modelsPath.startsWith("/"), "modelsPath must be relative");
-var providerPresetSchema = z.object({
+var providerPresetSchema = z2.object({
   id: idSchema,
   name: label,
   credentialEnv: envRef.optional(),
-  credentialAliases: z.array(z.string().regex(/^[A-Z][A-Z0-9_]+$/)),
-  protocols: z.array(z.object({
+  credentialAliases: z2.array(z2.string().regex(/^[A-Z][A-Z0-9_]+$/)),
+  protocols: z2.array(z2.object({
     protocol: protocolSchema,
     baseUrl: urlSchema.optional(),
-    authStyle: z.enum(["bearer", "x-api-key", "api-key"]),
+    authStyle: z2.enum(["bearer", "x-api-key", "api-key"]),
     catalogBaseUrl: urlSchema.optional(),
-    catalogFormat: z.enum(["openai", "ollama", "mistral", "together", "fireworks", "dashscope", "gemini", "none"]),
-    catalogAuthStyle: z.enum(["bearer", "x-api-key", "api-key", "none"]).optional(),
-    modelsPath: z.string(),
-    notes: z.array(z.string())
+    catalogFormat: z2.enum(["openai", "ollama", "mistral", "together", "fireworks", "dashscope", "gemini", "none"]),
+    catalogAuthStyle: z2.enum(["bearer", "x-api-key", "api-key", "none"]).optional(),
+    modelsPath: z2.string(),
+    notes: z2.array(z2.string())
   }).strict()).min(1),
-  sources: z.array(z.string().url()),
-  verification: z.literal("documented")
+  sources: z2.array(z2.string().url()),
+  verification: z2.literal("documented")
 }).strict();
-var profileInputSchema = z.object({
+var profileInputSchema = z2.object({
   id: idSchema,
   name: label,
   providerId: idSchema,
   harness: harnessSchema,
-  model: z.string().min(1).max(300)
+  model: z2.string().min(1).max(300),
+  modelPolicy: modelPolicySchema.optional()
 }).strict();
-var runInputSchema = z.object({
+var runInputSchema = z2.object({
+  modelPolicyVersion: z2.literal(1),
   profileId: idSchema,
   harness: harnessSchema,
-  model: z.string().min(1).max(300),
-  planToken: z.string().regex(/^[a-f0-9]{64}$/)
+  model: z2.string().min(1).max(300),
+  modelPolicy: modelPolicySchema.optional(),
+  planToken: z2.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var runUpdateSchema = z.object({
-  status: z.enum(["exited", "failed", "interrupted"]),
-  exitCode: z.number().int().min(0).max(255)
+var runUpdateSchema = z2.object({
+  status: z2.enum(["exited", "failed", "interrupted"]),
+  exitCode: z2.number().int().min(0).max(255),
+  routingEvents: routingEventsSchema.optional(),
+  routingEventsDropped: z2.number().int().min(0).max(1e6).optional()
 }).strict();
 
 class Fault extends Error {
@@ -149,7 +200,7 @@ async function boundedJson(response, maxBytes = MAX_BYTES) {
 }
 
 // src/sdk.ts
-import { resolveCredential } from "@hasna/contracts/client";
+import { createClientTransport } from "@hasna/contracts/client";
 
 // src/presets.ts
 var route = (protocol, baseUrl, options = {}) => ({
@@ -310,6 +361,7 @@ function apiError(status, data, apiKey) {
 
 class SwitcherClient {
   options;
+  transport;
   baseUrl;
   constructor(options) {
     this.baseUrl = endpoint(options.baseUrl).replace(/\/v1$/, "");
@@ -317,9 +369,50 @@ class SwitcherClient {
       throw new Error("Switcher API key is required.");
     this.options = { ...options };
   }
+  static fromEnvironment(env = process.env, options = {}) {
+    const shared = createClientTransport("switcher", env, {
+      credentials: options.credentials,
+      timeoutMs: options.timeoutMs ?? 120000,
+      retry: false,
+      fetchImpl: async (input, init) => {
+        const address = String(input).replace(/\/v1\/(health|ready|version)$/, "/$1");
+        const key = new Headers(init?.headers).get("x-api-key") ?? "";
+        let response;
+        try {
+          response = await (options.fetch ?? fetch)(address, init);
+        } catch {
+          throw new SwitcherError(0, "connection_failed", "Switcher API request failed; check endpoint and service availability.");
+        }
+        if (response.status === 401 || response.status === 403) {
+          await response.body?.cancel().catch(() => {});
+          throw new SwitcherError(response.status, "api_error", `Switcher API returned HTTP ${response.status}. Check the configured credential; no alternate identity was selected.`);
+        }
+        let data;
+        try {
+          data = await boundedJson(response);
+        } catch {
+          throw new SwitcherError(response.status, "invalid_response", "Switcher API returned invalid JSON.");
+        }
+        if (!response.ok)
+          throw apiError(response.status, data, key);
+        return Response.json(data);
+      }
+    });
+    const client = new SwitcherClient({ baseUrl: shared.resolution.baseUrl, apiKey: () => {
+      throw new Error("Shared credential transport was not invoked.");
+    } });
+    client.transport = shared.client;
+    return client;
+  }
   async request(method, path, body, options = {}) {
     if (!/^\/v1\/[a-zA-Z0-9/?&=._%+-]+$/.test(path) && !["/health", "/ready", "/version"].includes(path) || path.includes(".."))
       throw new Error("Invalid API path.");
+    if (this.transport)
+      return this.transport.request(method, path.startsWith("/v1/") ? path.slice(3) : path, body, {
+        idempotencyKey: method === "GET" ? undefined : options.idempotencyKey ?? crypto.randomUUID(),
+        headers: options.version === undefined ? undefined : { "if-match": String(options.version) },
+        retry: false
+      });
     const apiKey = typeof this.options.apiKey === "function" ? this.options.apiKey() : this.options.apiKey;
     if (!apiKey || /[\r\n]/.test(apiKey))
       throw new Error("Switcher API key is required.");
@@ -410,17 +503,14 @@ class SwitcherClient {
     return this.request("GET", `/v1/runs/${encodeURIComponent(id)}`);
   }
   createRun(input, idempotencyKey) {
-    return this.request("POST", "/v1/runs", input, { idempotencyKey });
+    return this.request("POST", "/v1/runs", { ...input, modelPolicyVersion: 1 }, { idempotencyKey });
   }
   finishRun(id, version, input, idempotencyKey) {
     return this.request("PATCH", `/v1/runs/${encodeURIComponent(id)}`, input, { version, idempotencyKey });
   }
 }
-function clientFromEnv(env = process.env) {
-  const credential = () => resolveCredential("switcher", Object.fromEntries(Object.entries(env).filter(([name]) => name === "HASNA_SWITCHER_API_KEY")), { keychain: { enabled: false } })?.apiKey ?? "";
-  if (!env.HASNA_SWITCHER_API_URL || !credential())
-    throw new Error("Set HASNA_SWITCHER_API_URL and HASNA_SWITCHER_API_KEY; no local database fallback is available.");
-  return new SwitcherClient({ baseUrl: env.HASNA_SWITCHER_API_URL, apiKey: credential });
+function clientFromEnv(env = process.env, options = {}) {
+  return SwitcherClient.fromEnvironment(env, options);
 }
 export {
   providerFromPreset,

package/dist/inference-gateway.d.ts

@@ -0,0 +1,24 @@
+import type { HarnessLaunchInput } from "./harness-types";
+import { type CompiledModelPolicy } from "./model-policy";
+export type RoutingEvent = {
+    at: string;
+    requestId: string;
+    requestedModel: string;
+    resolvedModel?: string;
+    reportedModel?: string;
+    decision: "allow" | "alias" | "reject" | "fallback";
+    reason?: string;
+    upstreamStatus?: number;
+};
+type GatewayInput = HarnessLaunchInput & {
+    compiledPolicy: CompiledModelPolicy;
+    catalogPath: string;
+    onRoutingEvent?: (event: RoutingEvent) => void;
+};
+/** A per-launch credential boundary: the native client never receives the provider key. */
+export declare function createInferenceGateway(input: GatewayInput): {
+    baseUrl: string;
+    token: string;
+    cleanup: () => Promise<void>;
+};
+export {};

package/dist/launcher.d.ts

@@ -1,6 +1,8 @@
+import type { PreparedLaunch } from "./harness-types";
 import { SwitcherClient } from "./sdk";
 import { type LaunchPlan, type ProviderInput } from "./domain";
-import { type OriContract, type OriLaunchPlan } from "./ori-backend";
+import { type OriContract } from "./ori-backend";
+import type { RoutingEvent } from "./inference-gateway";
 export { childEnvironment } from "./harness-environment";
 export type LaunchBackend = "direct" | "ori";
 export type LaunchOptions = {
@@ -18,6 +20,7 @@ export type LaunchOptions = {
 type OriPreparationOptions = Pick<LaunchOptions, "oriExecutable" | "args" | "resolveCredential" | "credentialEnv"> & {
     stateDir?: string;
     cwd?: string;
+    onRoutingEvent?: (event: RoutingEvent) => void;
 };
 type OriSupportedHarness = Exclude<LaunchPlan["profile"]["harness"], "omp" | "cline" | "hermes" | "prime-agent" | "gemini" | "aider" | "opencode" | "kilo">;
 export declare function validateOriForPlan(plan: LaunchPlan, options?: Pick<OriPreparationOptions, "oriExecutable" | "args" | "credentialEnv" | "cwd">): Promise<{
@@ -38,8 +41,10 @@ declare function buildOriRequest(plan: LaunchPlan, target: OriSupportedHarness,
     };
     readonly args: string[];
 };
-export declare function prepareOriForPlan(plan: LaunchPlan, options?: OriPreparationOptions): Promise<{
+export declare function prepareOriForPlan(plan: LaunchPlan, options: OriPreparationOptions & {
+    stateDir: string;
+}): Promise<{
     contract: OriContract;
-    prepared: OriLaunchPlan;
+    prepared: PreparedLaunch;
 }>;
 export declare function launch(client: SwitcherClient, profileId: string, options?: LaunchOptions): Promise<number>;