@neutrome/open-ai-router 0.5.8 → 0.6.0

package/README.md

@@ -1,7 +1,7 @@
 # `@neutrome/open-ai-router`
 
 Deployable router app and reusable router/runtime library built on
-`@neutrome/lil-engine` for protocol conversion and `@neutrome/lilsdk-ts` for
+`@neutrome/lil-engine` for protocol conversion and `@neutrome/lilsdk` for
 executor/tool contracts.
 
 ```ts
@@ -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-ts`.
+- Executor contracts and `connectTools` come from `@neutrome/lilsdk`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutrome/open-ai-router",
-  "version": "0.5.8",
+  "version": "0.6.0",
   "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.3.4",
-    "@neutrome/lilsdk-ts": "0.3.4"
+    "@neutrome/lil-engine": "0.4.0",
+    "@neutrome/lilsdk": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",

package/src/app/factory.test.ts

@@ -17,7 +17,7 @@ const config: RouterConfig = {
     default: {
       exports: ["*"],
       models: {
-        "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
+        "gpt-4o": { target: { provider: "openrouter", model: "gpt-4o" } },
       },
     },
   },

package/src/app/factory.ts

@@ -257,6 +257,7 @@ export function createRouterApp(options: RouterAppOptions) {
     }
 
     const ctx: RequestContext = { request, env };
