@neutrome/open-ai-router 0.4.1 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutrome/open-ai-router",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
@@ -9,7 +9,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "hono": "^4.12.18",
     "@neutrome/lil-engine": "0.2.1",
-    "@neutrome/lilsdk-ts": "0.2.4"
+    "@neutrome/lilsdk-ts": "0.2.5"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",

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

@@ -167,6 +167,109 @@ describe("router execution runtime", () => {
     expect(providerCalls).toEqual(["slwin"]);
   });
 
+  it("lets transforms invoke and stream nested targets", async () => {
+    const providerCalls: string[] = [];
+    const finalMarkers: Record<string, string> = {};
+    const runtime = createExecutionRuntime({
+      providerInvoker: {
+        async execute(request, ctx) {
+          providerCalls.push(`execute:${ctx.target.model}`);
+          if (ctx.target.model === "final") {
+            for (const instruction of request.code) {
+              if (instruction.opcode === Opcode.SET_META && instruction.value.kind === "key_string") {
+                finalMarkers[instruction.value.key] = instruction.value.value;
+              }
+            }
+          }
+
+          const result = cloneProgram(request);
+          result.code.push({
+            opcode: Opcode.SET_META,
+            value: { kind: "key_string", key: "nested-invoke", value: ctx.target.model },
+          });
+          return result;
+        },
+        async *stream(_request, ctx) {
+          providerCalls.push(`stream:${ctx.target.model}`);
+          yield createProgram({
+            code: [{
+              opcode: Opcode.STREAM_DELTA,
+              value: { kind: "string", value: ctx.target.model },
+            }],
+          });
+        },
+      },
+      transforms: {
+        enrich: {
+          name: "enrich",
+          capabilities: ["write_messages"],
+          async apply(program, ctx) {
+            const invoked = await ctx.invoke(createProgram(), {
+              target: { kind: "provider", provider: "openrouter", model: "nested-exec" },
+            });
+            let invokeModel = "";
+            for (const instruction of invoked.code) {
+              if (
+                instruction.opcode === Opcode.SET_META &&
+                instruction.value.kind === "key_string" &&
+                instruction.value.key === "nested-invoke"
+              ) {
+                invokeModel = instruction.value.value;
+              }
+            }
+
+            let streamModel = "";
+            for await (const chunk of ctx.invokeStream(createProgram(), {
+              target: { kind: "provider", provider: "openrouter", model: "nested-stream" },
+            })) {
+              const instruction = chunk.code[0];
+              if (
+                instruction?.opcode === Opcode.STREAM_DELTA &&
+                instruction.value.kind === "string"
+              ) {
+                streamModel = instruction.value.value;
+              }
+            }
+
+            const result = cloneProgram(program);
+            result.code.push(
+              {
+                opcode: Opcode.SET_META,
+                value: { kind: "key_string", key: "from-invoke", value: invokeModel },
+              },
+              {
+                opcode: Opcode.SET_META,
+                value: { kind: "key_string", key: "from-stream", value: streamModel },
+              },
+            );
+            return result;
+          },
+        },
+      },
+    });
+
+    await runtime.execute(createProgram(), {
+      target: {
+        kind: "provider",
+        provider: "openrouter",
+        model: "final",
+        transforms: ["enrich"],
+      },
+      requestId: "req_transform_nested",
+      executionId: "exec_transform",
+    });
+
+    expect(providerCalls).toEqual([
+      "execute:nested-exec",
+      "stream:nested-stream",
+      "execute:final",
+    ]);
+    expect(finalMarkers).toMatchObject({
+      "from-invoke": "nested-exec",
+      "from-stream": "nested-stream",
+    });
+  });
+
   it("streams through the provider invoker", async () => {
     const runtime = createExecutionRuntime({
       providerInvoker: {

package/src/router/execution-runtime.ts

@@ -64,7 +64,7 @@ export function createExecutionRuntime(options: ExecutionRuntimeOptions = {}): E
       emitSuccess: true,
     });
 
-    const transformed = applyTransforms(
+    const transformed = await applyTransforms(
       request,
       target,
       requestId,
@@ -216,7 +216,7 @@ export function createExecutionRuntime(options: ExecutionRuntimeOptions = {}): E
       emitSuccess: true,
     });
 
-    const transformed = applyTransforms(
+    const transformed = await applyTransforms(
       request,
       target,
       requestId,
@@ -377,7 +377,7 @@ export function createExecutionRuntime(options: ExecutionRuntimeOptions = {}): E
     };
   }
 
-  function applyTransforms(
+  async function applyTransforms(
     program: ReturnType<typeof cloneProgram>,
     target: ExecutionTarget,
     requestId: string,
@@ -387,6 +387,13 @@ export function createExecutionRuntime(options: ExecutionRuntimeOptions = {}): E
     depth: number,
   ) {
     let current = cloneProgram(program);
+    const transformContext = createExecutionContext(
+      requestId,
+      executionId,
+      parentExecutionId,
+      signal,
+      depth,
+    );
     for (const transformName of target.transforms ?? []) {
       const transform = transforms.get(transformName);
       if (!transform) {
@@ -400,7 +407,7 @@ export function createExecutionRuntime(options: ExecutionRuntimeOptions = {}): E
         );
       }
       try {
-        current = transform.apply(current, { observe, signal });
+        current = await transform.apply(current, transformContext);
       } catch (error) {
         throw new ExecutionError(
           "transform",