@neutrome/open-ai-router 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutrome/open-ai-router",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"

package/src/app/cors.ts

@@ -4,5 +4,12 @@ export const cors = () =>
   honoCors({
     origin: "*",
     allowMethods: ["GET", "POST", "OPTIONS"],
-    allowHeaders: ["Content-Type", "Authorization", "X-OpenAIRouter-Token"],
+    allowHeaders: [
+      "Content-Type",
+      "Authorization",
+      "X-API-Key",
+      "Anthropic-Version",
+      "X-Goog-Api-Key",
+      "X-OpenAIRouter-Token",
+    ],
   });

package/src/app/handlers.ts

@@ -2,7 +2,9 @@ import type { Context } from "hono";
 import type { Executor, ProgramTransform } from "@neutrome/lil-engine";
 import type { RequestContext } from "../auth/types.ts";
 import {
+  handleAnthropicMessages,
   handleChatCompletions,
+  handleGoogleGenAI,
   handleResponses,
   listConfiguredModels,
   type RouterExecutionOptions,
@@ -22,6 +24,8 @@ export type ChatCompletionsHandlerOptions = RouterExecutionOptions & {
 };
 
 export type ResponsesHandlerOptions = ChatCompletionsHandlerOptions;
+export type AnthropicMessagesHandlerOptions = ChatCompletionsHandlerOptions;
+export type GoogleGenAIHandlerOptions = ChatCompletionsHandlerOptions;
 
 export function listModelsHandler(runtime: RouterRuntime) {
   return async (c: Context) => {
@@ -97,35 +101,7 @@ export function chatCompletionsHandler(
   options: ChatCompletionsHandlerOptions = {},
 ) {
   return async (c: Context) => {
-    const ctx = createRequestContext(c);
-    collectIncomingAuth(ctx, runtime);
-    const handlerOptions = {
-      runtime,
-      ctx,
-    } as Parameters<typeof handleChatCompletions>[0];
-
-    if (options.executors) {
-      handlerOptions.executors = options.executors;
-    }
-    if (options.resolveExecutor) {
-      handlerOptions.resolveExecutor = options.resolveExecutor;
-    }
-    if (options.transforms) {
-      handlerOptions.transforms = options.transforms;
-    }
-    if (options.observe) {
-      handlerOptions.observe = options.observe;
-    }
-    if (options.requestIdFactory) {
-      handlerOptions.requestIdFactory = options.requestIdFactory;
-    }
-    if (options.executionIdFactory) {
-      handlerOptions.executionIdFactory = options.executionIdFactory;
-    }
-    if (options.upstreamTimeoutMs !== undefined) {
-      handlerOptions.upstreamTimeoutMs = options.upstreamTimeoutMs;
-    }
-
+    const handlerOptions = createExecutionHandlerOptions(c, runtime, options);
     return handleChatCompletions(handlerOptions);
   };
 }
@@ -135,42 +111,86 @@ export function responsesHandler(
   options: ResponsesHandlerOptions = {},
 ) {
   return async (c: Context) => {
-    const ctx = createRequestContext(c);
-    collectIncomingAuth(ctx, runtime);
-    const handlerOptions = {
-      runtime,
-      ctx,
-    } as Parameters<typeof handleResponses>[0];
+    const handlerOptions = createExecutionHandlerOptions(c, runtime, options);
+    return handleResponses(handlerOptions);
+  };
+}
 
-    if (options.executors) {
-      handlerOptions.executors = options.executors;
-    }
-    if (options.resolveExecutor) {
-      handlerOptions.resolveExecutor = options.resolveExecutor;
-    }
-    if (options.transforms) {
-      handlerOptions.transforms = options.transforms;
-    }
-    if (options.observe) {
-      handlerOptions.observe = options.observe;
-    }
-    if (options.requestIdFactory) {
-      handlerOptions.requestIdFactory = options.requestIdFactory;
-    }
-    if (options.executionIdFactory) {
-      handlerOptions.executionIdFactory = options.executionIdFactory;
-    }
-    if (options.upstreamTimeoutMs !== undefined) {
-      handlerOptions.upstreamTimeoutMs = options.upstreamTimeoutMs;
+export function anthropicMessagesHandler(
+  runtime: RouterRuntime,
+  options: AnthropicMessagesHandlerOptions = {},
+) {
+  return async (c: Context) => {
+    const handlerOptions = createExecutionHandlerOptions(c, runtime, options);
+    return handleAnthropicMessages(handlerOptions);
+  };
+}
+
+export function googleGenAIHandler(
+  runtime: RouterRuntime,
+  options: GoogleGenAIHandlerOptions = {},
+) {
+  return async (c: Context) => {
+    const route = parseGoogleGenAIRoute(c.req.raw);
+    if (!route) {
+      return c.text("Not Found", 404);
     }
 
-    return handleResponses(handlerOptions);
+    const request = await rewriteGoogleGenAIRequest(c.req.raw, route);
+    const handlerOptions = createExecutionHandlerOptions(
+      c,
+      runtime,
+      options,
+      request,
+    ) as Parameters<typeof handleGoogleGenAI>[0];
+    if (route.stream) {
+      handlerOptions.forceStreaming = true;
+    }
+    return handleGoogleGenAI(handlerOptions);
   };
 }
 
-function createRequestContext(c: Context): RequestContext {
+function createExecutionHandlerOptions(
+  c: Context,
+  runtime: RouterRuntime,
+  options: ChatCompletionsHandlerOptions,
+  request = c.req.raw,
+) {
+  const ctx = createRequestContext(c, request);
+  collectIncomingAuth(ctx, runtime);
+  const handlerOptions = {
+    runtime,
+    ctx,
+  } as Parameters<typeof handleChatCompletions>[0];
+
+  if (options.executors) {
+    handlerOptions.executors = options.executors;
+  }
+  if (options.resolveExecutor) {
+    handlerOptions.resolveExecutor = options.resolveExecutor;
+  }
+  if (options.transforms) {
+    handlerOptions.transforms = options.transforms;
+  }
+  if (options.observe) {
+    handlerOptions.observe = options.observe;
+  }
+  if (options.requestIdFactory) {
+    handlerOptions.requestIdFactory = options.requestIdFactory;
+  }
+  if (options.executionIdFactory) {
+    handlerOptions.executionIdFactory = options.executionIdFactory;
+  }
+  if (options.upstreamTimeoutMs !== undefined) {
+    handlerOptions.upstreamTimeoutMs = options.upstreamTimeoutMs;
+  }
+
+  return handlerOptions;
+}
+
+function createRequestContext(c: Context, request = c.req.raw): RequestContext {
   return {
-    request: c.req.raw,
+    request,
     incomingAuth: new Map(),
     env: (c.env ?? {}) as Record<string, unknown>,
     state: new Map(),
@@ -190,3 +210,42 @@ function ownerFromModelId(id: string): string {
   }
   return id.slice(0, slash);
 }
+
+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)) {
+      const body = JSON.stringify({
+        ...raw,
+        model: route.model,
+        ...(route.stream ? { stream: true } : {}),
+      });
+      return new Request(request.url, { method: request.method, headers, body });
+    }
+  } catch {}
+
+  return new Request(request.url, { method: request.method, headers, body: bodyText });
+}

package/src/example.test.ts

@@ -1,4 +1,9 @@
 import { describe, expect, it, vi } from "vitest";
+import {
+  appendAssistantMessage,
+  getModel,
+  streamTextResponse,
+} from "@neutrome/lil-engine";
 import { createApp } from "./example.ts";
 
 const decoder = new TextDecoder();
@@ -226,4 +231,177 @@ describe("open-ai-router createApp", () => {
       ],
     });
   });