+    const cache = options.cache?.(env);
 
     try {
       const handlerStartedMs = Date.now();
@@ -264,6 +265,7 @@ export function createRouterApp(options: RouterAppOptions) {
         runtime,
         ctx,
         program,
+        ...(cache ? { cache } : {}),
         executorImplementations: options.executorImplementations,
         ...(options.transforms ? { transforms: options.transforms } : {}),
         observe,

package/src/app/types.ts

@@ -1,4 +1,4 @@
-import type { Executor, ProgramTransform } from "@neutrome/lilsdk-ts";
+import type { Cache, Executor, ProgramTransform } from "@neutrome/lilsdk";
 import type {
   AuthPrincipal,
   RuntimeAuthenticator,
@@ -27,6 +27,7 @@ export type RouterAppOptions = {
   config: RouterConfig;
   executorImplementations: Readonly<Record<string, Executor>>;
   transforms?: Readonly<Record<string, ProgramTransform>>;
+  cache?(env: Record<string, unknown>): Cache | undefined;
   auth: RouterAppAuth;
   hooks?: RouterAppHooks;
   fetchImpl?: typeof fetch;

package/src/index.ts

@@ -55,6 +55,7 @@ export type {
   ModelNamespaceConfig,
   ModelNamespaceRuntime,
   ModelRouteConfig,
+  ModelRouteTarget,
   ModelRouteRuntime,
   ProgramTransform,
   ProviderApiStyle,

package/src/router/audit.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEvent } from "@neutrome/lilsdk-ts";
+import type { ExecutionEvent } from "@neutrome/lilsdk";
 
 export function createInMemoryAuditSink(): {
   events: ExecutionEvent[];

package/src/router/config.ts

@@ -28,20 +28,21 @@ export type ProviderTargetConfig = {
   auth?: ProviderAuthDriverConfig[];
 };
 
-export type ModelRouteConfig =
+export type ModelRouteTarget =
   | {
-      executorId: string;
-      alias?: string;
-      transforms?: string[];
-      mcps?: string[];
+      executor: string;
     }
   | {
       provider: string;
       model: string;
-      transforms?: string[];
-      mcps?: string[];
     };
 
+export type ModelRouteConfig = {
+  target: ModelRouteTarget;
+  transforms?: string[];
+  mcps?: string[];
+};
+
 export type ModelNamespaceConfig = {
   exports?: string[];
   models: Record<string, ModelRouteConfig>;

package/src/router/execute.test.ts

@@ -1,4 +1,4 @@
-import { appendAssistantMessage } from "@neutrome/lilsdk-ts/synthetic";
+import { appendAssistantMessage } from "@neutrome/lilsdk/synthetic";
 import { describe, expect, it, vi } from "vitest";
 import type { RequestContext } from "../upstream-auth/types.ts";
 import { handleChatCompletions } from "./execute.ts";
@@ -27,7 +27,7 @@ describe("router execution", () => {
           default: {
             exports: ["*"],
             models: {
-              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
+              "gpt-4o": { target: { provider: "openrouter", model: "gpt-4o" } },
             },
           },
         },
@@ -146,8 +146,7 @@ describe("router execution", () => {
             exports: ["*"],
             models: {
               "gpt-4o": {
-                provider: "openrouter",
-                model: "gpt-4o",
+                target: { provider: "openrouter", model: "gpt-4o" },
                 mcps: ["crm"],
               },
             },
@@ -283,7 +282,7 @@ describe("router execution", () => {
           default: {
             exports: ["*"],
             models: {
-              "gpt-5": { provider: "openai", model: "gpt-5" },
+              "gpt-5": { target: { provider: "openai", model: "gpt-5" } },
             },
           },
         },
@@ -363,8 +362,7 @@ describe("router execution", () => {
             exports: ["*"],
             models: {
               "claude-sonnet-4": {
-                provider: "anthropic",
-                model: "claude-sonnet-4",
+                target: { provider: "anthropic", model: "claude-sonnet-4" },
               },
             },
           },
@@ -445,8 +443,7 @@ describe("router execution", () => {
             exports: ["*"],
             models: {
               "gemini-2.5-flash": {
-                provider: "google",
-                model: "gemini-2.5-flash",
+                target: { provider: "google", model: "gemini-2.5-flash" },
               },
             },
           },
@@ -519,7 +516,7 @@ describe("router execution", () => {
           enei: {
             exports: ["enei-*"],
             models: {
-              "enei-1": { executorId: "enei-1" },
+              "enei-1": { target: { executor: "enei-1" } },
             },
           },
         },
@@ -583,7 +580,7 @@ describe("router execution", () => {
           default: {
             exports: ["*"],
             models: {
-              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
+              "gpt-4o": { target: { provider: "openrouter", model: "gpt-4o" } },
             },
           },
         },
@@ -661,7 +658,7 @@ describe("router execution", () => {
           default: {
             exports: ["*"],
             models: {
-              "gpt-4o": { provider: "openrouter", model: "gpt-4o" },
+              "gpt-4o": { target: { provider: "openrouter", model: "gpt-4o" } },
             },
           },
         },
@@ -723,8 +720,7 @@ describe("router execution", () => {
             exports: ["*"],
             models: {
               "claude-sonnet-4": {
-                provider: "anthropic",
-                model: "claude-sonnet-4",
+                target: { provider: "anthropic", model: "claude-sonnet-4" },
               },
             },
           },

package/src/router/execute.ts

@@ -66,7 +66,11 @@ const DEFAULT_UPSTREAM_TIMEOUT_MS = 120_000;
 
 export type RouterExecutionOptions = Pick<
   ExecutionRuntimeOptions,
-  "observe" | "requestIdFactory" | "executionIdFactory" | "resolveExecutor"
+  | "cache"
+  | "observe"
+  | "requestIdFactory"
+  | "executionIdFactory"
+  | "resolveExecutor"
 > & {
   executorImplementations?: Readonly<Record<string, Executor>>;
   transforms?: Readonly<Record<string, ProgramTransform>>;
@@ -122,6 +126,9 @@ export function createRouterExecutionRuntime(
   if (options.executorImplementations) {
     runtimeOptions.executorImplementations = options.executorImplementations;
   }
+  if (options.cache) {
+    runtimeOptions.cache = options.cache;
+  }
   if (options.transforms) {
     runtimeOptions.transforms = options.transforms;
   }

package/src/router/execution-events.ts

@@ -1,5 +1,5 @@
-import { createExecutionEvent } from "@neutrome/lilsdk-ts";
-import type { ExecutionEvent } from "@neutrome/lilsdk-ts";
+import { createExecutionEvent } from "@neutrome/lilsdk";
+import type { ExecutionEvent } from "@neutrome/lilsdk";
 
 type TimedExecutionInput = {
   observe?: ((event: ExecutionEvent) => void) | undefined;

package/src/router/execution-invocation.ts

@@ -1,5 +1,5 @@
 import type { Program, ValidationMode } from "@neutrome/lil-engine";
-import type { ExecutorContext } from "@neutrome/lilsdk-ts";
+import type { ExecutorContext } from "@neutrome/lilsdk";
 import {
   finishInvocation,
   observeExecutionError,

package/src/router/execution-observation.ts

@@ -1,7 +1,7 @@
 import { validateProgram } from "@neutrome/lil-engine";
 import type { Program, ValidationMode } from "@neutrome/lil-engine";
-import { createExecutionEvent } from "@neutrome/lilsdk-ts";
-import type { ExecutionEvent } from "@neutrome/lilsdk-ts";
+import { createExecutionEvent } from "@neutrome/lilsdk";
+import type { ExecutionEvent } from "@neutrome/lilsdk";
 import { ExecutionError } from "./errors.ts";
 import { executionTargetAuditRef, executionTargetId } from "./targets.ts";
 import type { ExecutionTarget } from "./execution-types.ts";

package/src/router/execution-runtime.test.ts

@@ -1,5 +1,11 @@
 import { describe, expect, it } from "vitest";
-import { cloneProgram, createProgram, Opcode } from "@neutrome/lil-engine";
+import {
+  cloneProgram,
+  createProgram,
+  getModel,
+  Opcode,
+  type Program,
+} from "@neutrome/lil-engine";
 import {
   createExecutionRuntime,
   createInMemoryAuditSink,
@@ -7,10 +13,62 @@ import {
   executionTargetAuditRef,
   executionTargetId,
 } from "./index.ts";
-import { createExecutionEvent as createAuditEvent } from "@neutrome/lilsdk-ts";
-import { observeExecutionStream } from "@neutrome/lilsdk-ts/stream";
+import {
+  createExecutionEvent as createAuditEvent,
+  type ExecutorContext,
+} from "@neutrome/lilsdk";
+import { observeExecutionStream } from "@neutrome/lilsdk/stream";
 
 describe("router execution runtime", () => {
+  it("shares one cache with transforms and executors", async () => {
+    const values = new Map<string, string>();
+    const cache = {
+      async get(key: string) {
+        return values.get(key) ?? null;
+      },
+      async put(key: string, value: string) {
+        values.set(key, value);
+      },
+      async delete(key: string) {
+        values.delete(key);
+      },
+    };
+    const runtime = createExecutionRuntime({
+      cache,
+      transforms: {
+        cached: {
+          name: "cached",
+          capabilities: [],
+          async apply(program, ctx) {
+            await ctx.cache.put("shared", "from-transform");
+            return program;
+          },
+        },
+      },
+      executorImplementations: {
+        cached: {
+          async execute(program, ctx) {
+            expect(ctx.cache).toBe(cache);
+            expect(await ctx.cache.get("shared")).toBe("from-transform");
+            return program;
+          },
+          async *stream() {
+            return;
+          },
+        },
+      },
+    });
+
+    await runtime.execute(createProgram(), {
+      target: {
+        kind: "executor",
+        executorId: "cached",
+        alias: "cached",
+        transforms: ["cached"],
+      },
+    });
+  });
+
   it("creates audit events with a stable envelope", () => {
     const event = createAuditEvent({
       kind: "executor.started",
@@ -66,33 +124,31 @@ describe("router execution runtime", () => {
 
   it("invokes nested executors without router re-entry and preserves request identity", async () => {
     const sink = createInMemoryAuditSink();
+    const childExecutor = {
+      async execute(request: Program) {
+        const result = cloneProgram(request);
+        result.code.push({
+          opcode: Opcode.RESP_DONE,
+          value: { kind: "string", value: "stop" },
+        });
+        return result;
+      },
+      async *stream() {
+        return;
+      },
+    };
     const runtime = createExecutionRuntime({
       observe: sink.observe,
       executorImplementations: {
         parent: {
           async execute(request, ctx) {
-            const childResult = await ctx.invoke(request, {
-              target: { kind: "executor", executorId: "child", alias: "child" },
-            });
+            const childResult = await ctx.invoke(childExecutor, request);
             return childResult;
           },
           async *stream() {
             return;
           },
         },
-        child: {
-          async execute(request) {
-            const result = cloneProgram(request);
-            result.code.push({
-              opcode: Opcode.RESP_DONE,
-              value: { kind: "string", value: "stop" },
-            });
-            return result;
-          },
-          async *stream() {
-            return;
-          },
-        },
       },
     });
 
@@ -119,12 +175,9 @@ describe("router execution runtime", () => {
     const started = sink.events.filter(
       (event) => event.kind === "executor.started",
     );
-    expect(started).toHaveLength(2);
+    expect(started).toHaveLength(1);
     expect(started[0]?.requestId).toBe("req_nested");
-    expect(started[1]?.requestId).toBe("req_nested");
-    expect(started[1]?.parentExecutionId).toBe("exec_root");
     expect(started[0]?.data?.depth).toBe(0);
-    expect(started[1]?.data?.depth).toBe(1);
   });
 
   it("applies target transforms before provider invocation", async () => {
@@ -181,6 +234,9 @@ describe("router execution runtime", () => {
     const providerCalls: string[] = [];
     const finalMarkers: Record<string, string> = {};
     const runtime = createExecutionRuntime({
+      resolveTarget(request) {
+        return { kind: "provider", model: getModel(request) ?? "" };
+      },
       providerInvoker: {
         async execute(request, ctx) {
           providerCalls.push(`execute:${ctx.target.model}`);
@@ -223,13 +279,10 @@ describe("router execution runtime", () => {
           name: "enrich",
           capabilities: ["write_messages"],
           async apply(program, ctx) {
-            const invoked = await ctx.invoke(createProgram(), {
-              target: {
-                kind: "provider",
-                provider: "openrouter",
-                model: "nested-exec",
-              },
-            });
+            const invoked = await ctx.invoke(
+              "openrouter/nested-exec",
+              createProgram(),
+            );
             let invokeModel = "";
             for (const instruction of invoked.code) {
               if (
@@ -242,13 +295,10 @@ describe("router execution runtime", () => {
             }
 
             let streamModel = "";
-            for await (const chunk of ctx.invokeStream(createProgram(), {
-              target: {
-                kind: "provider",
-                provider: "openrouter",
-                model: "nested-stream",
-              },
-            })) {
+            for await (const chunk of ctx.invokeStream(
+              "openrouter/nested-stream",
+              createProgram(),
+            )) {
               const instruction = chunk.code[0];
               if (
                 instruction?.opcode === Opcode.STREAM_DELTA &&
@@ -295,13 +345,13 @@ describe("router execution runtime", () => {
     });
 
     expect(providerCalls).toEqual([
-      "execute:nested-exec",
-      "stream:nested-stream",
+      "execute:openrouter/nested-exec",
+      "stream:openrouter/nested-stream",
       "execute:final",
     ]);
     expect(finalMarkers).toMatchObject({
-      "from-invoke": "nested-exec",
-      "from-stream": "nested-stream",
+      "from-invoke": "openrouter/nested-exec",
+      "from-stream": "openrouter/nested-stream",
     });
   });
 
@@ -341,33 +391,29 @@ describe("router execution runtime", () => {
 
   it("enforces recursion limits with typed errors", async () => {
     const sink = createInMemoryAuditSink();
+    const leaf = {
+      async execute(request: Program) {
+        return request;
+      },
+      async *stream() {
+        return;
+      },
+    };
+    const child = {
+      async execute(request: Program, ctx: ExecutorContext) {
+        return ctx.invoke(leaf, request);
+      },
+      async *stream() {
+        return;
+      },
+    };
     const runtime = createExecutionRuntime({
       observe: sink.observe,
       maxDepth: 1,
       executorImplementations: {
         parent: {
           async execute(request, ctx) {
-            return ctx.invoke(request, {
-              target: { kind: "executor", executorId: "child", alias: "child" },
-            });
-          },
-          async *stream() {
-            return;
-          },
-        },
-        child: {
-          async execute(request, ctx) {
-            return ctx.invoke(request, {
-              target: { kind: "executor", executorId: "leaf", alias: "leaf" },
-            });
-          },
-          async *stream() {
-            return;
-          },
-        },
-        leaf: {
-          async execute(request) {
-            return request;
+            return ctx.invoke(child, request);
           },
           async *stream() {
             return;

package/src/router/execution-runtime.ts

@@ -1,6 +1,6 @@
-import { cloneProgram } from "@neutrome/lil-engine";
+import { cloneProgram, setModel } from "@neutrome/lil-engine";
 import type { Program, ValidationMode } from "@neutrome/lil-engine";
-import type { ExecutorContext } from "@neutrome/lilsdk-ts";
+import type { ExecutorContext } from "@neutrome/lilsdk";
 import { validateProgramOrThrow as validateObservedProgram } from "./execution-observation.ts";
 import {
   ensureActiveSignal as assertActiveSignal,
@@ -24,6 +24,11 @@ import type {
 } from "./execution-types.ts";
 
 const DEFAULT_MAX_DEPTH = 8;
+const unavailableCache: ExecutorContext["cache"] = {
+  get: () => Promise.reject(cacheUnavailable()),
+  put: () => Promise.reject(cacheUnavailable()),
+  delete: () => Promise.reject(cacheUnavailable()),
+};
 
 export function createExecutionRuntime(
   options: ExecutionRuntimeOptions = {},
@@ -198,28 +203,48 @@ export function createExecutionRuntime(
     depth: number,
   ): ExecutorContext {
     return {
+      cache: options.cache ?? unavailableCache,
       requestId,
       executionId,
       ...(parentExecutionId ? { parentExecutionId } : {}),
-      async invoke(request, invokeOptions = {}) {
+      async invoke(executor, request) {
+        if (typeof executor !== "string") {
+          throwIfDepthExceeded(depth + 1, maxDepth);
+          return executor.execute(
+            cloneProgram(request),
+            createExecutionContext(
+              requestId,
+              executionIdFactory(),
+              executionId,
+              signal,
+              depth + 1,
+            ),
+          );
+        }
         return executeTarget(
-          cloneProgram(request),
-          {
-            ...invokeOptions,
-            requestId,
-            parentExecutionId: executionId,
-          },
+          setModel(cloneProgram(request), executor),
+          { requestId, parentExecutionId: executionId },
           depth + 1,
         );
       },
-      async *invokeStream(request, invokeOptions = {}) {
+      async *invokeStream(executor, request) {
+        if (typeof executor !== "string") {
+          throwIfDepthExceeded(depth + 1, maxDepth);
+          yield* executor.stream(
+            cloneProgram(request),
+            createExecutionContext(
+              requestId,
+              executionIdFactory(),
+              executionId,
+              signal,
+              depth + 1,
+            ),
+          );
+          return;
+        }
         yield* streamTarget(
-          cloneProgram(request),
-          {
-            ...invokeOptions,
-            requestId,
-            parentExecutionId: executionId,
-          },
+          setModel(cloneProgram(request), executor),
+          { requestId, parentExecutionId: executionId },
           depth + 1,
         );
       },
@@ -279,3 +304,7 @@ export function createExecutionRuntime(
     });
   }
 }
+
+function cacheUnavailable(): Error {
+  return new Error("Runtime cache is not configured");
+}

package/src/router/execution-transforms.ts

@@ -1,7 +1,7 @@
 import { cloneProgram } from "@neutrome/lil-engine";
 import type { Program } from "@neutrome/lil-engine";
-import { createExecutionEvent } from "@neutrome/lilsdk-ts";
-import type { ExecutorContext } from "@neutrome/lilsdk-ts";
+import { createExecutionEvent } from "@neutrome/lilsdk";
+import type { ExecutorContext } from "@neutrome/lilsdk";
 import { ExecutionError } from "./errors.ts";
 import { executionTargetAuditRef, executionTargetId } from "./targets.ts";
 import type { ExecutionTarget, ProgramTransform } from "./execution-types.ts";

package/src/router/execution-types.ts

@@ -1,17 +1,37 @@
 import type { Program, ValidationIssue } from "@neutrome/lil-engine";
 import type {
-  ExecutionTarget,
+  Cache,
   ExecutionEvent,
   Executor,
-  InvokeOptions,
   ProgramTransform,
-} from "@neutrome/lilsdk-ts";
+} from "@neutrome/lilsdk";
 import type {
   ExecutionErrorDetails,
   ExecutionErrorKind,
   ExecutionErrorStage,
 } from "./errors.ts";
 
+export type ExecutionTarget =
+  | {
+      kind: "provider";
+      provider?: string;
+      model: string;
+      transforms?: string[];
+    }
+  | {
+      kind: "executor";
+      executorId: string;
+      alias: string;
+      transforms?: string[];
+    };
+
+export type InvokeOptions = {
+  target?: ExecutionTarget;
+  requestId?: string;
+  executionId?: string;
+  parentExecutionId?: string;
+};
+
 export type ProviderInvocationContext = {
   requestId: string;
   executionId: string;
@@ -39,6 +59,7 @@ export type ResolveExecutor = (
 ) => Executor | Promise<Executor | null> | null;
 
 export type ExecutionRuntimeOptions = {
+  cache?: Cache;
   executorImplementations?: Readonly<Record<string, Executor>>;
   resolveExecutor?: ResolveExecutor;
   transforms?: Readonly<Record<string, ProgramTransform>>;
@@ -61,9 +82,7 @@ export type {
   ExecutionErrorDetails,
   ExecutionErrorKind,
   ExecutionErrorStage,
-  ExecutionTarget,
   ExecutionEvent,
   Executor,
-  InvokeOptions,
   ProgramTransform,
 };

package/src/router/index.ts

@@ -29,6 +29,7 @@ export {
 export type {
   ModelNamespaceConfig,
   ModelRouteConfig,
+  ModelRouteTarget,
   ProviderApiStyle,
   ProviderTargetConfig,
   RemoteMcpServerConfig,

package/src/router/mcp.ts

@@ -1,7 +1,7 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import type { ExecutorContext, Tool } from "@neutrome/lilsdk-ts";
+import type { ExecutorContext, Tool } from "@neutrome/lilsdk";
 import type { RemoteMcpServerRuntime, RouterRuntime } from "./runtime.ts";
 import { observeTimedExecution } from "./execution-events.ts";
 

package/src/router/provider-telemetry.ts

@@ -1,5 +1,5 @@
 import { usageObject, type Program } from "@neutrome/lil-engine";
-import { createExecutionEvent } from "@neutrome/lilsdk-ts";
+import { createExecutionEvent } from "@neutrome/lilsdk";
 import { z } from "zod";
 import type { ProviderInvocationContext } from "./execution-types.ts";
 

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

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

package/src/router/request-target.ts

@@ -18,9 +18,7 @@ export function resolveModelNamespaceExecutor(
           "Request is missing model for namespace executor resolution",
           { stage: "target_resolution" },
         );
-      return ctx.invoke(request, {
-        target: resolveInvocationTarget(runtime, `${name}/${model}`).target,
-      });
+      return ctx.invoke(`${name}/${model}`, request);
     },
     async *stream(request, ctx) {
       const model = getModel(request);
@@ -30,9 +28,7 @@ export function resolveModelNamespaceExecutor(
           "Request is missing model for namespace executor resolution",
           { stage: "target_resolution" },
         );
-      yield* ctx.invokeStream(request, {
-        target: resolveInvocationTarget(runtime, `${name}/${model}`).target,
-      });
+      yield* ctx.invokeStream(`${name}/${model}`, request);
     },
   };
 }

package/src/router/resolve.test.ts

@@ -22,9 +22,9 @@ describe("router resolution", () => {
           enei: {
             exports: ["enei-*"],
             models: {
-              "enei-1": { executorId: "enei-1" },
+              "enei-1": { target: { executor: "enei-1" } },
               "enei-1-pro": {
-                executorId: "enei-1-pro",
+                target: { executor: "enei-1-pro" },
                 transforms: ["reasoning:high"],
               },
             },
@@ -106,8 +106,10 @@ describe("router resolution", () => {
             exports: ["enei-*"],
             models: {
               "enei-1": {
-                provider: "openrouter",
-                model: "openai/gpt-4.1-mini",
+                target: {
+                  provider: "openrouter",
+                  model: "openai/gpt-4.1-mini",
+                },
               },
             },
           },
@@ -140,8 +142,8 @@ describe("router resolution", () => {
           enei: {
             exports: ["enei-*"],
             models: {
-              "enei-1": { executorId: "enei-1" },
-              "enei-1-pro": { executorId: "enei-1-pro" },
+              "enei-1": { target: { executor: "enei-1" } },
+              "enei-1-pro": { target: { executor: "enei-1-pro" } },
             },
           },
         },
@@ -168,7 +170,9 @@ describe("router resolution", () => {
           default: {
             exports: ["*"],
             models: {
-              "gpt-4o": { provider: "openrouter", model: "openai/gpt-4o" },
+              "gpt-4o": {
+                target: { provider: "openrouter", model: "openai/gpt-4o" },
+              },
             },
           },
         },

package/src/router/resolve.ts

@@ -1,4 +1,4 @@
-import type { ExecutionTarget } from "@neutrome/lilsdk-ts";
+import type { ExecutionTarget } from "./execution-types.ts";
 import {
   parseModelSyntax,
   type ModelSuffixSpec,

package/src/router/runtime.test.ts

@@ -25,7 +25,9 @@ describe("router runtime configuration", () => {
           providers: { upstream: provider },
           modelNamespaces: {
             default: {
-              models: { chat: { provider: "missing", model: "chat" } },
+              models: {
+                chat: { target: { provider: "missing", model: "chat" } },
+              },
             },
           },
         },

package/src/router/runtime.ts

@@ -1,4 +1,4 @@
-import type { ExecutionTarget } from "@neutrome/lilsdk-ts";
+import type { ExecutionTarget } from "./execution-types.ts";
 import { createExportsMatcher } from "../util/glob.ts";
 import type {
   ModelNamespaceConfig,
@@ -101,9 +101,12 @@ function validateRouterConfig(config: RouterConfig): void {
       throw new Error(`Model namespace ${namespace} has no routes`);
     }
     for (const [alias, route] of Object.entries(namespaceConfig.models)) {
-      if ("provider" in route && !config.providers[route.provider]) {
+      if (
+        "provider" in route.target &&
+        !config.providers[route.target.provider]
+      ) {
         throw new Error(
-          `Model route ${namespace}/${alias} references unknown provider ${route.provider}`,
+          `Model route ${namespace}/${alias} references unknown provider ${route.target.provider}`,
         );
       }
       for (const mcp of route.mcps ?? []) {
@@ -178,15 +181,15 @@ function buildModelRoute(
   alias: string,
   route: ModelRouteConfig,
 ): ModelRouteRuntime {
-  if ("provider" in route) {
+  if ("provider" in route.target) {
     return {
       requestedAlias: alias,
       transforms: route.transforms ?? [],
       mcps: route.mcps ?? [],
       target: {
         kind: "provider",
-        provider: route.provider,
-        model: route.model,
+        provider: route.target.provider,
+        model: route.target.model,
         transforms: route.transforms ?? [],
       },
     };
@@ -198,8 +201,8 @@ function buildModelRoute(
     mcps: route.mcps ?? [],
     target: {
       kind: "executor",
-      executorId: route.executorId,
-      alias: route.alias ?? alias,
+      executorId: route.target.executor,
+      alias,
       transforms: route.transforms ?? [],
     },
   };

package/src/telemetry/router.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEvent } from "@neutrome/lilsdk-ts";
+import type { ExecutionEvent } from "@neutrome/lilsdk";
 import { z } from "zod";
 import { createPosthogTelemetryDrivers } from "./posthog.ts";
 import type {

package/src/telemetry.test.ts

@@ -1,4 +1,4 @@
-import { createExecutionEvent } from "@neutrome/lilsdk-ts";
+import { createExecutionEvent } from "@neutrome/lilsdk";
 import { describe, expect, it, vi } from "vitest";
 import {
   createRouterTelemetry,

package/src/trace-labels.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEvent as AuditEvent } from "@neutrome/lilsdk-ts";
+import type { ExecutionEvent as AuditEvent } from "@neutrome/lilsdk";
 
 export function traceTimingKind(event: AuditEvent): string {
   if (event.kind.startsWith("upstream_auth.")) return "upstream_auth";