@neutrome/open-ai-router 0.4.2 → 0.5.0

package/src/example.test.ts

@@ -1,377 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { appendAssistantMessage } from "@neutrome/lilsdk-ts/synthetic";
-import { streamTextResponse } from "@neutrome/lilsdk-ts/stream";
-import {
-  getModel,
-} from "@neutrome/lil-engine";
-import { createApp } from "./example.ts";
-
-const decoder = new TextDecoder();
-
-describe("open-ai-router createApp", () => {
-  it("lists configured executor aliases", async () => {
-    const app = createApp({
-      config: {
-        providers: {
-          openrouter: {
-            api_base_url: "https://openrouter.ai/api/v1",
-            style: "chat-completions",
-            exports: ["*"],
-          },
-        },
-        modelNamespaces: {
-          semantyka: {
-            exports: ["enei-*"],
-            models: {
-              "enei-1": { executorId: "enei-1" },
-            },
-          },
-        },
-      },
-    });
-
-    const response = await app.request("/v1/models");
-
-    expect(response.status).toBe(200);
-    expect(await response.json()).toEqual({
-      object: "list",
-      data: [
-        { id: "semantyka/enei-1", object: "model", created: 0, owned_by: "semantyka" },
-      ],
-    });
-  });
-
-  it("serves provider-backed chat completions through the app surface", async () => {
-    let capturedBody: Record<string, unknown> | null = null;
-
-    const app = createApp({
-      config: {
-        upstreamAuth: {
-          order: ["proxy"],
-          proxy: {
-            headers: ["authorization"],
-          },
-        },
-        providers: {
-          openrouter: {
-            api_base_url: "https://openrouter.ai/api/v1",
-            style: "chat-completions",
-            exports: ["*"],
-          },
-        },
-        modelNamespaces: {
-          default: {
-            exports: ["*"],
-            models: {
-              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
-            },
-          },
-        },
-      },
-      fetchImpl: vi.fn(async (_input, init) => {
-        capturedBody = JSON.parse(decoder.decode(new Uint8Array(init?.body as ArrayBuffer)));
-        return new Response(
-          JSON.stringify({
-            id: "resp_1",
-            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/chat/completions", {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-key",
-        "content-type": "application/json",
-      },
-      body: JSON.stringify({
-        model: "gpt-4o",
-        messages: [{ role: "user", content: "hi" }],
-      }),
-    });
-
-    expect(response.status).toBe(200);
-    expect(capturedBody).toEqual({
-      model: "gpt-4o",
-      messages: [{ role: "user", content: "hi" }],
-    });
-    expect(response.headers.get("x-openairouter-provider-id")).toBe("openrouter");
-    expect(await response.json()).toEqual({
-      object: "chat.completion",
-      id: "resp_1",
-      model: "gpt-4o",
-      choices: [
-        {
-          index: 0,
-          message: { role: "assistant", content: "hello" },
-          finish_reason: "stop",
-        },
-      ],
-    });
-  });
-
-  it("serves responses through chat-completions provider transport", 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",
-            exports: ["*"],
-          },
-        },
-        modelNamespaces: {
-          default: {
-            exports: ["*"],
-            models: {
-              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
-            },
-          },
-        },
-      },
-      fetchImpl: vi.fn(async (_input, init) => {
-        capturedBody = JSON.parse(decoder.decode(new Uint8Array(init?.body as ArrayBuffer)));
-        return new Response(
-          JSON.stringify({
-            id: "resp_2",
-            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/responses", {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-      },
-      body: JSON.stringify({
-        model: "gpt-4o",
-        input: [{ role: "user", content: "hi" }],
-      }),
-    });
-
-    expect(response.status).toBe(200);
-    expect(capturedBody).toEqual({
-      model: "gpt-4o",
-      messages: [{ role: "user", content: "hi" }],
-    });
-    expect(await response.json()).toEqual({
-      id: "resp_2",
-      model: "gpt-4o",
-      output: [
-        {
-          type: "message",
-          role: "assistant",
-          status: "completed",
-          content: [{ type: "output_text", text: "hello" }],
-        },
-      ],
-    });
-  });
-
-  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",
-            exports: ["*"],
-          },
-        },
-        modelNamespaces: {
-          default: {
-            exports: ["*"],
-            models: {
-              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
-            },
-          },
-        },
-      },
-      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: {},
-        modelNamespaces: {
-          support: {
-            exports: ["*"],
-            models: {
-              "refund-router": { executorId: "support/refund-router" },
-            },
-          },
-        },
-      },
-      executorImplementations: {
-        "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: {},
-        modelNamespaces: {
-          support: {
-            exports: ["*"],
-            models: {
-              "refund-router": { executorId: "support/refund-router" },
-            },
-          },
-        },
-      },
-      executorImplementations: {
-        "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,73 +0,0 @@
-import { Hono } from "hono";
-import { cors } from "./app/cors.ts";
-import {
-  anthropicMessagesHandler,
-  chatCompletionsHandler,
-  googleGenAIHandler,
-  listModelsHandler,
-  responsesHandler,
-  type ChatCompletionsHandlerOptions,
-} from "./app/handlers.ts";
-import { healthHandler } from "./app/health.ts";
-import { createRouterRuntime, type CreateRouterOptions } from "./router/index.ts";
-
-export type CreateAppOptions = CreateRouterOptions & ChatCompletionsHandlerOptions;
-
-export function createApp(options: CreateAppOptions) {
-  const routerOptions = {
-    config: options.config,
-  } as CreateRouterOptions;
-
-  if (options.fetchImpl) {
-    routerOptions.fetchImpl = options.fetchImpl;
-  }
-  if (options.knownSuffixes) {
-    routerOptions.knownSuffixes = options.knownSuffixes;
-  }
-  if (options.upstreamAuthDrivers) {
-    routerOptions.upstreamAuthDrivers = options.upstreamAuthDrivers;
-  }
-
-  const runtime = createRouterRuntime(routerOptions);
-  const app = new Hono();
-
-  const handlerOptions = {} as ChatCompletionsHandlerOptions;
-  if (options.executorImplementations) {
-    handlerOptions.executorImplementations = options.executorImplementations;
-  }
-  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;
-  }
-
-  app.use("/v1/models", cors());
-  app.get("/v1/models", listModelsHandler(runtime));
-
-  app.use("/v1/chat/completions", cors());
-  app.post("/v1/chat/completions", chatCompletionsHandler(runtime, handlerOptions));
-
-  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));
-
-  return app;
-}

