@neutrome/open-ai-router 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutrome/open-ai-router",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
@@ -14,7 +14,7 @@
     "deploy": "wrangler deploy"
   },
   "dependencies": {
-    "@neutrome/lil-engine": "0.1.2",
+    "@neutrome/lil-engine": "workspace:*",
     "hono": "^4.12.18"
   },
   "devDependencies": {

package/src/app/factory.ts

@@ -0,0 +1,186 @@
+import { Hono, type Context } from "hono";
+import type { Executor, ProgramTransform } from "@neutrome/lil-engine";
+import type { ExecutionRuntimeOptions } from "@neutrome/lil-engine";
+import { cors } from "./cors.ts";
+import { healthHandler } from "./health.ts";
+import {
+  createRouterRuntime,
+  handleAnthropicMessages,
+  handleChatCompletions,
+  handleGoogleGenAI,
+  handleResponses,
+  listConfiguredModels,
+  type RouterRuntime,
+} from "../router/index.ts";
+import type { RequestContext } from "../auth/types.ts";
+import type { RouterConfig } from "../router/config.ts";
+import type { UsageReport } from "../router/execute.ts";
+
+export type RouterAppAuth = {
+  authenticate(request: Request, env: Record<string, unknown>): Promise<object | null>;
+  canAccess(principal: object, modelId: string): boolean;
+};
+
+export type RouterAppHooks = {
+  beforeRequest?(ctx: { request: Request; model: string | null; env: Record<string, unknown> }): Promise<Response | void>;
+  onUsage?(report: UsageReport, env: Record<string, unknown>): void;
+  onToolCall?(report: { toolName: string }, env: Record<string, unknown>): void;
+};
+
+export type RouterAppOptions = {
+  config: RouterConfig;
+  executors: Readonly<Record<string, Executor>>;
+  transforms?: Readonly<Record<string, ProgramTransform>>;
+  auth: RouterAppAuth;
+  hooks?: RouterAppHooks;
+  fetchImpl?: typeof fetch;
+  knownSuffixes?: string[];
+  observe?: ExecutionRuntimeOptions["observe"];
+  requestIdFactory?: ExecutionRuntimeOptions["requestIdFactory"];
+  executionIdFactory?: ExecutionRuntimeOptions["executionIdFactory"];
+  upstreamTimeoutMs?: number;
+};
+
+export function createRouterApp(options: RouterAppOptions) {
+  const runtime = createRouterRuntime({
+    config: options.config,
+    ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
+    ...(options.knownSuffixes ? { knownSuffixes: options.knownSuffixes } : {}),
+  });
+
+  const app = new Hono();
+
+  app.use("/v1/*", cors());
+  app.get("/health", healthHandler());
+
+  app.get("/v1/models", async (c) => {
+    const env = honoEnv(c);
+    const principal = await options.auth.authenticate(c.req.raw, env);
+    if (!principal) return unauthorized();
+
+    const models = listConfiguredModels(runtime)
+      .filter((id) => options.auth.canAccess(principal, id))
+      .map((id) => ({
+        id,
+        object: "model" as const,
+        created: 0,
+        owned_by: id.split("/")[0] || "unknown",
+      }));
+    return c.json({ object: "list", data: models });
+  });
+
+  app.post("/v1/chat/completions", (c) => runAuthorized(c, c.req.raw, handleChatCompletions));
+  app.post("/v1/responses", (c) => runAuthorized(c, c.req.raw, handleResponses));
+  app.post("/v1/messages", (c) => runAuthorized(c, c.req.raw, handleAnthropicMessages));
+
+  app.post("/v1/models/*", async (c) => {
+    const route = parseGoogleGenAIRoute(c.req.raw);
+    if (!route) return c.text("Not Found", 404);
+    const request = await rewriteGoogleGenAIRequest(c.req.raw, route);
+    return runAuthorized(c, request, handleGoogleGenAI, route.stream);
+  });
+
+  app.all("*", (c) => c.text("Not Found", 404));
+
+  async function runAuthorized(
+    c: Context,
+    request: Request,
+    handler: (opts: any) => Promise<Response>,
+    forceStreaming?: boolean,
+  ): Promise<Response> {
+    const env = honoEnv(c);
+    const principal = await options.auth.authenticate(request, env);
+    if (!principal) return unauthorized();
+
+    const model = await readModel(request.clone());
+    if (model && !options.auth.canAccess(principal, model)) {
+      return errorResponse(`Model \`${model}\` does not exist or you do not have access.`, 404, "model_not_found");
+    }
+
+    if (options.hooks?.beforeRequest) {
+      const hookResponse = await options.hooks.beforeRequest({ request, model, env });
+      if (hookResponse) return hookResponse;
+    }
+
+    const ctx: RequestContext = {
+      request,
+      incomingAuth: new Map(),
+      env,
+      state: new Map(),
+    };
+    for (const driver of runtime.authChain) {
+      driver.collectIncoming?.(ctx);
+    }
+
+    const onUsage = options.hooks?.onUsage
+      ? (report: UsageReport) => options.hooks!.onUsage!(report, env)
+      : undefined;
+
+    return handler({
+      runtime,
+      ctx,
+      executors: options.executors,
+      ...(options.transforms ? { transforms: options.transforms } : {}),
+      ...(options.observe ? { observe: options.observe } : {}),
+      ...(options.upstreamTimeoutMs !== undefined ? { upstreamTimeoutMs: options.upstreamTimeoutMs } : {}),
+      ...(onUsage ? { onUsage } : {}),
+      ...(forceStreaming ? { forceStreaming: true } : {}),
+    });
+  }
+
+  return app;
+}
+
+function honoEnv(c: Context): Record<string, unknown> {
+  return (c.env ?? {}) as Record<string, unknown>;
+}
+
+function parseGoogleGenAIRoute(request: Request): { model: string; stream: boolean } | null {
+  const pathname = new URL(request.url).pathname;
+  const match = pathname.match(/^\/v1\/models\/(.+):(generateContent|streamGenerateContent)$/);
+  if (!match?.[1] || !match[2]) return null;
+  try {
+    return { model: decodeURIComponent(match[1]), stream: match[2] === "streamGenerateContent" };
+  } catch {
+    return null;
+  }
+}
+
+async function rewriteGoogleGenAIRequest(
+  request: Request,
+  route: { model: string; stream: boolean },
+): Promise<Request> {
+  const bodyText = await request.text();
+  const headers = new Headers(request.headers);
+  try {
+    const raw = JSON.parse(bodyText) as Record<string, unknown>;
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      return new Request(request.url, {
+        method: request.method,
+        headers,
+        body: JSON.stringify({ ...raw, model: route.model, ...(route.stream ? { stream: true } : {}) }),
+      });
+    }
+  } catch {}
+  return new Request(request.url, { method: request.method, headers, body: bodyText });
+}
+
+async function readModel(request: Request): Promise<string | null> {
+  try {
+    const body = (await request.json()) as { model?: unknown };
+    return typeof body.model === "string" ? body.model : null;
+  } catch {
+    return null;
+  }
+}
+
+function unauthorized(): Response {
+  return errorResponse("Authentication required", 401, "auth_required");
+}
+
+function errorResponse(message: string, status: number, code: string): Response {
+  return new Response(
+    JSON.stringify({ error: { message, type: "invalid_request_error", param: null, code } }),
+    { status, headers: { "content-type": "application/json; charset=utf-8" } },
+  );
+}

