@neutrome/open-ai-router 0.4.2 → 0.5.1

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(executionTargetAuditRef({
-      kind: "executor",
-      executorId: "enei",
-      alias: "enei-1",
-    })).toEqual({
+    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({
       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);
         },
@@ -176,7 +186,10 @@ describe("router execution runtime", () => {
           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") {
+              if (
+                instruction.opcode === Opcode.SET_META &&
+                instruction.value.kind === "key_string"
+              ) {
                 finalMarkers[instruction.value.key] = instruction.value.value;
               }
             }
@@ -185,17 +198,23 @@ describe("router execution runtime", () => {
           const result = cloneProgram(request);
           result.code.push({
             opcode: Opcode.SET_META,
-            value: { kind: "key_string", key: "nested-invoke", value: ctx.target.model },
+            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 },
-            }],
+            code: [
+              {
+                opcode: Opcode.STREAM_DELTA,
+                value: { kind: "string", value: ctx.target.model },
+              },
+            ],
           });
         },
       },
@@ -205,7 +224,11 @@ describe("router execution runtime", () => {
           capabilities: ["write_messages"],
           async apply(program, ctx) {
             const invoked = await ctx.invoke(createProgram(), {
-              target: { kind: "provider", provider: "openrouter", model: "nested-exec" },
+              target: {
+                kind: "provider",
+                provider: "openrouter",
+                model: "nested-exec",
+              },
             });
             let invokeModel = "";
             for (const instruction of invoked.code) {
@@ -220,7 +243,11 @@ describe("router execution runtime", () => {
 
             let streamModel = "";
             for await (const chunk of ctx.invokeStream(createProgram(), {
-              target: { kind: "provider", provider: "openrouter", model: "nested-stream" },
+              target: {
+                kind: "provider",
+                provider: "openrouter",
+                model: "nested-stream",
+              },
             })) {
               const instruction = chunk.code[0];
               if (
@@ -235,11 +262,19 @@ describe("router execution runtime", () => {
             result.code.push(
               {
                 opcode: Opcode.SET_META,
-                value: { kind: "key_string", key: "from-invoke", value: invokeModel },
+                value: {
+                  kind: "key_string",
+                  key: "from-invoke",
+                  value: invokeModel,
+                },
               },
               {
                 opcode: Opcode.SET_META,
-                value: { kind: "key_string", key: "from-stream", value: streamModel },
+                value: {
+                  kind: "key_string",
+                  key: "from-stream",
+                  value: streamModel,
+                },
               },
             );
             return result;
@@ -280,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" },
+              },
             ],
           });
         },
@@ -338,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);
   });
@@ -358,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",
@@ -387,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",
@@ -407,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") {