+
+  it("serves anthropic messages through the app surface", async () => {
+    let capturedBody: Record<string, unknown> | null = null;
+
+    const app = createApp({
+      config: {
+        providers: {
+          openrouter: {
+            api_base_url: "https://openrouter.ai/api/v1",
+            style: "chat-completions",
+            allow_anonymous: true,
+            exports: ["gpt-4o"],
+            no_prefix: true,
+          },
+        },
+        executors: {},
+      },
+      fetchImpl: vi.fn(async (_input, init) => {
+        capturedBody = JSON.parse(decoder.decode(new Uint8Array(init?.body as ArrayBuffer)));
+        return new Response(
+          JSON.stringify({
+            id: "resp_3",
+            model: "gpt-4o",
+            choices: [
+              {
+                index: 0,
+                message: { role: "assistant", content: "hello" },
+                finish_reason: "stop",
+              },
+            ],
+          }),
+          {
+            headers: {
+              "content-type": "application/json; charset=utf-8",
+            },
+          },
+        );
+      }),
+    });
+
+    const response = await app.request("/v1/messages", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "gpt-4o",
+        messages: [
+          {
+            role: "user",
+            content: [{ type: "text", text: "hi" }],
+          },
+        ],
+      }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(capturedBody).toEqual({
+      model: "gpt-4o",
+      messages: [{ role: "user", content: "hi" }],
+    });
+    expect(await response.json()).toEqual({
+      id: "resp_3",
+      model: "gpt-4o",
+      role: "assistant",
+      content: [{ type: "text", text: "hello" }],
+      stop_reason: "end_turn",
+    });
+  });
+
+  it("serves google generateContent routes and decodes namespaced model paths", async () => {
+    let capturedModel: string | null = null;
+    let executeCalled = false;
+
+    const app = createApp({
+      config: {
+        providers: {},
+        executors: {
+          support: {
+            exports: ["*"],
+            models: {
+              "refund-router": { executor: "support/refund-router" },
+            },
+          },
+        },
+      },
+      executors: {
+        "support/refund-router": {
+          async execute(request) {
+            executeCalled = true;
+            capturedModel = getModel(request) ?? null;
+            return appendAssistantMessage(request, "hello");
+          },
+          async *stream(request) {
+            capturedModel = getModel(request) ?? null;
+            yield* streamTextResponse("hello");
+          },
+        },
+      },
+    });
+
+    const response = await app.request("/v1/models/support%2Frefund-router:generateContent", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        contents: [{ role: "user", parts: [{ text: "hi" }] }],
+      }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(executeCalled).toBe(true);
+    expect(capturedModel).toBe("support/refund-router");
+    expect(await response.json()).toEqual({
+      candidates: [
+        {
+          content: {
+            role: "model",
+            parts: [{ text: "hello" }],
+          },
+        },
+      ],
+    });
+  });
+
+  it("serves google streamGenerateContent routes as event streams", async () => {
+    let capturedModel: string | null = null;
+
+    const app = createApp({
+      config: {
+        providers: {},
+        executors: {
+          support: {
+            exports: ["*"],
+            models: {
+              "refund-router": { executor: "support/refund-router" },
+            },
+          },
+        },
+      },
+      executors: {
+        "support/refund-router": {
+          async execute(request) {
+            capturedModel = getModel(request) ?? null;
+            return appendAssistantMessage(request, "hello");
+          },
+          async *stream(request) {
+            capturedModel = getModel(request) ?? null;
+            yield* streamTextResponse("hello");
+          },
+        },
+      },
+    });
+
+    const response = await app.request("/v1/models/support%2Frefund-router:streamGenerateContent", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        contents: [{ role: "user", parts: [{ text: "hi" }] }],
+      }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(capturedModel).toBe("support/refund-router");
+    expect(response.headers.get("content-type")).toContain("text/event-stream");
+    const body = await response.text();
+    expect(body).toContain("\"candidates\"");
+    expect(body).toContain("\"text\":\"hello\"");
+    expect(body).toContain("\"finishReason\":\"STOP\"");
+  });
 });

