@neutrome/open-ai-router 0.6.8 → 0.6.10

package/README.md

@@ -30,4 +30,4 @@ Notes:
 
 - `RouterConfig` is the canonical router config surface.
 - `/v1/models` lists configured executor aliases.
-- Executor contracts and `connectTools` come from `@neutrome/lilsdk`.
+- Executor contracts and `createToolsExecutor` come from `@neutrome/lilsdk`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutrome/open-ai-router",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
@@ -11,8 +11,8 @@
     "hono": "^4.12.18",
     "posthog-node": "^5.41.0",
     "zod": "^4.2.1",
-    "@neutrome/lil-engine": "0.4.5",
-    "@neutrome/lilsdk": "0.4.5"
+    "@neutrome/lil-engine": "0.5.1",
+    "@neutrome/lilsdk": "0.5.1"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",
@@ -25,6 +25,7 @@
     "cf-typegen": "wrangler types",
     "test": "vitest run",
     "typecheck": "tsc -p tsconfig.json --noEmit",
+    "npm:publish": "pnpm publish --no-git-checks",
     "dev": "wrangler dev",
     "preview": "wrangler preview",
     "deploy": "wrangler deploy"

package/src/app/factory.ts

@@ -1,9 +1,9 @@
 import { Hono, type Context } from "hono";
 import {
   getModel,
-  setStreaming,
   type Program,
   type ProviderStyle,
+  setStreaming,
 } from "@neutrome/lil-engine";
 import { cors } from "./cors.ts";
 import { healthHandler } from "./health.ts";

package/src/router/error-codec.ts

@@ -2,7 +2,7 @@ import {
   appendErrorBlock,
   createProgram,
   emitProviderError,
-  firstError,
+  getFirstErrorBlock,
   parseProviderError,
   type Program,
   type ProviderStyle,
@@ -21,7 +21,7 @@ export async function toProviderError(
     contentType: response.headers.get("content-type"),
   });
   const summary =
