@neutrome/lilsdk-ts 0.2.4 → 0.3.0

package/test/lilsdk-ts.test.ts

@@ -9,10 +9,21 @@ import {
   type Program,
 } from "@neutrome/lil-engine";
 import { describe, expect, it } from "vitest";
-import { all, any, find, has, indexOf, map, reduce } from "../src/primitives/index.ts";
-import { appendAssistantMessage, appendToolInteraction } from "../src/synthetic/index.ts";
+import {
+  all,
+  any,
+  find,
+  has,
+  indexOf,
+  map,
+  reduce,
+} from "../src/primitives/index.ts";
+import {
+  appendAssistantMessage,
+  appendToolInteraction,
+} from "../src/synthetic/index.ts";
 import { observeExecutionStream, writeReasoning } from "../src/stream/index.ts";
-import { fallback, goal, retry } from "../src/loops/index.ts";
+import { fallback, retry, runGoal } from "../src/loops/index.ts";
 import {
   appendInternalDraft,
   createTwoPassExecutor,
@@ -20,18 +31,17 @@ import {
   INTERNAL_DRAFT_TOOL_NAME,
   streamModel,
 } from "../src/managed/twoPassExecutor.ts";
-import type {
-  Executor,
-  ExecutorContext,
-  OutputSink,
-} from "../src/types.ts";
+import type { Executor, ExecutorContext, OutputSink } from "../src/types.ts";
 
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 
 describe("@neutrome/lilsdk-ts", () => {
   it("provides clone-safe structural primitives", () => {
-    const needle = { opcode: Opcode.MSG_START, value: { kind: "none" as const } };
+    const needle = {
+      opcode: Opcode.MSG_START,
+      value: { kind: "none" as const },
+    };
     const program: Program = {
       code: [
         needle,
@@ -44,8 +54,12 @@ describe("@neutrome/lilsdk-ts", () => {
     expect(has(program, needle)).toBe(true);
     expect(find(program, needle)).toEqual(needle);
     expect(reduce(program, (count) => count + 1, 0)).toBe(2);
-    expect(all(program, (instruction) => instruction.opcode !== Opcode.MSG_END)).toBe(true);
-    expect(any(program, (instruction) => instruction.opcode === Opcode.TXT_CHUNK)).toBe(true);
+    expect(
+      all(program, (instruction) => instruction.opcode !== Opcode.MSG_END),
+    ).toBe(true);
+    expect(
+      any(program, (instruction) => instruction.opcode === Opcode.TXT_CHUNK),
+    ).toBe(true);
 
     const mapped = map(program, (instruction) => instruction);
     mapped.buffers[0]![0] = 9;
@@ -53,36 +67,54 @@ describe("@neutrome/lilsdk-ts", () => {
   });
 
   it("observes tool-call streams", async () => {
-    const observed = await observeExecutionStream((async function* () {
-      yield parseChatCompletionsStreamChunk(encoder.encode(JSON.stringify({
-        id: "tool-stream",
-        object: "chat.completion.chunk",
-        model: "smart",
-        choices: [{ index: 0, delta: { role: "assistant" } }],
-      })));
-      yield parseChatCompletionsStreamChunk(encoder.encode(JSON.stringify({
-        id: "tool-stream",
-        object: "chat.completion.chunk",
-        model: "smart",
-        choices: [{
-          index: 0,
-          delta: {
-            tool_calls: [{
-              index: 0,
-              id: "call_lookup",
-              type: "function",
-              function: { name: "lookup", arguments: "{\"q\":\"kyiv\"}" },
-            }],
-          },
-        }],
-      })));
-      yield parseChatCompletionsStreamChunk(encoder.encode(JSON.stringify({
-        id: "tool-stream",
-        object: "chat.completion.chunk",
-        model: "smart",
-        choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }],
-      })));
-    })());
+    const observed = await observeExecutionStream(
+      (async function* () {
+        yield parseChatCompletionsStreamChunk(
+          encoder.encode(
+            JSON.stringify({
+              id: "tool-stream",
+              object: "chat.completion.chunk",
+              model: "smart",
+              choices: [{ index: 0, delta: { role: "assistant" } }],
+            }),
+          ),
+        );
+        yield parseChatCompletionsStreamChunk(
+          encoder.encode(
+            JSON.stringify({
+              id: "tool-stream",
+              object: "chat.completion.chunk",
+              model: "smart",
+              choices: [
+                {
+                  index: 0,
+                  delta: {
+                    tool_calls: [
+                      {
+                        index: 0,
+                        id: "call_lookup",
+                        type: "function",
+                        function: { name: "lookup", arguments: '{"q":"kyiv"}' },
+                      },
+                    ],
+                  },
+                },
+              ],
+            }),
+          ),
+        );
+        yield parseChatCompletionsStreamChunk(
+          encoder.encode(
+            JSON.stringify({
+              id: "tool-stream",
+              object: "chat.completion.chunk",
+              model: "smart",
+              choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }],
+            }),
+          ),
+        );
+      })(),
+    );
 
     expect(observed.mode).toBe("tool");
     if (observed.mode !== "tool") {
@@ -90,30 +122,44 @@ describe("@neutrome/lilsdk-ts", () => {
     }
 
     const parsed = observed.chunks.map((chunk) =>
-      JSON.parse(decoder.decode(emitChatCompletionsStreamChunk(chunk)))
+      JSON.parse(decoder.decode(emitChatCompletionsStreamChunk(chunk))),
+    );
+    expect(parsed.some((chunk) => chunk.choices?.[0]?.delta?.tool_calls)).toBe(
+      true,
     );
-    expect(parsed.some((chunk) => chunk.choices?.[0]?.delta?.tool_calls)).toBe(true);
   });
 
   it("appends internal drafts with fixed SDK metadata and empty args", () => {
-    const request = parseChatCompletionsRequest(encoder.encode(JSON.stringify({
-      model: "virtual-model",
-      messages: [{ role: "user", content: "hello" }],
-    })));
+    const request = parseChatCompletionsRequest(
+      encoder.encode(
+        JSON.stringify({
+          model: "virtual-model",
+          messages: [{ role: "user", content: "hello" }],
+        }),
+      ),
+    );
 
     const updated = appendInternalDraft(request, "draft answer");
-    const emitted = JSON.parse(decoder.decode(emitChatCompletionsRequest(updated)));
+    const emitted = JSON.parse(
+      decoder.decode(emitChatCompletionsRequest(updated)),
+    );
 
-    expect(emitted.messages[1].tool_calls[0].function.name).toBe(INTERNAL_DRAFT_TOOL_NAME);
+    expect(emitted.messages[1].tool_calls[0].function.name).toBe(
+      INTERNAL_DRAFT_TOOL_NAME,
+    );
     expect(emitted.messages[1].tool_calls[0].function.arguments).toBe("{}");
     expect(emitted.messages[2].content).toBe("draft answer");
   });
 
   it("appends generic synthetic tool interactions", () => {
-    const request = parseChatCompletionsRequest(encoder.encode(JSON.stringify({
-      model: "virtual-model",
-      messages: [{ role: "user", content: "hello" }],
-    })));
+    const request = parseChatCompletionsRequest(
+      encoder.encode(
+        JSON.stringify({
+          model: "virtual-model",
+          messages: [{ role: "user", content: "hello" }],
+        }),
+      ),
+    );
 
     const updated = appendToolInteraction(request, {
       callId: "call_lookup",
@@ -121,32 +167,44 @@ describe("@neutrome/lilsdk-ts", () => {
       args: { id: "42" },
       result: { status: "active" },
     });
-    const emitted = JSON.parse(decoder.decode(emitChatCompletionsRequest(updated)));
+    const emitted = JSON.parse(
+      decoder.decode(emitChatCompletionsRequest(updated)),
+    );
 
     expect(emitted.messages[1].tool_calls[0].function).toEqual({
       name: "lookup",
-      arguments: "{\"id\":\"42\"}",
+      arguments: '{"id":"42"}',
     });
     expect(emitted.messages[2]).toEqual({
       role: "tool",
       tool_call_id: "call_lookup",
-      content: "{\"status\":\"active\"}",
+      content: '{"status":"active"}',
     });
   });
 
   it("builds two-pass executors from model and prompt config", async () => {
-    const request = parseChatCompletionsRequest(encoder.encode(JSON.stringify({
-      model: "virtual-model",
-      messages: [{ role: "user", content: "hello" }],
-    })));
+    const request = parseChatCompletionsRequest(
+      encoder.encode(
+        JSON.stringify({
+          model: "virtual-model",
+          messages: [{ role: "user", content: "hello" }],
+        }),
+      ),
+    );
     const seen: Program[] = [];
     const ctx = buildExecutorContext({
       async invoke(program) {
         seen.push(program);
         if (seen.length === 1) {
-          return appendAssistantMessage({ code: [], buffers: [] }, "draft answer");
+          return appendAssistantMessage(
+            { code: [], buffers: [] },
+            "draft answer",
+          );
         }
-        return appendAssistantMessage({ code: [], buffers: [] }, "final answer");
+        return appendAssistantMessage(
+          { code: [], buffers: [] },
+          "final answer",
+        );
       },
       async *invokeStream() {
         throw new Error("streaming path is not used in this test");
@@ -161,11 +219,19 @@ describe("@neutrome/lilsdk-ts", () => {
 
     const result = await executor.execute(request, ctx);
 
-    expect(seen.map((program) => getModel(program))).toEqual(["smart-model", "base-model"]);
+    expect(seen.map((program) => getModel(program))).toEqual([
+      "smart-model",
+      "base-model",
+    ]);
     expect(contentText(result)).toBe("final answer");
 
-    const finalRequest = JSON.parse(decoder.decode(emitChatCompletionsRequest(seen[1]!)));
-    expect(finalRequest.messages[0]).toEqual({ role: "system", content: "system prompt" });
+    const finalRequest = JSON.parse(
+      decoder.decode(emitChatCompletionsRequest(seen[1]!)),
+    );
+    expect(finalRequest.messages[0]).toEqual({
+      role: "system",
+      content: "system prompt",
+    });
     expect(finalRequest.messages[2].tool_calls[0].function).toEqual({
       name: INTERNAL_DRAFT_TOOL_NAME,
       arguments: "{}",
@@ -178,18 +244,25 @@ describe("@neutrome/lilsdk-ts", () => {
   });
 
   it("replaces draft system prompt and moves existing system prompt to first user message", async () => {
-    const request = parseChatCompletionsRequest(encoder.encode(JSON.stringify({
-      model: "virtual-model",
-      messages: [
-        { role: "system", content: "original system" },
-        { role: "user", content: "hello" },
-      ],
-    })));
+    const request = parseChatCompletionsRequest(
+      encoder.encode(
+        JSON.stringify({
+          model: "virtual-model",
+          messages: [
+            { role: "system", content: "original system" },
+            { role: "user", content: "hello" },
+          ],
+        }),
+      ),
+    );
     const seen: Program[] = [];
     const ctx = buildExecutorContext({
       async invoke(program) {
         seen.push(program);
-        return appendAssistantMessage({ code: [], buffers: [] }, seen.length === 1 ? "draft" : "final");
+        return appendAssistantMessage(
+          { code: [], buffers: [] },
+          seen.length === 1 ? "draft" : "final",
+        );
       },
       async *invokeStream() {
         throw new Error("streaming path is not used in this test");
@@ -204,7 +277,9 @@ describe("@neutrome/lilsdk-ts", () => {
 
     await executor.execute(request, ctx);
 
-    const draftRequest = JSON.parse(decoder.decode(emitChatCompletionsRequest(seen[0]!)));
+    const draftRequest = JSON.parse(
+      decoder.decode(emitChatCompletionsRequest(seen[0]!)),
+    );
     expect(draftRequest.messages).toEqual([
       { role: "system", content: "draft system" },
       { role: "user", content: "original system" },
@@ -217,31 +292,47 @@ describe("@neutrome/lilsdk-ts", () => {
     const ctx = buildExecutorContext({
       async invoke(program) {
         calls.push({ model: getModel(program) ?? "", streaming: false });
-        return appendAssistantMessage({ code: [], buffers: [] }, "model answer");
+        return appendAssistantMessage(
+          { code: [], buffers: [] },
+          "model answer",
+        );
       },
       async *invokeStream(program) {
         calls.push({ model: getModel(program) ?? "", streaming: true });
-        yield parseChatCompletionsStreamChunk(encoder.encode(JSON.stringify({
-          id: "stream-response",
-          model: "base-model",
-          choices: [{ index: 0, delta: { content: "hello" } }],
-        })));
+        yield parseChatCompletionsStreamChunk(
+          encoder.encode(
+            JSON.stringify({
+              id: "stream-response",
+              model: "base-model",
+              choices: [{ index: 0, delta: { content: "hello" } }],
+            }),
+          ),
+        );
       },
     });
 
-    const request = parseChatCompletionsRequest(encoder.encode(JSON.stringify({
-      model: "virtual-model",
-      messages: [{ role: "user", content: "hello" }],
-    })));
+    const request = parseChatCompletionsRequest(
+      encoder.encode(
+        JSON.stringify({
+          model: "virtual-model",
+          messages: [{ role: "user", content: "hello" }],
+        }),
+      ),
+    );
     const first = await invokeModel(ctx, request, "smart-model");
     const chunks: Program[] = [];
     for await (const chunk of streamModel(ctx, request, "base-model")) {
       chunks.push(chunk);
     }
 
-    expect(calls).toEqual([{ model: "smart-model", streaming: false }, { model: "base-model", streaming: true }]);
+    expect(calls).toEqual([
+      { model: "smart-model", streaming: false },
+      { model: "base-model", streaming: true },
+    ]);
     expect(contentText(first)).toBe("model answer");
-    expect(decoder.decode(emitChatCompletionsStreamChunk(chunks[0]!))).toContain("hello");
+    expect(
+      decoder.decode(emitChatCompletionsStreamChunk(chunks[0]!)),
+    ).toContain("hello");
     expect(getModel(request)).toBe("virtual-model");
   });
 
@@ -258,20 +349,27 @@ describe("@neutrome/lilsdk-ts", () => {
 
     await writeReasoning(sink, "thinking");
 
-    expect(JSON.parse(emitted[0]!).choices[0].delta.reasoning_content).toBe("thinking");
+    expect(JSON.parse(emitted[0]!).choices[0].delta.reasoning_content).toBe(
+      "thinking",
+    );
   });
 
   it("retries executor failures", async () => {
     let calls = 0;
-    const executor = retry(executorFromExecute(async () => {
-      calls += 1;
-      if (calls === 1) {
-        throw new Error("transient");
-      }
-      return appendAssistantMessage({ code: [], buffers: [] }, "ok");
-    }));
+    const executor = retry(
+      executorFromExecute(async () => {
+        calls += 1;
+        if (calls === 1) {
+          throw new Error("transient");
+        }
+        return appendAssistantMessage({ code: [], buffers: [] }, "ok");
+      }),
+    );
 
-    const result = await executor.execute({ code: [], buffers: [] }, buildExecutorContext());
+    const result = await executor.execute(
+      { code: [], buffers: [] },
+      buildExecutorContext(),
+    );
 
     expect(calls).toBe(2);
     expect(contentText(result)).toBe("ok");
@@ -282,23 +380,75 @@ describe("@neutrome/lilsdk-ts", () => {
       executorFromExecute(async () => {
         throw new Error("primary failed");
       }),
-      executorFromExecute(async () => appendAssistantMessage({ code: [], buffers: [] }, "fallback")),
+      executorFromExecute(async () =>
+        appendAssistantMessage({ code: [], buffers: [] }, "fallback"),
+      ),
     ]);
 
-    const result = await executor.execute({ code: [], buffers: [] }, buildExecutorContext());
+    const result = await executor.execute(
+      { code: [], buffers: [] },
+      buildExecutorContext(),
+    );
 
     expect(contentText(result)).toBe("fallback");
   });
 
-  it("runs goal loops until the review is satisfied", async () => {
+  it("does not retry a stream after exposing a partial chunk", async () => {
+    let retryCalls = 0;
+    const executor = retry(
+      streamingExecutor(async function* () {
+        retryCalls += 1;
+        yield appendAssistantMessage({ code: [], buffers: [] }, "partial");
+        throw new Error("stream interrupted");
+      }),
+      { attempts: 2 },
+    );
+    const context = buildExecutorContext();
+    const stream = executor
+      .stream({ code: [], buffers: [] }, context)
+      [Symbol.asyncIterator]();
+
+    await expect(stream.next()).resolves.toMatchObject({ done: false });
+    await expect(stream.next()).rejects.toThrow("stream interrupted");
+    expect(retryCalls).toBe(1);
+  });
+
+  it("does not fall back after exposing a partial stream chunk", async () => {
+    let fallbackCalls = 0;
+    const executor = fallback([
+      streamingExecutor(async function* () {
+        yield appendAssistantMessage({ code: [], buffers: [] }, "partial");
+        throw new Error("stream interrupted");
+      }),
+      streamingExecutor(async function* () {
+        fallbackCalls += 1;
+        yield appendAssistantMessage({ code: [], buffers: [] }, "fallback");
+      }),
+    ]);
+    const stream = executor
+      .stream({ code: [], buffers: [] }, buildExecutorContext())
+      [Symbol.asyncIterator]();
+
+    await expect(stream.next()).resolves.toMatchObject({ done: false });
+    await expect(stream.next()).rejects.toThrow("stream interrupted");
+    expect(fallbackCalls).toBe(0);
+  });
+
+  it("runs execute-only goal loops until the review is satisfied", async () => {
     let attempts = 0;
-    const executor = goal({
+    const executor = runGoal({
       draft: executorFromExecute(async () => {
         attempts += 1;
-        return appendAssistantMessage({ code: [], buffers: [] }, `answer ${attempts}`);
+        return appendAssistantMessage(
+          { code: [], buffers: [] },
+          `answer ${attempts}`,
+        );
       }),
       review: executorFromExecute(async () =>
-        appendAssistantMessage({ code: [], buffers: [] }, attempts > 1 ? "pass" : "retry")
+        appendAssistantMessage(
+          { code: [], buffers: [] },
+          attempts > 1 ? "pass" : "retry",
+        ),
       ),
       satisfied(review) {
         return contentText(review) === "pass";
@@ -308,7 +458,10 @@ describe("@neutrome/lilsdk-ts", () => {
       },
     });
 
-    const result = await executor.execute({ code: [], buffers: [] }, buildExecutorContext());
+    const result = await executor.execute(
+      { code: [], buffers: [] },
+      buildExecutorContext(),
+    );
 
     expect(attempts).toBe(2);
     expect(contentText(result)).toBe("answer 2");
@@ -343,3 +496,14 @@ function executorFromExecute(execute: Executor["execute"]): Executor {
     },
   };
 }
+
+function streamingExecutor(stream: Executor["stream"]): Executor {
+  return {
+    async execute(request, ctx) {
+      let result = request;
+      for await (const chunk of stream(request, ctx)) result = chunk;
+      return result;
+    },
+    stream,
+  };
+}