package/src/example.ts

@@ -1,7 +1,9 @@
 import { Hono } from "hono";
 import { cors } from "./app/cors.ts";
 import {
+  anthropicMessagesHandler,
   chatCompletionsHandler,
+  googleGenAIHandler,
   listModelsHandler,
   responsesHandler,
   type ChatCompletionsHandlerOptions,
@@ -55,6 +57,12 @@ export function createApp(options: CreateAppOptions) {
   app.use("/v1/responses", cors());
   app.post("/v1/responses", responsesHandler(runtime, handlerOptions));
 
+  app.use("/v1/messages", cors());
+  app.post("/v1/messages", anthropicMessagesHandler(runtime, handlerOptions));
+
+  app.use("/v1/models/*", cors());
+  app.post("/v1/models/*", googleGenAIHandler(runtime, handlerOptions));
+
   app.get("/health", healthHandler());
   app.all("*", (c) => c.text("Not Found", 404));
 

package/src/index.ts

@@ -5,7 +5,9 @@ export {
   createFetchProviderInvoker,
   createRouterExecutionRuntime,
   createRouterRuntime,
+  handleAnthropicMessages,
   handleChatCompletions,
+  handleGoogleGenAI,
   handleResponses,
   listConfiguredModels,
   ProviderHttpError,
@@ -21,7 +23,9 @@ export type {
   ExecutorRouteConfig,
   ExecutorRouteRuntime,
   ExecutorRuntime,
+  HandleAnthropicMessagesOptions,
   HandleChatCompletionsOptions,
+  HandleGoogleGenAIOptions,
   HandleResponsesOptions,
   ProviderApiStyle,
   ProviderApiStyle as ProviderStyle,
@@ -46,5 +50,16 @@ export { proxyAuthDriver } from "./auth/proxy.ts";
 
 export { cors } from "./app/cors.ts";
 export { healthHandler } from "./app/health.ts";
-export { chatCompletionsHandler, listModelsHandler, responsesHandler } from "./app/handlers.ts";
-export type { ChatCompletionsHandlerOptions, ResponsesHandlerOptions } from "./app/handlers.ts";
+export {
+  anthropicMessagesHandler,
+  chatCompletionsHandler,
+  googleGenAIHandler,
+  listModelsHandler,
+  responsesHandler,
+} from "./app/handlers.ts";
+export type {
+  AnthropicMessagesHandlerOptions,
+  ChatCompletionsHandlerOptions,
+  GoogleGenAIHandlerOptions,
+  ResponsesHandlerOptions,
+} from "./app/handlers.ts";

package/src/router/execute.ts

@@ -1,8 +1,7 @@
 import {
   emitChatCompletionsResponse,
-  emitChatCompletionsStreamChunk,
-  emitProviderResponse,
   emitProviderRequest,
+  emitProviderResponse,
   emitProviderStreamChunk,
   getModel,
   isStreaming,
@@ -11,8 +10,10 @@ import {
   parseProviderResponse,
   parseProviderStreamChunk,
   setModel,
-  usageObject,
+  setStreaming,
   type Program,
+  type ProviderStyle,
+  usageObject,
 } from "@neutrome/lil-engine";
 import {
   createExecutionRuntime,
@@ -60,6 +61,17 @@ export type HandleResponsesOptions = RouterExecutionOptions & {
   ctx: RequestContext;
 };
 
+export type HandleAnthropicMessagesOptions = RouterExecutionOptions & {
+  runtime: RouterRuntime;
+  ctx: RequestContext;
+};
+
+export type HandleGoogleGenAIOptions = RouterExecutionOptions & {
+  runtime: RouterRuntime;
+  ctx: RequestContext;
+  forceStreaming?: boolean;
+};
+
 export class RouterError extends Error {
   constructor(
     message: string,
@@ -102,9 +114,6 @@ export function createRouterExecutionRuntime(
   if (options.executors) {
     runtimeOptions.executors = options.executors;
   }
-  if (options.resolveExecutor) {
-    runtimeOptions.resolveExecutor = options.resolveExecutor;
-  }
   if (options.transforms) {
     runtimeOptions.transforms = options.transforms;
   }
@@ -118,9 +127,41 @@ export function createRouterExecutionRuntime(
     runtimeOptions.executionIdFactory = options.executionIdFactory;
   }
 
+  const userResolveExecutor = options.resolveExecutor;
+  runtimeOptions.resolveExecutor = (name) => {
+    if (userResolveExecutor) {
+      const result = userResolveExecutor(name);
+      if (result) return result;
+    }
+    return resolveNamespaceExecutor(runtime, name);
+  };
+
   return createExecutionRuntime(runtimeOptions);
 }
 
+function resolveNamespaceExecutor(
+  runtime: RouterRuntime,
+  name: string,
+): Executor | null {
+  const executor = runtime.executors.get(name);
+  if (!executor) return null;
+
+  return {
+    async execute(request, ctx) {
+      const model = getModel(request);
+      if (!model) throw new ExecutionError("resolution", "Request is missing model for namespace executor resolution", { stage: "target_resolution" });
+      const resolved = resolveInvocationTarget(runtime, `${name}/${model}`);
+      return ctx.invoke(request, { target: resolved.target });
+    },
+    async *stream(request, ctx) {
+      const model = getModel(request);
+      if (!model) throw new ExecutionError("resolution", "Request is missing model for namespace executor resolution", { stage: "target_resolution" });
+      const resolved = resolveInvocationTarget(runtime, `${name}/${model}`);
+      yield* ctx.invokeStream(request, { target: resolved.target });
+    },
+  };
+}
+
 export async function handleChatCompletions(
   options: HandleChatCompletionsOptions,
 ): Promise<Response> {
@@ -165,10 +206,39 @@ export async function handleChatCompletions(
 
 export async function handleResponses(
   options: HandleResponsesOptions,
+): Promise<Response> {
+  return handleProviderStyle("responses", options);
+}
+
+export async function handleAnthropicMessages(
+  options: HandleAnthropicMessagesOptions,
+): Promise<Response> {
+  return handleProviderStyle("anthropic-messages", options);
+}
+
+export async function handleGoogleGenAI(
+  options: HandleGoogleGenAIOptions,
+): Promise<Response> {
+  return handleProviderStyle(
+    "google-genai",
+    options,
+    options.forceStreaming ? (request) => setStreaming(request, true) : undefined,
+  );
+}
+
+async function handleProviderStyle(
+  style: Exclude<ProviderStyle, "chat-completions">,
+  options: RouterExecutionOptions & {
+    runtime: RouterRuntime;
+    ctx: RequestContext;
+  },
+  mutateRequest?: (request: Program) => Program,
 ): Promise<Response> {
   try {
     const requestBody = new Uint8Array(await options.ctx.request.arrayBuffer());
-    const request = parseProviderRequest("responses", requestBody);
+    const request = mutateRequest
+      ? mutateRequest(parseProviderRequest(style, requestBody))
+      : parseProviderRequest(style, requestBody);
     const resolved = resolveRequestTarget(options.runtime, request);
     const execution = createRouterExecutionRuntime(
       options.runtime,
@@ -180,7 +250,7 @@ export async function handleResponses(
     if (isStreaming(request)) {
       const chunks = execution.stream(request, { target: resolved.target });
       return await streamExecutionResponse(
-        "responses",
+        style,
         chunks,
         resolved,
         startTime,
@@ -194,7 +264,7 @@ export async function handleResponses(
     const userTime = Date.now() - startTime;
     reportUsage(response, resolved, options.onUsage);
     return jsonExecutionResponse(
-      emitProviderResponse("responses", response),
+      emitProviderResponse(style, response),
       resolved,
       userTime,
     );
@@ -336,7 +406,7 @@ export function createFetchProviderInvoker(
 }
 
 async function streamExecutionResponse(
-  responseStyle: "chat-completions" | "responses",
+  responseStyle: ProviderStyle,
   chunks: AsyncIterable<Program>,
   resolved: ResolvedTarget,
   startTime: number,
@@ -357,10 +427,7 @@ async function streamExecutionResponse(
           const hasUsage = usageObject(chunk) !== undefined;
           if (hasUsage) lastChunkWithUsage = chunk;
           if (hasUsage && !emitUsageToClient) return;
-          const bytes =
-            responseStyle === "chat-completions"
-              ? emitChatCompletionsStreamChunk(chunk)
-              : emitProviderStreamChunk("responses", chunk);
+          const bytes = emitProviderStreamChunk(responseStyle, chunk);
           controller.enqueue(
             encoder.encode(`data: ${decoder.decode(bytes)}\n\n`),
           );

package/src/router/index.ts

@@ -2,7 +2,9 @@ export { createRouterRuntime } from "./runtime.ts";
 export {
   createFetchProviderInvoker,
   createRouterExecutionRuntime,
+  handleAnthropicMessages,
   handleChatCompletions,
+  handleGoogleGenAI,
   handleResponses,
   resolveRequestTarget,
   RouterError,
@@ -25,7 +27,9 @@ export type {
   RouterRuntime,
 } from "./runtime.ts";
 export type {
+  HandleAnthropicMessagesOptions,
   HandleChatCompletionsOptions,
+  HandleGoogleGenAIOptions,
   HandleResponsesOptions,
   RouterExecutionOptions,
   UsageReport,