-    firstError(program)?.message ||
+    getFirstErrorBlock(program)?.message ||
     `Provider ${provider.name} returned ${response.status}`;
   return new ProviderHttpError(
     summary,

package/src/router/execute.test.ts

@@ -1,4 +1,4 @@
-import { appendAssistantMessage } from "@neutrome/lilsdk/synthetic";
+import { appendAssistantMessage } from "@neutrome/lil-engine";
 import { describe, expect, it, vi } from "vitest";
 import type { RequestContext } from "../upstream-auth/types.ts";
 import { handleChatCompletions } from "./execute.ts";

package/src/router/execute.ts

@@ -1,20 +1,18 @@
 import {
-  emitChatCompletionsResponse,
   emitProviderError,
   emitProviderRequest,
   emitProviderResponse,
   emitProviderStreamChunk,
   getModel,
+  getUsage,
   isStreaming,
-  parseChatCompletionsRequest,
   parseProviderRequest,
   parseProviderResponse,
   parseProviderStreamChunk,
-  setModel,
-  setStreaming,
   type Program,
   type ProviderStyle,
-  usageObject,
+  setModel,
+  setStreaming,
 } from "@neutrome/lil-engine";
 import { createExecutionRuntime } from "./execution-runtime.ts";
 import { createFetchProviderInvoker } from "./provider-invoker.ts";
@@ -165,10 +163,8 @@ export function createRouterExecutionRuntime(
 export async function handleChatCompletions(
   options: HandleChatCompletionsOptions,
 ): Promise<Response> {
-  return handleRequestStyle(
-    "chat-completions",
-    options,
-    emitChatCompletionsResponse,
+  return handleRequestStyle("chat-completions", options, (program) =>
+    emitProviderResponse("chat-completions", program),
   );
 }
 

package/src/router/execution-resolution.ts

@@ -1,4 +1,4 @@
-import { firstError, type Program } from "@neutrome/lil-engine";
+import { getFirstErrorBlock, type Program } from "@neutrome/lil-engine";
 import {
   ExecutionError,
   isExecutionError,
@@ -100,7 +100,7 @@ export function normalizeExecutionError(
 ): ExecutionError {
   if (isExecutionError(error)) return error;
   if (error instanceof ProviderHttpError) {
-    const upstream = firstError(error.program);
+    const upstream = getFirstErrorBlock(error.program);
     return new ExecutionError("provider", error.message, {
       stage: fallbackStage,
       details: {

package/src/router/provider-stream.ts

@@ -1,10 +1,10 @@
 import {
   emitProviderRequest,
+  getUsage,
   isStreaming,
   parseProviderStreamChunk,
-  setModel,
   type Program,
-  usageObject,
+  setModel,
 } from "@neutrome/lil-engine";
 import { RouterError } from "./errors.ts";
 import { toProviderError } from "./error-codec.ts";
@@ -155,7 +155,7 @@ export async function* streamProvider(
             encoder.encode(data),
           );
           responseChunks.push(chunk);
-          if (usageObject(chunk) !== undefined) lastChunkWithUsage = chunk;
+          if (getUsage(chunk) !== undefined) lastChunkWithUsage = chunk;
           yield chunk;
         }
       }
@@ -181,7 +181,7 @@ export async function* streamProvider(
           encoder.encode(data),
         );
         responseChunks.push(chunk);
-        if (usageObject(chunk) !== undefined) lastChunkWithUsage = chunk;
+        if (getUsage(chunk) !== undefined) lastChunkWithUsage = chunk;
         yield chunk;
       }
     }

package/src/router/provider-telemetry.ts

@@ -1,4 +1,4 @@
-import { usageObject, type Program } from "@neutrome/lil-engine";
+import { getUsage, type Program } from "@neutrome/lil-engine";
 import { createExecutionEvent } from "@neutrome/lilsdk";
 import { z } from "zod";
 import {
@@ -21,7 +21,7 @@ export function emitProviderUsage(
   responseBytes: number,
   streamChunks?: readonly Program[],
 ): void {
-  const usage = response ? usageObject(response) : undefined;
+  const usage = response ? getUsage(response) : undefined;
   const u = (usage && typeof usage === "object" ? usage : {}) as Record<
     string,
     unknown

package/src/router/remote-mcp-execution.ts

@@ -1,4 +1,4 @@
-import { connectTools } from "@neutrome/lilsdk/tools";
+import { createToolsExecutor } from "@neutrome/lilsdk/tools";
 import type {
   ExecutionTarget,
   Executor,
@@ -49,7 +49,10 @@ export function prepareRemoteMcpExecution(
       ...options,
       executorImplementations: {
         ...(options.executorImplementations ?? {}),
-        [executorName]: connectTools(remoteMcp.tools, resolved.requestedModel),
+        [executorName]: createToolsExecutor(
+          resolved.requestedModel,
+          remoteMcp.tools,
+        ),
       },
     },
     close: remoteMcp.close,

package/src/router/request-program.ts

@@ -1,5 +1,4 @@
 import {
-  parseChatCompletionsRequest,
   parseProviderRequest,
   type Program,
   type ProviderStyle,
@@ -11,6 +10,6 @@ export async function parseRequestProgram(
 ): Promise<Program> {
   const body = new Uint8Array(await request.arrayBuffer());
   return style === "chat-completions"
-    ? parseChatCompletionsRequest(body)
+    ? parseProviderRequest("chat-completions", body)
     : parseProviderRequest(style, body);
 }

package/src/router/response-delivery.ts

@@ -1,7 +1,7 @@
 import {
+  delta,
   emitProviderError,
   emitProviderStreamChunk,
-  repackStream,
   type Program,
   type ProviderStyle,
 } from "@neutrome/lil-engine";
@@ -21,9 +21,9 @@ export async function streamExecutionResponse(
   input: { requestId: string; executionId: string; startedAtMs: number },
   cleanup?: () => Promise<void>,
 ): Promise<Response> {
-  const iterator = repackStream(chunks, { target: responseStyle })[
-    Symbol.asyncIterator
-  ]();
+  const iterator = delta
+    .repack(chunks, { target: responseStyle })
+    [Symbol.asyncIterator]();
 
   const first = await iterator.next();
   observeTimedExecution({

package/src/telemetry/chat-normalization.ts

@@ -1,10 +1,10 @@
 import {
-  decodeStreamToolDelta,
-  emitChatCompletionsRequest,
-  emitChatCompletionsResponse,
-  type Program,
+  delta,
+  emitProviderRequest,
+  emitProviderResponse,
+  getUsage,
   Opcode,
-  usageObject,
+  type Program,
 } from "@neutrome/lil-engine";
 
 const decoder = new TextDecoder();
@@ -13,7 +13,7 @@ const decoder = new TextDecoder();
 export function normalizeChatRequest(
   program: Program,
 ): Record<string, unknown> {
-  const request = json(emitChatCompletionsRequest(program));
+  const request = json(emitProviderRequest("chat-completions", program));
   delete request.stream;
   return request;
 }
@@ -21,7 +21,7 @@ export function normalizeChatRequest(
 export function normalizeChatResponse(
   program: Program,
 ): Record<string, unknown> {
-  return json(emitChatCompletionsResponse(program));
+  return json(emitProviderResponse("chat-completions", program));
 }
 
 export function normalizeChatStream(
@@ -39,7 +39,7 @@ export function normalizeChatStream(
   let usage: unknown;
 
   for (const chunk of chunks) {
-    const chunkUsage = usageObject(chunk);
+    const chunkUsage = getUsage(chunk);
     if (chunkUsage !== undefined) usage = chunkUsage;
     for (const instruction of chunk.code) {
       if (
@@ -68,13 +68,14 @@ export function normalizeChatStream(
       )
         reasoning.push(instruction.value.value);
       if (instruction.opcode !== Opcode.STREAM_TOOL_DELTA) continue;
-      const delta = decodeStreamToolDelta(instruction);
-      if (!delta) continue;
-      const tool = tools.get(delta.index) ?? { arguments: "" };
-      if (delta.id !== undefined) tool.id = delta.id;
-      if (delta.name !== undefined) tool.name = delta.name;
-      if (delta.arguments !== undefined) tool.arguments += delta.arguments;
-      tools.set(delta.index, tool);
+      const toolCall = delta.decodeToolCall(instruction);
+      if (!toolCall) continue;
+      const tool = tools.get(toolCall.index) ?? { arguments: "" };
+      if (toolCall.id !== undefined) tool.id = toolCall.id;
+      if (toolCall.name !== undefined) tool.name = toolCall.name;
+      if (toolCall.arguments !== undefined)
+        tool.arguments += toolCall.arguments;
+      tools.set(toolCall.index, tool);
     }
   }
 

package/src/telemetry.test.ts

@@ -1,5 +1,5 @@
 import { createExecutionEvent } from "@neutrome/lilsdk";
-import { streamEnd, streamStart, streamTextDelta } from "@neutrome/lil-engine";
+import { delta } from "@neutrome/lil-engine";
 import { describe, expect, it, vi } from "vitest";
 import {
   createRouterTelemetry,
@@ -185,10 +185,10 @@ describe("trace chat normalization", () => {
   it("concatenates stream chunks into a chat completion response", () => {
     expect(
       normalizeChatStream([
-        streamStart(),
-        streamTextDelta("hello "),
-        streamTextDelta("world"),
-        streamEnd("length"),
+        delta.start(),
+        delta.text("hello "),
+        delta.text("world"),
+        delta.end("length"),
       ]),
     ).toEqual({
       object: "chat.completion",