package/src/app/handlers.ts

@@ -28,8 +28,8 @@ export type AnthropicMessagesHandlerOptions = ChatCompletionsHandlerOptions;
 export type GoogleGenAIHandlerOptions = ChatCompletionsHandlerOptions;
 
 export function listModelsHandler(runtime: RouterRuntime) {
-  return async (c: Context) => {
-    const modelIds = await listAvailableModels(runtime);
+  return (c: Context) => {
+    const modelIds = listAvailableModels(runtime);
     const models: OpenAiModel[] = modelIds.map((id) => ({
       id,
       object: "model",
@@ -40,60 +40,8 @@ export function listModelsHandler(runtime: RouterRuntime) {
   };
 }
 
-async function listAvailableModels(runtime: RouterRuntime): Promise<string[]> {
-  const seen = new Set<string>();
-  const models: string[] = [];
-
-  for (const id of listConfiguredModels(runtime)) {
-    addModel(id);
-  }
-
-  await Promise.all(runtime.providerOrder.map(async (namespace) => {
-    const provider = runtime.providers.get(namespace);
-    if (!provider || provider.catalog.length > 0) {
-      return;
-    }
-
-    for (const model of await fetchProviderCatalog(runtime, provider.apiBaseUrl)) {
-      if (provider.exportsMatcher(model)) {
-        addModel(`${namespace}/${model}`);
-      }
-    }
-  }));
-
-  return models;
-
-  function addModel(id: string): void {
-    if (seen.has(id)) {
-      return;
-    }
-    seen.add(id);
-    models.push(id);
-  }
-}
-
-async function fetchProviderCatalog(runtime: RouterRuntime, apiBaseUrl: string): Promise<string[]> {
-  try {
-    const response = await runtime.fetchImpl(`${apiBaseUrl}/models`, {
-      method: "GET",
-      headers: { accept: "application/json" },
-    });
-    if (!response.ok) {
-      return [];
-    }
-
-    const raw = await response.json() as { data?: unknown };
-    const data = raw.data;
-    if (!Array.isArray(data)) {
-      return [];
-    }
-
-    return data
-      .map((model) => (model as { id?: unknown } | null | undefined)?.id)
-      .filter((id): id is string => typeof id === "string");
-  } catch {
-    return [];
-  }
+function listAvailableModels(runtime: RouterRuntime): string[] {
+  return listConfiguredModels(runtime);
 }
 
 export function chatCompletionsHandler(

package/src/auth/apikey.ts

@@ -0,0 +1,51 @@
+export type ApiKeyEntry = {
+  tokenHash: string;
+  allowedModels: string[] | null;
+  allowedNamespaces: string[] | null;
+};
+
+export type ApiKeyAuth = {
+  authenticate(request: Request): Promise<ApiKeyEntry | null>;
+  canAccess(key: ApiKeyEntry, modelId: string): boolean;
+};
+
+export function createApiKeyAuth(keys: readonly ApiKeyEntry[]): ApiKeyAuth {
+  return {
+    async authenticate(request) {
+      const token = readApiToken(request);
+      if (!token) return null;
+      const hash = await sha256Hex(token);
+      return keys.find((k) => k.tokenHash === hash) ?? null;
+    },
+
+    canAccess(key, modelId) {
+      const hasModelRestriction = key.allowedModels && key.allowedModels.length > 0;
+      const hasNamespaceRestriction = key.allowedNamespaces && key.allowedNamespaces.length > 0;
+      if (!hasModelRestriction && !hasNamespaceRestriction) return true;
+      if (hasModelRestriction && key.allowedModels!.includes(modelId)) return true;
+      const ns = modelId.split("/")[0] ?? "";
+      return !!(hasNamespaceRestriction && key.allowedNamespaces!.includes(ns));
+    },
+  };
+}
+
+function readApiToken(request: Request): string | null {
+  const authHeader = request.headers.get("authorization");
+  const bearerMatch = authHeader?.match(/^Bearer\s+(.+)$/i);
+  if (bearerMatch?.[1]) return bearerMatch[1];
+
+  const headerToken = request.headers.get("x-api-key")
+    ?? request.headers.get("x-goog-api-key");
+  if (headerToken) return headerToken;
+
+  const url = new URL(request.url);
+  return url.searchParams.get("key") ?? url.searchParams.get("api_key");
+}
+
+async function sha256Hex(value: string): Promise<string> {
+  const bytes = new TextEncoder().encode(value);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}

package/src/example.test.ts

@@ -9,15 +9,14 @@ import { createApp } from "./example.ts";
 const decoder = new TextDecoder();
 
 describe("open-ai-router createApp", () => {
-  it("lists configured provider catalog entries and executor aliases", async () => {
+  it("lists configured executor aliases", async () => {
     const app = createApp({
       config: {
         providers: {
           openrouter: {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
-            exports: ["gpt-4o"],
-            catalog: ["gpt-4o"],
+            exports: ["*"],
           },
         },
         executors: {
@@ -38,50 +37,6 @@ describe("open-ai-router createApp", () => {
       object: "list",
       data: [
         { id: "semantyka/enei-1", object: "model", created: 0, owned_by: "semantyka" },
-        { id: "openrouter/gpt-4o", object: "model", created: 0, owned_by: "openrouter" },
-      ],
-    });
-  });
-
-  it("lists provider /models entries when provider catalog is not configured", async () => {
-    const app = createApp({
-      config: {
-        providers: {
-          openrouter: {
-            api_base_url: "https://openrouter.ai/api/v1",
-            style: "chat-completions",
-            exports: ["*:free"],
-          },
-        },
-        executors: {},
-      },
-      fetchImpl: vi.fn(async () =>
-        new Response(
-          JSON.stringify({
-            data: [
-              { id: "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free" },
-              { id: "openai/gpt-4.1-mini" },
-            ],
-          }),
-          {
-            headers: { "content-type": "application/json; charset=utf-8" },
-          },
-        )
-      ),
-    });
-
-    const response = await app.request("/v1/models");
-
-    expect(response.status).toBe(200);
-    expect(await response.json()).toEqual({
-      object: "list",
-      data: [
-        {
-          id: "openrouter/nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
-          object: "model",
-          created: 0,
-          owned_by: "openrouter",
-        },
       ],
     });
   });
@@ -101,12 +56,17 @@ describe("open-ai-router createApp", () => {
           openrouter: {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
-            exports: ["gpt-4o"],
-            allow_anonymous: false,
-            no_prefix: true,
+            exports: ["*"],
+          },
+        },
+        executors: {
+          default: {
+            exports: ["*"],
+            models: {
+              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
+            },
           },
         },
-        executors: {},
       },
       fetchImpl: vi.fn(async (_input, init) => {
         capturedBody = JSON.parse(decoder.decode(new Uint8Array(init?.body as ArrayBuffer)));
@@ -172,12 +132,17 @@ describe("open-ai-router createApp", () => {
           openrouter: {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
-            allow_anonymous: true,
-            exports: ["gpt-4o"],
-            no_prefix: true,
+            exports: ["*"],
+          },
+        },
+        executors: {
+          default: {
+            exports: ["*"],
+            models: {
+              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
+            },
           },
         },
-        executors: {},
       },
       fetchImpl: vi.fn(async (_input, init) => {
         capturedBody = JSON.parse(decoder.decode(new Uint8Array(init?.body as ArrayBuffer)));
@@ -241,12 +206,17 @@ describe("open-ai-router createApp", () => {
           openrouter: {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
-            allow_anonymous: true,
-            exports: ["gpt-4o"],
-            no_prefix: true,
+            exports: ["*"],
+          },
+        },
+        executors: {
+          default: {
+            exports: ["*"],
+            models: {
+              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
+            },
           },
         },
-        executors: {},
       },
       fetchImpl: vi.fn(async (_input, init) => {
         capturedBody = JSON.parse(decoder.decode(new Uint8Array(init?.body as ArrayBuffer)));

package/src/index.ts

@@ -1,3 +1,6 @@
+export { createRouterApp } from "./app/factory.ts";
+export type { RouterAppAuth, RouterAppHooks, RouterAppOptions } from "./app/factory.ts";
+
 export { createApp } from "./example.ts";
 export type { CreateAppOptions } from "./example.ts";
 
@@ -47,6 +50,8 @@ export type {
 export { buildAuthChain } from "./auth/registry.ts";
 export { envAuthDriver } from "./auth/env.ts";
 export { proxyAuthDriver } from "./auth/proxy.ts";
+export { createApiKeyAuth } from "./auth/apikey.ts";
+export type { ApiKeyAuth, ApiKeyEntry } from "./auth/apikey.ts";
 
 export { cors } from "./app/cors.ts";
 export { healthHandler } from "./app/health.ts";

package/src/router/config.ts

@@ -9,11 +9,7 @@ export type ProviderTargetConfig = {
   api_base_url: string;
   style: ProviderApiStyle;
   exports?: string[] | null;
-  endpoint_path?: string;
-  allow_anonymous?: boolean;
-  no_prefix?: boolean;
   headers?: Record<string, string>;
-  catalog?: string[];
 };
 
 export type ExecutorRouteConfig =

package/src/router/execute.test.ts

@@ -19,12 +19,17 @@ describe("router execution", () => {
           openrouter: {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
-            allow_anonymous: true,
-            exports: ["gpt-4o"],
-            no_prefix: true,
+            exports: ["*"],
+          },
+        },
+        executors: {
+          default: {
+            exports: ["*"],
+            models: {
+              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
+            },
           },
         },
-        executors: {},
       },
       fetchImpl: vi.fn(async (input, init) => {
         capturedUrl = String(input);
@@ -98,12 +103,17 @@ describe("router execution", () => {
           openai: {
             api_base_url: "https://api.openai.com/v1",
             style: "responses",
-            allow_anonymous: true,
-            exports: ["gpt-5"],
-            no_prefix: true,
+            exports: ["*"],
+          },
+        },
+        executors: {
+          default: {
+            exports: ["*"],
+            models: {
+              "gpt-5": { provider: "openai", model: "gpt-5" },
+            },
           },
         },
-        executors: {},
       },
       fetchImpl: vi.fn(async (input, init) => {
         capturedUrl = String(input);
@@ -166,12 +176,17 @@ describe("router execution", () => {
           anthropic: {
             api_base_url: "https://api.anthropic.com",
             style: "anthropic-messages",
-            allow_anonymous: true,
-            exports: ["claude-*"],
-            no_prefix: true,
+            exports: ["*"],
+          },
+        },
+        executors: {
+          default: {
+            exports: ["*"],
+            models: {
+              "claude-sonnet-4": { provider: "anthropic", model: "claude-sonnet-4" },
+            },
           },
         },
-        executors: {},
       },
       fetchImpl: vi.fn(async (input, init) => {
         capturedUrl = String(input);
@@ -236,12 +251,17 @@ describe("router execution", () => {
           google: {
             api_base_url: "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent",
             style: "google-genai",
-            allow_anonymous: true,
-            exports: ["gemini-*"],
-            no_prefix: true,
+            exports: ["*"],
+          },
+        },
+        executors: {
+          default: {
+            exports: ["*"],
+            models: {
+              "gemini-2.5-flash": { provider: "google", model: "gemini-2.5-flash" },
+            },
           },
         },
-        executors: {},
       },
       fetchImpl: vi.fn(async (input, init) => {
         capturedUrl = String(input);
@@ -359,12 +379,17 @@ describe("router execution", () => {
           openrouter: {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
-            allow_anonymous: true,
-            exports: ["gpt-4o"],
-            no_prefix: true,
+            exports: ["*"],
+          },
+        },
+        executors: {
+          default: {
+            exports: ["*"],
+            models: {
+              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
+            },
           },
         },
-        executors: {},
       },
       fetchImpl: vi.fn(async () => {
         const stream = new ReadableStream<Uint8Array>({
@@ -428,12 +453,17 @@ describe("router execution", () => {
           openrouter: {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
-            allow_anonymous: true,
-            exports: ["gpt-4o"],
-            no_prefix: true,
+            exports: ["*"],
+          },
+        },
+        executors: {
+          default: {
+            exports: ["*"],
+            models: {
+              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
+            },
           },
         },
-        executors: {},
       },
       fetchImpl: vi.fn(async (_input, init) => {
         return await new Promise<Response>((_resolve, reject) => {

package/src/router/execute.ts

@@ -28,7 +28,7 @@ import type { RequestContext, TargetAuthContext } from "../auth/types.ts";
 import { cloneForwardHeaders, isSse } from "../util/headers.ts";
 import { eventDataLines, splitSseEvents } from "../util/sse.ts";
 import { resolveInvocationTarget, type ResolvedTarget } from "./resolve.ts";
-import type { RouterRuntime } from "./runtime.ts";
+import type { ProviderRuntime, RouterRuntime } from "./runtime.ts";
 
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
@@ -300,19 +300,14 @@ export function createFetchProviderInvoker(
 ): ProviderInvoker {
   return {
     async execute(request, providerCtx) {
-      const provider = getProviderOrThrow(runtime, providerCtx.target.provider, providerCtx.target.model);
+      const provider = getProviderOrThrow(runtime, providerCtx.target.provider);
       const timed = createUpstreamSignal(providerCtx.signal, upstreamTimeoutMs);
 
       try {
         const upstream = await fetchProvider(
           runtime,
           ctx,
-          provider.name,
-          provider.allowAnonymous,
-          provider.headers,
-          provider.apiBaseUrl,
-          provider.endpointPath,
-          provider.style,
+          provider,
           setModel(request, providerCtx.target.model),
           timed.signal,
         );
@@ -330,7 +325,7 @@ export function createFetchProviderInvoker(
     },
 
     async *stream(request, providerCtx) {
-      const provider = getProviderOrThrow(runtime, providerCtx.target.provider, providerCtx.target.model);
+      const provider = getProviderOrThrow(runtime, providerCtx.target.provider);
       const timed = createUpstreamSignal(providerCtx.signal, upstreamTimeoutMs);
       let reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
       let buffer = "";
@@ -339,12 +334,7 @@ export function createFetchProviderInvoker(
         const upstream = await fetchProvider(
           runtime,
           ctx,
-          provider.name,
-          provider.allowAnonymous,
-          provider.headers,
-          provider.apiBaseUrl,
-          provider.endpointPath,
-          provider.style,
+          provider,
           setModel(request, providerCtx.target.model),
           timed.signal,
         );
@@ -516,50 +506,31 @@ function timingHeaders(userTimeMs: number): Record<string, string> {
 async function fetchProvider(
   runtime: RouterRuntime,
   ctx: RequestContext,
-  providerName: string,
-  allowAnonymous: boolean,
-  providerHeaders: Readonly<Record<string, string>>,
-  apiBaseUrl: string,
-  endpointPath: string,
-  providerStyle: RouterRuntime["providers"] extends ReadonlyMap<string, infer T>
-    ? T extends { style: infer S }
-      ? S
-      : never
-    : never,
+  provider: ProviderRuntime,
   request: Program,
   signal: AbortSignal,
 ): Promise<Response> {
   const headers = cloneForwardHeaders(ctx.request.headers);
   headers.set("content-type", "application/json");
-  for (const [key, value] of Object.entries(providerHeaders)) {
+  for (const [key, value] of Object.entries(provider.headers)) {
     headers.set(key, value);
   }
 
-  let hasAuth = false;
   for (const driver of runtime.authChain) {
-    const targetCtx: TargetAuthContext = { ...ctx, providerName };
+    const targetCtx: TargetAuthContext = { ...ctx, providerName: provider.name };
     const auth = await driver.collectTarget(targetCtx);
     if (!auth) {
       continue;
     }
     new Headers(auth.headers).forEach((value, key) => headers.set(key, value));
-    hasAuth = true;
     break;
   }
 
-  if (!hasAuth && !allowAnonymous) {
-    throw new RouterError(
-      `No auth available for provider ${providerName}`,
-      401,
-      "provider_auth_missing",
-    );
-  }
-
-  let body = emitProviderRequest(providerStyle, request);
-  if (providerStyle === "chat-completions" && isStreaming(request)) {
+  let body = emitProviderRequest(provider.style, request);
+  if (provider.style === "chat-completions" && isStreaming(request)) {
     body = injectStreamUsage(body);
   }
-  return runtime.fetchImpl(`${apiBaseUrl}${endpointPath}`, {
+  return runtime.fetchImpl(`${provider.apiBaseUrl}${provider.endpointPath}`, {
     method: "POST",
     headers,
     body: toBody(body),
@@ -567,32 +538,23 @@ async function fetchProvider(
   });
 }
 
-function getProviderOrThrow(runtime: RouterRuntime, providerName: string | undefined, model?: string) {
-  if (providerName) {
-    const provider = runtime.providers.get(providerName);
-    if (!provider) {
-      throw new RouterError(
-        `Provider ${providerName} is not configured`,
-        500,
-        "provider_not_configured",
-      );
-    }
-    return provider;
+function getProviderOrThrow(runtime: RouterRuntime, providerName: string | undefined) {
+  if (!providerName) {
+    throw new RouterError(
+      "No provider specified on execution target",
+      500,
+      "provider_not_configured",
+    );
   }
-
-  for (const name of runtime.providerOrder) {
-    const provider = runtime.providers.get(name)!;
-    if (!provider.noPrefix) continue;
-    if (provider.exportsMatcher(model ?? "")) {
-      return provider;
-    }
+  const provider = runtime.providers.get(providerName);
+  if (!provider) {
+    throw new RouterError(
+      `Provider ${providerName} is not configured`,
+      500,
+      "provider_not_configured",
+    );
   }
-
-  throw new RouterError(
-    `No provider found for model \`${model ?? "(unknown)"}\``,
-    404,
-    "provider_not_found",
-  );
+  return provider;
 }
 
 async function toProviderError(

package/src/router/resolve.test.ts

@@ -10,8 +10,7 @@ describe("router resolution", () => {
           openrouter: {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
-            exports: ["gemma-*"],
-            catalog: ["gemma-4-31b-it"],
+            exports: ["*"],
           },
         },
         executors: {
@@ -45,7 +44,6 @@ describe("router resolution", () => {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
             exports: ["google/*"],
-            catalog: ["google/gemma-4-31b-it"],
           },
         },
         executors: {},
@@ -71,7 +69,6 @@ describe("router resolution", () => {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
             exports: ["openai/gpt-4.1-mini"],
-            catalog: ["openai/gpt-4.1-mini"],
           },
         },
         executors: {
@@ -96,15 +93,14 @@ describe("router resolution", () => {
     });
   });
 
-  it("lists configured executor and provider models as qualified IDs", () => {
+  it("lists configured executor models as qualified IDs", () => {
     const runtime = createRouterRuntime({
       config: {
         providers: {
           openrouter: {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
-            exports: ["google/*", "openai/*"],
-            catalog: ["google/gemma-4-31b-it", "openai/gpt-4o", "anthropic/claude-sonnet-4"],
+            exports: ["*"],
           },
         },
         executors: {
@@ -122,34 +118,38 @@ describe("router resolution", () => {
     expect(listConfiguredModels(runtime)).toEqual([
       "enei/enei-1",
       "enei/enei-1-pro",
-      "openrouter/google/gemma-4-31b-it",
-      "openrouter/openai/gpt-4o",
     ]);
   });
 
-  it("returns multiple candidates for unqualified provider matches", () => {
+  it("resolves unqualified model through executor routes", () => {
     const runtime = createRouterRuntime({
       config: {
         providers: {
           openrouter: {
             api_base_url: "https://openrouter.ai/api/v1",
             style: "chat-completions",
-            exports: ["gpt-4o"],
-            no_prefix: true,
+            exports: ["*"],
           },
-          backup: {
-            api_base_url: "https://backup.example/v1",
-            style: "chat-completions",
-            exports: ["gpt-4o"],
-            no_prefix: true,
+        },
+        executors: {
+          default: {
+            exports: ["*"],
+            models: {
+              "gpt-4o": { provider: "openrouter", model: "openai/gpt-4o" },
+            },
           },
         },
-        executors: {},
       },
     });
 
     const resolved = resolveInvocationTargets(runtime, "gpt-4o");
-    expect(resolved).toHaveLength(2);
-    expect(resolved.map((item) => item.namespace)).toEqual(["openrouter", "backup"]);
+    expect(resolved).toHaveLength(1);
+    expect(resolved[0]!.namespace).toBe("default");
+    expect(resolved[0]!.target).toEqual({
+      kind: "provider",
+      provider: "openrouter",
+      model: "openai/gpt-4o",
+      transforms: [],
+    });
   });
 });

package/src/router/resolve.ts

@@ -48,31 +48,11 @@ export function resolveInvocationTargets(
     }
   }
 
-  for (const namespace of runtime.providerOrder) {
-    const provider = runtime.providers.get(namespace)!;
-    if (!provider.noPrefix) continue;
-    if (provider.exportsMatcher(parsed.baseModel)) {
-      matches.push({
-        requestedModel,
-        namespace,
-        source: "provider",
-        suffixes: parsed.suffixes,
-        target: {
-          kind: "provider",
-          provider: namespace,
-          model: parsed.baseModel,
-          transforms: parsed.suffixes.map((suffix) => suffix.raw),
-        },
-      });
-    }
-  }
-
   return matches;
 }
 
 export function listConfiguredModels(runtime: RouterRuntime): string[] {
   const models: string[] = [];
-  const seen = new Set<string>();
 
   for (const namespace of runtime.executorOrder) {
     const executor = runtime.executors.get(namespace)!;
@@ -83,19 +63,6 @@ export function listConfiguredModels(runtime: RouterRuntime): string[] {
     }
   }
 
-  for (const namespace of runtime.providerOrder) {
-    const provider = runtime.providers.get(namespace)!;
-    for (const model of provider.catalog) {
-      if (provider.exportsMatcher(model)) {
-        models.push(`${namespace}/${model}`);
-        if (provider.noPrefix && !seen.has(model)) {
-          seen.add(model);
-          models.push(model);
-        }
-      }
-    }
-  }
-
   return models;
 }
 

package/src/router/runtime.ts

@@ -14,11 +14,8 @@ export type ProviderRuntime = {
   style: ProviderTargetConfig["style"];
   apiBaseUrl: string;
   endpointPath: string;
-  allowAnonymous: boolean;
-  noPrefix: boolean;
   headers: Readonly<Record<string, string>>;
   exportsMatcher: (model: string) => boolean;
-  catalog: readonly string[];
 };
 
 export type ExecutorRouteRuntime = {
@@ -84,12 +81,9 @@ function buildProviderRuntime(name: string, config: ProviderTargetConfig): Provi
     name,
     style: config.style,
     apiBaseUrl: config.api_base_url,
-    endpointPath: config.endpoint_path ?? defaultEndpointPath(config.style),
-    allowAnonymous: config.allow_anonymous ?? false,
-    noPrefix: config.no_prefix ?? false,
+    endpointPath: defaultEndpointPath(config.style),
     headers: config.headers ?? {},
     exportsMatcher: createExportsMatcher(config.exports),
-    catalog: config.catalog ?? [],
   };
 }
 

package/src/worker.ts

@@ -1,3 +1,5 @@
+type ExecutionContext = { waitUntil(p: Promise<unknown>): void; passThroughOnException(): void };
+
 import type { RouterConfig } from "./router/index.ts";
 import { createApp } from "./example.ts";
 
@@ -13,7 +15,6 @@ const config: RouterConfig = {
     openrouter: {
       api_base_url: "https://openrouter.ai/api/v1",
       style: "chat-completions",
-      allow_anonymous: false,
       exports: ["*:free"],
     },
   },

package/tsconfig.json

@@ -1,9 +1,21 @@
 {
-  "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "types": ["node", "./worker-configuration.d.ts", "vitest/globals"],
-    "outDir": "dist"
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable", "WebWorker"],
+    "strict": true,
+    "allowImportingTsExtensions": true,
+    "allowArbitraryExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "sourceMap": true,
+    "noEmit": true,
+    "types": ["node", "vitest/globals"]
   },
   "include": ["src/**/*.ts", "src/**/*.d.ts"],
-  "exclude": ["test", "dist", "node_modules"],
+  "exclude": ["test", "dist", "node_modules"]
 }