package/src/observer.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createTraceCollector } from "./observer.ts";
-
-describe("createTraceCollector", () => {
-  it("prefixes raw trace chunks with event comments", () => {
-    const collector = createTraceCollector("00000000-0000-4000-8000-000000000001");
-
-    collector.observe({
-      kind: "request.received",
-      requestId: "request-1",
-      executionId: "request-1",
-      timestamp: "2026-06-24T12:00:00.000Z",
-      data: { lilText: "MSG_START" },
-    });
-    collector.observe({
-      kind: "provider.request",
-      requestId: "request-1",
-      executionId: "provider-1",
-      timestamp: "2026-06-24T12:00:01.000Z",
-      data: { lilText: "SET_MODEL \"gpt-4o\"" },
-    });
-    collector.observe({
-      kind: "provider.response_chunk",
-      requestId: "request-1",
-      executionId: "provider-1",
-      timestamp: "2026-06-24T12:00:02.000Z",
-      data: { lilText: "STREAM_DELTA \"Hi\"" },
-    });
-
-    expect(collector.getTrace().rawTrace).toBe(
-      ';request:0\nMSG_START\n\n;provider-request:1\nSET_MODEL "gpt-4o"\n\n;provider-response-chunk:2\nSTREAM_DELTA "Hi"',
-    );
-  });
-
-  it("appends structured timing comments with durationMs", () => {
-    const collector = createTraceCollector("00000000-0000-4000-8000-000000000001");
-
-    collector.observe({
-      kind: "provider.finished",
-      requestId: "request-1",
-      executionId: "provider-1",
-      timestamp: "2026-06-24T12:00:03.000Z",
-      data: {
-        startedAt: "2026-06-24T12:00:02.877Z",
-        finishedAt: "2026-06-24T12:00:03.000Z",
-        durationMs: 123,
-      },
-    });
-
-    expect(collector.getTrace().rawTrace).toBe(
-      ';timing {"kind":"provider","event":"provider.finished","requestId":"request-1","executionId":"provider-1","startedAt":"2026-06-24T12:00:02.877Z","finishedAt":"2026-06-24T12:00:03.000Z","durationMs":123}',
-    );
-  });
-});