@neutrome/open-ai-router 0.4.1 → 0.5.0

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

@@ -1,17 +1,13 @@
 import { describe, expect, it } from "vitest";
+import { cloneProgram, createProgram, Opcode } from "@neutrome/lil-engine";
 import {
-  cloneProgram,
-  createProgram,
-  Opcode,
-} from "@neutrome/lil-engine";
-import {
-  createAuditEvent,
   createExecutionRuntime,
   createInMemoryAuditSink,
   ExecutionError,
   executionTargetAuditRef,
   executionTargetId,
 } from "./index.ts";
+import { createExecutionEvent as createAuditEvent } from "@neutrome/lilsdk-ts";
 import { observeExecutionStream } from "@neutrome/lilsdk-ts/stream";
 
 describe("router execution runtime", () => {
@@ -33,12 +29,14 @@ describe("router execution runtime", () => {
 
   it("collects audit events in memory", () => {
     const sink = createInMemoryAuditSink();
-    sink.observe(createAuditEvent({
-      kind: "program.validated",
-      requestId: "req_2",
-      executionId: "exec_2",
-      data: { issues: 0 },
-    }));
+    sink.observe(
+      createAuditEvent({
+        kind: "program.validated",
+        requestId: "req_2",
+        executionId: "exec_2",
+        data: { issues: 0 },
+      }),
+    );
 
     expect(sink.events).toHaveLength(1);
     expect(sink.events[0]?.kind).toBe("program.validated");
@@ -46,17 +44,21 @@ describe("router execution runtime", () => {
   });
 
   it("normalizes execution target identifiers", () => {
-    expect(executionTargetId({
-      kind: "provider",
-      provider: "openrouter",
-      model: "google/gemma-4-31b-it",
-    })).toBe("openrouter/google/gemma-4-31b-it");
+    expect(
+      executionTargetId({
+        kind: "provider",
+        provider: "openrouter",
+        model: "google/gemma-4-31b-it",
+      }),
+    ).toBe("openrouter/google/gemma-4-31b-it");
 
-    expect(executionTargetAuditRef({
-      kind: "executor",
-      executorId: "enei",
-      alias: "enei-1",
-    })).toEqual({
+    expect(
+      executionTargetAuditRef({
+        kind: "executor",
+        executorId: "enei",
+        alias: "enei-1",
+      }),
+    ).toEqual({
       kind: "executor",
       id: "enei/enei-1",
     });
@@ -96,7 +98,10 @@ describe("router execution runtime", () => {
 
     const request = createProgram({
       code: [
-        { opcode: Opcode.SET_MODEL, value: { kind: "string", value: "enei-1" } },
+        {
+          opcode: Opcode.SET_MODEL,
+          value: { kind: "string", value: "enei-1" },
+        },
       ],
     });
 
@@ -111,7 +116,9 @@ describe("router execution runtime", () => {
       value: { kind: "string", value: "stop" },
     });
 
-    const started = sink.events.filter((event) => event.kind === "executor.started");
+    const started = sink.events.filter(
+      (event) => event.kind === "executor.started",
+    );
     expect(started).toHaveLength(2);
     expect(started[0]?.requestId).toBe("req_nested");
     expect(started[1]?.requestId).toBe("req_nested");
@@ -125,13 +132,16 @@ describe("router execution runtime", () => {
     const runtime = createExecutionRuntime({
       providerInvoker: {
         async execute(request) {
-          const marker = request.code.find((instruction) =>
-            instruction.opcode === Opcode.SET_META &&
-            instruction.value.kind === "key_string" &&
-            instruction.value.key === "transform",
+          const marker = request.code.find(
+            (instruction) =>
+              instruction.opcode === Opcode.SET_META &&
+              instruction.value.kind === "key_string" &&
+              instruction.value.key === "transform",
           );
           providerCalls.push(
-            marker?.value.kind === "key_string" ? marker.value.value : "missing",
+            marker?.value.kind === "key_string"
+              ? marker.value.value
+              : "missing",
           );
           return cloneProgram(request);
         },
@@ -167,6 +177,134 @@ 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: {
@@ -177,7 +315,10 @@ describe("router execution runtime", () => {
           yield cloneProgram(request);
           yield createProgram({
             code: [
-              { opcode: Opcode.STREAM_DELTA, value: { kind: "string", value: "hello" } },
+              {
+                opcode: Opcode.STREAM_DELTA,
+                value: { kind: "string", value: "hello" },
+              },
             ],
           });
         },
@@ -235,14 +376,18 @@ describe("router execution runtime", () => {
       },
     });
 
-    await expect(runtime.execute(createProgram(), {
-      target: { kind: "executor", executorId: "parent", alias: "parent" },
-    })).rejects.toMatchObject({
+    await expect(
+      runtime.execute(createProgram(), {
+        target: { kind: "executor", executorId: "parent", alias: "parent" },
+      }),
+    ).rejects.toMatchObject({
       kind: "recursion_limit",
       stage: "target_resolution",
     } satisfies Partial<ExecutionError>);
 
-    const failed = sink.events.find((event) => event.kind === "execution.failed");
+    const failed = sink.events.find(
+      (event) => event.kind === "execution.failed",
+    );
     expect(failed?.errorKind).toBe("recursion_limit");
     expect(failed?.data?.depth).toBe(2);
   });
@@ -255,28 +400,40 @@ describe("router execution runtime", () => {
         },
         async *stream() {
           yield createProgram({
-            code: [
-              { opcode: Opcode.MSG_START, value: { kind: "none" } },
-            ],
+            code: [{ opcode: Opcode.MSG_START, value: { kind: "none" } }],
           });
         },
       },
     });
 
-    await expect(runtime.execute(createProgram({
-      code: [
-        { opcode: Opcode.EXT_DATA, value: { kind: "key_json", key: "provider", value: new Uint8Array([123, 125]) } },
-      ],
-    }), {
-      target: { kind: "provider", provider: "openrouter", model: "gpt-4o" },
-    })).rejects.toMatchObject({
+    await expect(
+      runtime.execute(
+        createProgram({
+          code: [
+            {
+              opcode: Opcode.EXT_DATA,
+              value: {
+                kind: "key_json",
+                key: "provider",
+                value: new Uint8Array([123, 125]),
+              },
+            },
+          ],
+        }),
+        {
+          target: { kind: "provider", provider: "openrouter", model: "gpt-4o" },
+        },
+      ),
+    ).rejects.toMatchObject({
       kind: "validation",
       stage: "request",
     } satisfies Partial<ExecutionError>);
 
-    const iterator = runtime.stream(createProgram(), {
-      target: { kind: "provider", provider: "openrouter", model: "gpt-4o" },
-    })[Symbol.asyncIterator]();
+    const iterator = runtime
+      .stream(createProgram(), {
+        target: { kind: "provider", provider: "openrouter", model: "gpt-4o" },
+      })
+      [Symbol.asyncIterator]();
     await expect(iterator.next()).rejects.toMatchObject({
       kind: "validation",
       stage: "stream_chunk",
@@ -284,19 +441,30 @@ describe("router execution runtime", () => {
   });
 
   it("observes text-first streams and tool-call streams", async () => {
-    const textObserved = await observeExecutionStream((async function* () {
-      yield createProgram({
-        code: [
-          { opcode: Opcode.STREAM_DELTA, value: { kind: "string", value: "hello" } },
-        ],
-      });
-      yield createProgram({
-        code: [
-          { opcode: Opcode.STREAM_DELTA, value: { kind: "string", value: " world" } },
-          { opcode: Opcode.RESP_DONE, value: { kind: "string", value: "stop" } },
-        ],
-      });
-    })());
+    const textObserved = await observeExecutionStream(
+      (async function* () {
+        yield createProgram({
+          code: [
+            {
+              opcode: Opcode.STREAM_DELTA,
+              value: { kind: "string", value: "hello" },
+            },
+          ],
+        });
+        yield createProgram({
+          code: [
+            {
+              opcode: Opcode.STREAM_DELTA,
+              value: { kind: "string", value: " world" },
+            },
+            {
+              opcode: Opcode.RESP_DONE,
+              value: { kind: "string", value: "stop" },
+            },
+          ],
+        });
+      })(),
+    );
 
     expect(textObserved).toEqual({
       mode: "text",
@@ -304,18 +472,26 @@ describe("router execution runtime", () => {
       emittedText: true,
     });
 
-    const toolObserved = await observeExecutionStream((async function* () {
-      yield createProgram({
-        code: [
-          { opcode: Opcode.STREAM_TOOL_DELTA, value: { kind: "json", value: new Uint8Array([123, 125]) } },
-        ],
-      });
-      yield createProgram({
-        code: [
-          { opcode: Opcode.RESP_DONE, value: { kind: "string", value: "tool_calls" } },
-        ],
-      });
-    })());
+    const toolObserved = await observeExecutionStream(
+      (async function* () {
+        yield createProgram({
+          code: [
+            {
+              opcode: Opcode.STREAM_TOOL_DELTA,
+              value: { kind: "json", value: new Uint8Array([123, 125]) },
+            },
+          ],
+        });
+        yield createProgram({
+          code: [
+            {
+              opcode: Opcode.RESP_DONE,
+              value: { kind: "string", value: "tool_calls" },
+            },
+          ],
+        });
+      })(),
+    );
 
     expect(toolObserved.mode).toBe("tool");
     if (toolObserved.mode === "tool") {