@hasna/switcher 0.1.1 → 0.1.3

package/dist/mcp/index.js

@@ -4,16 +4,63 @@
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/domain.ts
+import { z as z2 } from "zod";
+
+// src/model-policy-schema.ts
 import { z } from "zod";
-var VERSION = "0.1.1";
-var harnessSchema = z.enum(["claude", "codex", "grok", "opencode2", "pi"]);
-var protocolSchema = z.enum(["anthropic-messages", "openai-responses", "openai-chat"]);
-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 VERSION = "0.1.3";
+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 {
@@ -26,73 +73,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()
+  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"]).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", "none"]).optional(),
-  catalogAuthStyle: z.enum(["bearer", "x-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"]),
+    authStyle: z2.enum(["bearer", "x-api-key", "api-key"]),
     catalogBaseUrl: urlSchema.optional(),
-    catalogFormat: z.enum(["openai", "ollama", "mistral", "together", "fireworks", "dashscope", "none"]),
-    catalogAuthStyle: z.enum(["bearer", "x-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 {
@@ -174,7 +227,18 @@ var providerPresets = [
   ], ["https://api-docs.deepseek.com/guides/anthropic_api", "https://api-docs.deepseek.com/api/list-models"], "DEEPSEEK_API_KEY"),
   preset("openrouter", "OpenRouter", ["openai-chat", "openai-responses", "anthropic-messages"].map((protocol) => route(protocol, "https://openrouter.ai/api/v1", { catalogAuthStyle: "none" })), ["https://openrouter.ai/docs/api/api-reference/models/list-all-models-and-their-properties", "https://openrouter.ai/docs/guides/overview"], "OPENROUTER_API_KEY"),
   preset("anthropic", "Anthropic", [route("anthropic-messages", "https://api.anthropic.com/v1", { authStyle: "x-api-key" })], ["https://platform.claude.com/docs/en/api/overview", "https://platform.claude.com/docs/en/api/models/list"], "ANTHROPIC_API_KEY"),
+  preset("gemini", "Google Gemini", [route("gemini-generate-content", "https://generativelanguage.googleapis.com/v1beta", {
+    authStyle: "x-api-key",
+    catalogBaseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    catalogFormat: "gemini",
+    catalogAuthStyle: "x-api-key",
+    notes: ["Gemini CLI uses the native generateContent wire with x-goog-api-key authentication; model IDs are returned as models/{id}."]
+  }), route("openai-chat", "https://generativelanguage.googleapis.com/v1beta/openai")], ["https://ai.google.dev/api", "https://ai.google.dev/api/models", "https://github.com/google-gemini/gemini-cli", "https://ai.google.dev/gemini-api/docs/openai"], "GEMINI_API_KEY"),
   preset("openai", "OpenAI", [route("openai-responses", "https://api.openai.com/v1"), route("openai-chat", "https://api.openai.com/v1")], ["https://platform.openai.com/docs/api-reference/introduction", "https://platform.openai.com/docs/api-reference/models/list"], "OPENAI_API_KEY"),
+  preset("azure-openai", "Azure OpenAI (v1)", [
+    route("openai-responses", undefined, { authStyle: "api-key", catalogFormat: "none", notes: ["Pass the Azure OpenAI v1 resource endpoint ending in /openai/v1. The request model is your deployment name. Azure's model-definition list is not a deployment catalog, so configure manual deployment models or an explicit deployment catalog parser; Switcher does not synthesize deployment paths or api-version query parameters."] }),
+    route("openai-chat", undefined, { authStyle: "api-key", catalogFormat: "none", notes: ["Pass the Azure OpenAI v1 resource endpoint ending in /openai/v1. Chat Completions is POST /chat/completions and accepts the literal api-key header. The request model is your deployment name; configure manual deployment models or an explicit deployment catalog parser because GET /models does not establish deployment names."] })
+  ], ["https://learn.microsoft.com/en-us/rest/api/aifoundry/azureopenai/models", "https://learn.microsoft.com/en-us/rest/api/microsoft-foundry/azureopenai/chat", "https://learn.microsoft.com/en-us/rest/api/aifoundry/azureopenai/responses"], "AZURE_OPENAI_API_KEY"),
   preset("xai", "xAI", ["openai-chat", "openai-responses", "anthropic-messages"].map((protocol) => route(protocol, "https://api.x.ai/v1")), ["https://api.x.ai/docs/", "https://docs.x.ai/developers/model-capabilities/text/generate-text"], "XAI_API_KEY"),
   preset("ollama", "Ollama", ["openai-chat", "openai-responses"].map((protocol) => route(protocol, "http://127.0.0.1:11434/v1", {
     catalogBaseUrl: "http://127.0.0.1:11434",
@@ -234,6 +298,26 @@ class SwitcherError extends Error {
     this.requestId = requestId;
   }
 }
+function apiError(status, data, apiKey) {
+  const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+  const error = object(data) && object(data.error) ? data.error : {};
+  const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const base64 = Buffer.from(apiKey, "utf8").toString("base64");
+  const literal = [apiKey, JSON.stringify(apiKey).slice(1, -1), base64, base64.replace(/=+$/, ""), Buffer.from(apiKey, "utf8").toString("base64url")];
+  const encoded = [encodeURIComponent(apiKey), new URLSearchParams({ key: apiKey }).toString().slice(4)];
+  const patterns = [...new Set(literal)].sort((a, b) => b.length - a.length).map(escape);
+  for (const value of encoded) {
+    patterns.unshift(escape(value).replace(/%[0-9A-F]{2}/g, (part) => part.replace(/[A-F]/g, (letter) => `[${letter}${letter.toLowerCase()}]`)));
+  }
+  const reflected = new RegExp(patterns.join("|"), "g");
+  const redact = (value) => value.replace(reflected, "[REDACTED]");
+  const identifier = (value, pattern) => typeof value === "string" && pattern.test(value) && redact(value) === value ? value : undefined;
+  const code = identifier(error.code, /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/) ?? "api_error";
+  const requestId = identifier(error.requestId, /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+  const fallback = `Switcher API returned HTTP ${status}.`;
+  const message = typeof error.message === "string" && error.message.length <= 4096 ? redact(error.message).replace(/[\x00-\x1f\x7f-\x9f]/g, " ").trim().slice(0, 2048) || fallback : fallback;
+  return new SwitcherError(status, code, message, requestId);
+}
 
 class SwitcherClient {
   options;
@@ -270,7 +354,7 @@ class SwitcherClient {
       throw new SwitcherError(response.status, "invalid_response", "Switcher API returned invalid JSON.");
     }
     if (!response.ok)
-      throw new SwitcherError(response.status, data?.error?.code ?? "api_error", data?.error?.message ?? `Switcher API returned HTTP ${response.status}.`, data?.error?.requestId);
+      throw apiError(response.status, data, apiKey);
     return data;
   }
   query(options = {}) {
@@ -337,7 +421,7 @@ 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 });
@@ -352,7 +436,7 @@ function clientFromEnv(env = process.env) {
 
 // src/mcp.ts
 var server = new McpServer({ name: "switcher", version: VERSION });
-var page = { limit: z2.number().int().min(1).max(1000).optional(), offset: z2.number().int().nonnegative().optional(), search: z2.string().optional() };
+var page = { limit: z3.number().int().min(1).max(1000).optional(), offset: z3.number().int().nonnegative().optional(), search: z3.string().optional() };
 function tool(name, description, schema, run) {
   server.tool(name, description, schema, async (input) => {
     try {
@@ -363,23 +447,23 @@ function tool(name, description, schema, run) {
   });
 }
 tool("providers_list", "List provider profiles.", page, (p) => clientFromEnv().listProviders(p));
-tool("providers_get", "Get a provider.", { id: z2.string() }, (p) => clientFromEnv().getProvider(p.id));
+tool("providers_get", "Get a provider.", { id: z3.string() }, (p) => clientFromEnv().getProvider(p.id));
 tool("providers_create", "Create a provider using credential environment references only.", providerInputSchema.innerType().shape, (p) => clientFromEnv().createProvider(p));
-tool("providers_update", "Replace a provider at its current version.", { provider: providerInputSchema, version: z2.number().int() }, (p) => clientFromEnv().updateProvider(p.provider, p.version));
-tool("providers_delete", "Delete an unreferenced provider.", { id: z2.string(), version: z2.number().int() }, (p) => clientFromEnv().deleteProvider(p.id, p.version));
-tool("models_list", "List catalog with capability information.", { id: z2.string(), ...page }, (p) => {
+tool("providers_update", "Replace a provider at its current version.", { provider: providerInputSchema, version: z3.number().int() }, (p) => clientFromEnv().updateProvider(p.provider, p.version));
+tool("providers_delete", "Delete an unreferenced provider.", { id: z3.string(), version: z3.number().int() }, (p) => clientFromEnv().deleteProvider(p.id, p.version));
+tool("models_list", "List catalog with capability information.", { id: z3.string(), ...page }, (p) => {
   const { id, ...rest } = p;
   return clientFromEnv().listModels(id, rest);
 });
-tool("models_refresh", "Discover provider models.", { id: z2.string() }, (p) => clientFromEnv().refreshModels(p.id));
+tool("models_refresh", "Discover provider models.", { id: z3.string() }, (p) => clientFromEnv().refreshModels(p.id));
 tool("profiles_list", "List harness launch profiles.", page, (p) => clientFromEnv().listProfiles(p));
-tool("profiles_get", "Get a harness profile.", { id: z2.string() }, (p) => clientFromEnv().getProfile(p.id));
+tool("profiles_get", "Get a harness profile.", { id: z3.string() }, (p) => clientFromEnv().getProfile(p.id));
 tool("profiles_create", "Create a harness launch profile.", profileInputSchema.shape, (p) => clientFromEnv().createProfile(p));
-tool("profiles_update", "Replace a harness profile at its version.", { profile: profileInputSchema, version: z2.number().int() }, (p) => clientFromEnv().updateProfile(p.profile, p.version));
-tool("profiles_delete", "Delete a profile without run history.", { id: z2.string(), version: z2.number().int() }, (p) => clientFromEnv().deleteProfile(p.id, p.version));
-tool("launch_plan", "Validate a local launch plan; does not execute a remote process.", { profileId: z2.string() }, (p) => clientFromEnv().launchPlan(p.profileId));
+tool("profiles_update", "Replace a harness profile at its version.", { profile: profileInputSchema, version: z3.number().int() }, (p) => clientFromEnv().updateProfile(p.profile, p.version));
+tool("profiles_delete", "Delete a profile without run history.", { id: z3.string(), version: z3.number().int() }, (p) => clientFromEnv().deleteProfile(p.id, p.version));
+tool("launch_plan", "Validate a local launch plan; does not execute a remote process.", { profileId: z3.string() }, (p) => clientFromEnv().launchPlan(p.profileId));
 tool("runs_list", "List launch metadata.", page, (p) => clientFromEnv().listRuns(p));
-tool("runs_get", "Get launch metadata.", { id: z2.string() }, (p) => clientFromEnv().getRun(p.id));
+tool("runs_get", "Get launch metadata.", { id: z3.string() }, (p) => clientFromEnv().getRun(p.id));
 if (process.argv.includes("--version"))
   console.log(VERSION);
 else if (process.argv.includes("--help"))

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

@@ -0,0 +1,137 @@
+import { z } from "zod";
+/** Model references are opaque provider IDs, never prompts or credentials. */
+export declare const policyModelIdSchema: z.ZodString;
+export declare const modelPolicyRoleSchema: z.ZodEnum<["subagent", "fast", "planning", "review", "summary", "compaction", "weak", "editor"]>;
+export type ModelPolicyRole = z.infer<typeof modelPolicyRoleSchema>;
+export declare const modelPolicySchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    roles: z.ZodOptional<z.ZodObject<{
+        subagent: z.ZodOptional<z.ZodString>;
+        fast: z.ZodOptional<z.ZodString>;
+        planning: z.ZodOptional<z.ZodString>;
+        review: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        compaction: z.ZodOptional<z.ZodString>;
+        weak: z.ZodOptional<z.ZodString>;
+        editor: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        subagent?: string | undefined;
+        fast?: string | undefined;
+        planning?: string | undefined;
+        review?: string | undefined;
+        summary?: string | undefined;
+        compaction?: string | undefined;
+        weak?: string | undefined;
+        editor?: string | undefined;
+    }, {
+        subagent?: string | undefined;
+        fast?: string | undefined;
+        planning?: string | undefined;
+        review?: string | undefined;
+        summary?: string | undefined;
+        compaction?: string | undefined;
+        weak?: string | undefined;
+        editor?: string | undefined;
+    }>>;
+    allowedModels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    aliases: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodString>, Record<string, string>, Record<string, string>>>;
+    fallbacks: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>, Record<string, string[]>, Record<string, string[]>>>;
+}, "strict", z.ZodTypeAny, {
+    version: 1;
+    roles?: {
+        subagent?: string | undefined;
+        fast?: string | undefined;
+        planning?: string | undefined;
+        review?: string | undefined;
+        summary?: string | undefined;
+        compaction?: string | undefined;
+        weak?: string | undefined;
+        editor?: string | undefined;
+    } | undefined;
+    allowedModels?: string[] | undefined;
+    aliases?: Record<string, string> | undefined;
+    fallbacks?: Record<string, string[]> | undefined;
+}, {
+    version?: 1 | undefined;
+    roles?: {
+        subagent?: string | undefined;
+        fast?: string | undefined;
+        planning?: string | undefined;
+        review?: string | undefined;
+        summary?: string | undefined;
+        compaction?: string | undefined;
+        weak?: string | undefined;
+        editor?: string | undefined;
+    } | undefined;
+    allowedModels?: string[] | undefined;
+    aliases?: Record<string, string> | undefined;
+    fallbacks?: Record<string, string[]> | undefined;
+}>;
+export type ModelPolicy = z.infer<typeof modelPolicySchema>;
+export declare const routingDecisionSchema: z.ZodEnum<["allow", "alias", "reject", "fallback"]>;
+export declare const routingEventRoleSchema: z.ZodEnum<["main", "subagent", "fast", "planning", "review", "summary", "compaction", "weak", "editor"]>;
+export declare const routingEventSchema: z.ZodObject<{
+    at: z.ZodString;
+    requestId: z.ZodString;
+    requestedModel: z.ZodString;
+    resolvedModel: z.ZodOptional<z.ZodString>;
+    reportedModel: z.ZodOptional<z.ZodString>;
+    decision: z.ZodEnum<["allow", "alias", "reject", "fallback"]>;
+    role: z.ZodOptional<z.ZodEnum<["main", "subagent", "fast", "planning", "review", "summary", "compaction", "weak", "editor"]>>;
+    reason: z.ZodOptional<z.ZodString>;
+    upstreamStatus: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    at: string;
+    requestId: string;
+    requestedModel: string;
+    decision: "allow" | "alias" | "reject" | "fallback";
+    resolvedModel?: string | undefined;
+    reportedModel?: string | undefined;
+    role?: "main" | "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor" | undefined;
+    reason?: string | undefined;
+    upstreamStatus?: number | undefined;
+}, {
+    at: string;
+    requestId: string;
+    requestedModel: string;
+    decision: "allow" | "alias" | "reject" | "fallback";
+    resolvedModel?: string | undefined;
+    reportedModel?: string | undefined;
+    role?: "main" | "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor" | undefined;
+    reason?: string | undefined;
+    upstreamStatus?: number | undefined;
+}>;
+export type RoutingEvent = z.infer<typeof routingEventSchema>;
+export declare const routingEventsSchema: z.ZodArray<z.ZodObject<{
+    at: z.ZodString;
+    requestId: z.ZodString;
+    requestedModel: z.ZodString;
+    resolvedModel: z.ZodOptional<z.ZodString>;
+    reportedModel: z.ZodOptional<z.ZodString>;
+    decision: z.ZodEnum<["allow", "alias", "reject", "fallback"]>;
+    role: z.ZodOptional<z.ZodEnum<["main", "subagent", "fast", "planning", "review", "summary", "compaction", "weak", "editor"]>>;
+    reason: z.ZodOptional<z.ZodString>;
+    upstreamStatus: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    at: string;
+    requestId: string;
+    requestedModel: string;
+    decision: "allow" | "alias" | "reject" | "fallback";
+    resolvedModel?: string | undefined;
+    reportedModel?: string | undefined;
+    role?: "main" | "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor" | undefined;
+    reason?: string | undefined;
+    upstreamStatus?: number | undefined;
+}, {
+    at: string;
+    requestId: string;
+    requestedModel: string;
+    decision: "allow" | "alias" | "reject" | "fallback";
+    resolvedModel?: string | undefined;
+    reportedModel?: string | undefined;
+    role?: "main" | "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor" | undefined;
+    reason?: string | undefined;
+    upstreamStatus?: number | undefined;
+}>, "many">;
+/** Stable object-key order; ordered fallback arrays retain their precedence. */
+export declare function canonicalPolicyJSON(value: unknown): string;

package/dist/model-policy.d.ts

@@ -0,0 +1,31 @@
+import { type Model } from "./domain";
+export declare const MODEL_POLICY_VERSION: 1;
+export type ModelRole = "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor";
+export type ModelPolicy = {
+    version?: 1;
+    roles?: Partial<Record<ModelRole, string>>;
+    allowedModels?: string[];
+    aliases?: Record<string, string>;
+    fallbacks?: Record<string, string[]>;
+};
+export type CompiledModelPolicy = {
+    version: 1;
+    model: string;
+    roles: Record<ModelRole, string>;
+    allowedModels: string[];
+    aliases: Record<string, string>;
+    fallbacks: Record<string, string[]>;
+    digest: string;
+};
+export type ModelGuidanceContext = {
+    harness: string;
+    providerId?: string;
+    baseUrl?: string;
+    model: string;
+    compiled: CompiledModelPolicy;
+    catalogPath?: string;
+};
+export declare function compileModelPolicy(model: string, catalog: readonly Model[], policy?: ModelPolicy): CompiledModelPolicy;
+export declare function resolvePolicyModel(compiled: CompiledModelPolicy, requested: string): string;
+export declare function renderModelGuidance(context: ModelGuidanceContext): string;
+export declare function injectModelGuidance(protocol: "anthropic-messages" | "openai-chat" | "openai-responses" | "gemini-generate-content", body: unknown, guidance: string, operation?: string): unknown;

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

@@ -0,0 +1,23 @@
+/** Pure compilation of the documented native model-policy surfaces.
+ *
+ * This module deliberately does not launch processes, read configuration, or
+ * infer provider aliases. Callers provide the exact model IDs they have
+ * already selected and may then serialize the returned env/config values.
+ */
+export declare const nativeRoles: readonly ["main", "subagent", "fast", "planning", "review", "summary", "compaction", "weak", "editor"];
+export type NativeRole = typeof nativeRoles[number];
+export type NativePolicyHarness = "claude" | "codex" | "grok" | "opencode" | "opencode2" | "omp" | "hermes" | "aider" | "kilo" | "gemini" | "cline" | "dsh" | "pi" | "prime-agent";
+export type NativeModelPolicyInput = {
+    harness: NativePolicyHarness;
+    mainModel: string;
+    roles?: Partial<Record<NativeRole, string>>;
+    version?: string;
+};
+export type NativeModelPolicy = {
+    harness: NativePolicyHarness;
+    env: Record<string, string>;
+    config: Record<string, unknown>;
+    unsupportedRoles: NativeRole[];
+};
+/** Compile exact role assignments into native settings/env without inventing knobs. */
+export declare function compileNativeModelPolicy(input: NativeModelPolicyInput): NativeModelPolicy;

package/dist/omp-backend.d.ts

@@ -0,0 +1,7 @@
+import type { HarnessLaunchInput, PreparedLaunch } from "./harness-types";
+/**
+ * Prepare an isolated OMP configuration. OMP reads models.yml as JSON-valid
+ * YAML, and resolves the apiKey/header references from the child environment.
+ * The credential therefore never reaches the generated files or command line.
+ */
+export declare function prepareOmpLaunch(input: HarnessLaunchInput): Promise<PreparedLaunch>;

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

@@ -0,0 +1,33 @@
+import type { ModelPolicy } from "./model-policy-schema";
+type Dict = Record<string, unknown>;
+export type OpenCodeRole = "main" | "subagent" | "planning" | "summary" | "compaction";
+export type OpenCodeCompiledRoles = Partial<Record<OpenCodeRole, string>>;
+export type PreservedOpenCodeAgent = Dict & {
+    name: string;
+};
+export type OpenCodeModelPolicyInput = {
+    providerId: string;
+    mainModel: string;
+    roles?: OpenCodeCompiledRoles | ModelPolicy["roles"];
+    preservedAgents?: PreservedOpenCodeAgent[];
+    /** OpenCode 2's native `agents` table or legacy OpenCode's `agent` table. */
+    format?: "v2" | "legacy";
+};
+export type OpenCodeModelPolicyResult = {
+    model: string;
+    agents: PreservedOpenCodeAgent[];
+    /** Only native OpenCode fields are emitted. */
+    config: {
+        model: string;
+        agents?: Record<string, Dict>;
+        agent?: Record<string, Dict>;
+    };
+};
+/**
+ * Merge Switcher routing into native OpenCode agent declarations. Prompts,
+ * permissions, modes and other native fields are copied without alteration.
+ */
+export declare function compileOpenCodeModelPolicy(input: OpenCodeModelPolicyInput): OpenCodeModelPolicyResult;
+/** Match OpenCode's explicit agent selection without interpreting prompt values as flags. */
+export declare function openCodeInvocationModel(args: readonly string[], policy: OpenCodeModelPolicyResult, defaultAgent?: string): string;
+export {};

package/dist/opencode2-config.d.ts

@@ -4,13 +4,13 @@ declare const rule: z.ZodObject<{
     resource: z.ZodString;
     effect: z.ZodEnum<["allow", "deny", "ask"]>;
 }, "strict", z.ZodTypeAny, {
+    effect: "allow" | "deny" | "ask";
     action: string;
     resource: string;
-    effect: "allow" | "deny" | "ask";
 }, {
+    effect: "allow" | "deny" | "ask";
     action: string;
     resource: string;
-    effect: "allow" | "deny" | "ask";
 }>;
 type Rule = z.infer<typeof rule>;
 type Agent = {
@@ -35,9 +35,9 @@ export declare function isolateOpenCode2(cwd: string, stateDir: string, provider
         };
         default_agent?: string | undefined;
         permissions: {
+            effect: "allow" | "deny" | "ask";
             action: string;
             resource: string;
-            effect: "allow" | "deny" | "ask";
         }[];
         agents: Record<string, Agent>;
     };

package/dist/ori-backend.d.ts

@@ -1,6 +1,6 @@
 /** The Ori 0.12.1 command name for a Switcher harness. */
-export type OriTarget = "claude" | "codex" | "grok" | "opencode2" | "pi";
-export type OriProtocol = "anthropic-messages" | "openai-responses" | "openai-chat";
+export type OriTarget = "claude" | "codex" | "grok" | "opencode2" | "pi" | "dsh" | "gemini" | "aider" | "kilo";
+export type OriProtocol = "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
 export type OriReasoningEffort = "max" | "xhigh" | "high" | "medium" | "low" | "minimal" | "none";
 export type OriProviderCatalogEntry = {
     id: "openrouter";

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

@@ -0,0 +1,8 @@
+import type { PreparedLaunch } from "./harness-types";
+/** Execute the verified native launch after Ori finishes its OpenRouter setup.
+ * Credentials are remapped from process environment, never written into the shim. */
+export declare function prepareOriModelPolicy(target: "codex" | "grok", prepared: Pick<PreparedLaunch, "executable" | "args" | "env">): {
+    name: "codex" | "grok";
+    env: Record<string, string>;
+    script: string;
+};

package/dist/presets.d.ts

@@ -6,14 +6,14 @@ export declare function getProviderPreset(id: string): {
     name: string;
     credentialAliases: string[];
     protocols: {
-        protocol: "anthropic-messages" | "openai-responses" | "openai-chat";
-        authStyle: "bearer" | "x-api-key";
-        catalogFormat: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "none";
+        protocol: "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
+        authStyle: "bearer" | "x-api-key" | "api-key";
+        catalogFormat: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "gemini" | "none";
         modelsPath: string;
         notes: string[];
         baseUrl?: string | undefined;
         catalogBaseUrl?: string | undefined;
-        catalogAuthStyle?: "bearer" | "x-api-key" | "none" | undefined;
+        catalogAuthStyle?: "bearer" | "x-api-key" | "api-key" | "none" | undefined;
     }[];
     sources: string[];
     verification: "documented";
@@ -25,10 +25,10 @@ export type PresetOptions = {
     harness?: Profile["harness"];
     baseUrl?: string;
     credentialEnv?: string;
-    authStyle?: "bearer" | "x-api-key";
+    authStyle?: "bearer" | "x-api-key" | "api-key";
     catalogBaseUrl?: string;
     catalogCredentialEnv?: string;
-    catalogAuthStyle?: "bearer" | "x-api-key" | "none";
+    catalogAuthStyle?: "bearer" | "x-api-key" | "api-key" | "none";
     modelsPath?: string;
     catalogFormat?: ProviderInput["catalogFormat"];
     catalogAccountId?: string;
@@ -37,8 +37,8 @@ export declare function providerFromPreset(presetId: string, options?: PresetOpt
     id: string;
     name: string;
     baseUrl: string;
-    protocol: "anthropic-messages" | "openai-responses" | "openai-chat";
-    authStyle: "bearer" | "x-api-key";
+    protocol: "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
+    authStyle: "bearer" | "x-api-key" | "api-key";
     modelsPath: string;
     manualModels: {
         id: string;
@@ -50,11 +50,12 @@ export declare function providerFromPreset(presetId: string, options?: PresetOpt
         inputModalities?: string[] | undefined;
         outputModalities?: string[] | undefined;
         supportedParameters?: string[] | undefined;
+        supportedGenerationMethods?: string[] | undefined;
     }[];
     credentialEnv?: string | undefined;
     catalogBaseUrl?: string | undefined;
-    catalogFormat?: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "none" | undefined;
-    catalogAuthStyle?: "bearer" | "x-api-key" | "none" | undefined;
+    catalogFormat?: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "gemini" | "none" | undefined;
+    catalogAuthStyle?: "bearer" | "x-api-key" | "api-key" | "none" | undefined;
     catalogCredentialEnv?: string | undefined;
     catalogAccountId?: string | undefined;
 };