@neutrome/lilsdk 0.4.5 → 0.5.0

package/test/lilsdk-ts.test.ts

@@ -1,16 +1,17 @@
 import {
-  contentText,
+  appendAssistantMessage,
+  appendToolInteraction,
   createProgram,
-  deltaText,
-  emitChatCompletionsRequest,
-  emitChatCompletionsStreamChunk,
-  getModel,
-  parseChatCompletionsRequest,
-  parseChatCompletionsStreamChunk,
-  programAttachments,
-  viewProgram,
-  setModel,
+  delta,
+  emitProviderRequest,
+  emitProviderStreamChunk,
+  extractAttachments,
+  extractContentText,
   Opcode,
+  parseProviderRequest,
+  parseProviderStreamChunk,
+  ProgramView,
+  setModel,
   type Program,
 } from "@neutrome/lil-engine";
 import { describe, expect, it } from "vitest";
@@ -23,30 +24,47 @@ import {
   map,
   reduce,
 } from "../src/primitives/index.ts";
-import {
-  appendAssistantMessage,
-  appendToolInteraction,
-} from "../src/synthetic/index.ts";
-import {
-  observeExecutionStream,
-  streamTextResponse,
-  writeReasoning,
-} from "../src/stream/index.ts";
+import { observeExecutionStream, writeThinking } from "../src/stream/index.ts";
 import { createGoalExecutor, fallback, retry } from "../src/loops/index.ts";
-import {
-  appendInternalDraft,
-  createTwoPassExecutor,
-  INTERNAL_DRAFT_TOOL_NAME,
-} from "../src/managed/two-pass.ts";
 import { createAttachmentToTextExecutor } from "../src/managed/attachment-to-text.ts";
+import { createCapabilitiesExecutor } from "../src/managed/capabilities.ts";
 import type { Executor, ExecutorContext, OutputSink } from "../src/types.ts";
 
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 
 describe("@neutrome/lilsdk", () => {
+  it("leaves capability tool prefixes directly available", async () => {
+    const request = parseProviderRequest(
+      "chat-completions",
+      encoder.encode(
+        JSON.stringify({
+          tools: [
+            { type: "function", function: { name: "keep_search" } },
+            { type: "function", function: { name: "managed_weather" } },
+          ],
+        }),
+      ),
+    );
+    let innerRequest: Program | undefined;
+    const executor = createCapabilitiesExecutor(
+      executorFromExecute(async (value) => {
+        innerRequest = value;
+        return value;
+      }),
+      { skipPrefixes: ["keep_"] },
+    );
+
+    await executor.execute(request, buildExecutorContext());
+
+    expect(
+      new ProgramView(innerRequest!).tools.map((tool) => tool.name),
+    ).toEqual(["keep_search", "learn_capability"]);
+  });
+
   it("describes the latest attachment and removes it before the inner executor", async () => {
-    const request = parseChatCompletionsRequest(
+    const request = parseProviderRequest(
+      "chat-completions",
       encoder.encode(
         JSON.stringify({
           messages: [
@@ -91,9 +109,9 @@ describe("@neutrome/lilsdk", () => {
       ],
     );
     await executor.execute(request, buildExecutorContext());
-    expect(programAttachments(innerRequest!)).toHaveLength(0);
+    expect(extractAttachments(innerRequest!)).toHaveLength(0);
     expect(
-      viewProgram(innerRequest!).messages.at(-1)?.toolResult?.text,
+      new ProgramView(innerRequest!).messages.at(-1)?.toolResult?.text,
     ).toContain("The original binary media is not present in this context.");
   });
   it("provides clone-safe structural primitives", () => {
@@ -128,7 +146,8 @@ describe("@neutrome/lilsdk", () => {
   it("observes tool-call streams", async () => {
     const observed = await observeExecutionStream(
       (async function* () {
-        yield parseChatCompletionsStreamChunk(
+        yield parseProviderStreamChunk(
+          "chat-completions",
           encoder.encode(
             JSON.stringify({
               id: "tool-stream",
@@ -138,7 +157,8 @@ describe("@neutrome/lilsdk", () => {
             }),
           ),
         );
-        yield parseChatCompletionsStreamChunk(
+        yield parseProviderStreamChunk(
+          "chat-completions",
           encoder.encode(
             JSON.stringify({
               id: "tool-stream",
@@ -162,7 +182,8 @@ describe("@neutrome/lilsdk", () => {
             }),
           ),
         );
-        yield parseChatCompletionsStreamChunk(
+        yield parseProviderStreamChunk(
+          "chat-completions",
           encoder.encode(
             JSON.stringify({
               id: "tool-stream",
@@ -181,37 +202,18 @@ describe("@neutrome/lilsdk", () => {
     }
 
     const parsed = observed.chunks.map((chunk) =>
-      JSON.parse(decoder.decode(emitChatCompletionsStreamChunk(chunk))),
+      JSON.parse(
+        decoder.decode(emitProviderStreamChunk("chat-completions", chunk)),
+      ),
     );
     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 updated = appendInternalDraft(request, "draft answer");
-    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.arguments).toBe("{}");
-    expect(emitted.messages[2].content).toBe("draft answer");
-  });
-
   it("appends generic synthetic tool interactions", () => {
-    const request = parseChatCompletionsRequest(
+    const request = parseProviderRequest(
+      "chat-completions",
       encoder.encode(
         JSON.stringify({
           model: "virtual-model",
@@ -227,7 +229,7 @@ describe("@neutrome/lilsdk", () => {
       result: { status: "active" },
     });
     const emitted = JSON.parse(
-      decoder.decode(emitChatCompletionsRequest(updated)),
+      decoder.decode(emitProviderRequest("chat-completions", updated)),
     );
 
     expect(emitted.messages[1].tool_calls[0].function).toEqual({
@@ -241,292 +243,20 @@ describe("@neutrome/lilsdk", () => {
     });
   });
 
-  it("builds two-pass executors from model and settings resolvers", async () => {
-    const request = parseChatCompletionsRequest(
-      encoder.encode(
-        JSON.stringify({
-          model: "virtual-model",
-          messages: [{ role: "user", content: "hello" }],
-        }),
-      ),
-    );
-    const seen: Program[] = [];
-    const ctx = buildExecutorContext({
-      async invoke(_executor, program) {
-        seen.push(program);
-        if (seen.length === 1) {
-          return appendAssistantMessage(
-            { code: [], buffers: [] },
-            "draft answer",
-          );
-        }
-        return appendAssistantMessage(
-          { code: [], buffers: [] },
-          "final answer",
-        );
-      },
-      async *invokeStream() {
-        throw new Error("streaming path is not used in this test");
-      },
-    });
-
-    const executor = createTwoPassExecutor({
-      draft: "smart-model",
-      final: "base-model",
-      resolveFinalSettings: () => ({
-        reasoningLevel: "high",
-        systemPrompt: "system prompt",
-      }),
-    });
-
-    const result = await executor.execute(request, ctx);
-
-    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",
-    });
-    expect(finalRequest.reasoning_effort).toBe("high");
-    expect(finalRequest.messages[2].tool_calls[0].function).toEqual({
-      name: INTERNAL_DRAFT_TOOL_NAME,
-      arguments: "{}",
-    });
-    expect(finalRequest.messages[3]).toEqual({
-      role: "tool",
-      tool_call_id: "knowledge_0",
-      content: "draft answer",
-    });
-  });
-
-  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 seen: Program[] = [];
-    const ctx = buildExecutorContext({
-      async invoke(_executor, program) {
-        seen.push(program);
-        return appendAssistantMessage(
-          { code: [], buffers: [] },
-          seen.length === 1 ? "draft" : "final",
-        );
-      },
-      async *invokeStream() {
-        throw new Error("streaming path is not used in this test");
-      },
-    });
-
-    const executor = createTwoPassExecutor({
-      draft: "smart-model",
-      final: "base-model",
-      resolveDraftSettings: () => ({ systemPrompt: "draft system" }),
-    });
-
-    await executor.execute(request, ctx);
-
-    const draftRequest = JSON.parse(
-      decoder.decode(emitChatCompletionsRequest(seen[0]!)),
-    );
-    expect(draftRequest.messages).toEqual([
-      { role: "system", content: "draft system" },
-      { role: "user", content: "original system" },
-      { role: "user", content: "hello" },
-    ]);
-  });
-
-  it("composes model strings and custom executors", async () => {
-    const calls: Array<{ model: string; streaming: boolean }> = [];
-    const ctx = buildExecutorContext({
-      async invoke(_executor, program) {
-        calls.push({ model: getModel(program) ?? "", streaming: false });
-        return appendAssistantMessage(
-          { code: [], buffers: [] },
-          "model answer",
-        );
-      },
-      async *invokeStream(_executor, 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" } }],
-            }),
-          ),
-        );
-      },
-    });
-
-    const request = parseChatCompletionsRequest(
-      encoder.encode(
-        JSON.stringify({
-          model: "virtual-model",
-          messages: [{ role: "user", content: "hello" }],
-        }),
-      ),
-    );
-    const first = await ctx.invoke("smart-model", request);
-    const chunks: Program[] = [];
-    for await (const chunk of ctx.invokeStream("base-model", request)) {
-      chunks.push(chunk);
-    }
-
-    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(getModel(request)).toBe("virtual-model");
-
-    const customExecutor = executorFromExecute(async () =>
-      appendAssistantMessage({ code: [], buffers: [] }, "custom answer"),
-    );
-    const custom = await ctx.invoke(customExecutor, request);
-    expect(contentText(custom)).toBe("custom answer");
-
-    const twoPass = createTwoPassExecutor({
-      draft: customExecutor,
-      final: customExecutor,
-    });
-    expect(contentText(await twoPass.execute(request, ctx))).toBe(
-      "custom answer",
-    );
-  });
-
-  it("can skip the draft pass and limits the final context length", async () => {
-    const request = parseChatCompletionsRequest(
-      encoder.encode(
-        JSON.stringify({
-          model: "virtual-model",
-          messages: [{ role: "user", content: "request" }],
-        }),
-      ),
-    );
-    const seen: Program[] = [];
-    const ctx = buildExecutorContext({
-      async invoke(_executor, program) {
-        seen.push(program);
-        return appendAssistantMessage(
-          { code: [], buffers: [] },
-          seen.length === 1 ? "a very long draft" : "final",
-        );
-      },
-      async *invokeStream() {
-        throw new Error("streaming path is not used in this test");
-      },
-    });
-
-    const executor = createTwoPassExecutor({
-      draft: "smart-model",
-      final: "base-model",
-      maxTotalContextLength: 10,
-      resolveDraftSettings: () => ({ systemPrompt: "draft" }),
-    });
-    await executor.execute(request, ctx);
-
-    const finalRequest = JSON.parse(
-      decoder.decode(emitChatCompletionsRequest(seen[1]!)),
-    );
-    expect(finalRequest.messages.at(-1)?.content).toBe("a v");
-
-    let receivedRequest: Program | undefined;
-    let receivedContext: ExecutorContext | undefined;
-    const directFinal = createTwoPassExecutor({
-      draft: "unused",
-      final: "base-model",
-      resolveDraftSettings: (incomingRequest, incomingContext) => {
-        receivedRequest = incomingRequest;
-        receivedContext = incomingContext;
-        return null;
-      },
-    });
-    await directFinal.execute(request, ctx);
-    expect(getModel(seen.at(-1)!)).toBe("base-model");
-    expect(receivedRequest).toBe(request);
-    expect(receivedContext).toBe(ctx);
-
-    const draftOnly = createTwoPassExecutor({
-      draft: "smart-model",
-      final: "unused",
-      resolveFinalSettings: () => null,
-    });
-    await draftOnly.execute(request, ctx);
-    expect(getModel(seen.at(-1)!)).toBe("smart-model");
-  });
-
-  it("keeps two-pass drafts inside the final stream", async () => {
-    const executor = createTwoPassExecutor({
-      draft: "draft",
-      final: "final",
-    });
-    const ctx = buildExecutorContext({
-      async invoke() {
-        throw new Error("non-streaming path is not used in this test");
-      },
-      async *invokeStream(executor) {
-        const text = executor === "draft" ? "draft" : "final";
-        yield createProgram({
-          code: [
-            {
-              opcode: Opcode.STREAM_DELTA,
-              value: { kind: "string", value: text },
-            },
-            {
-              opcode: Opcode.RESP_DONE,
-              value: { kind: "string", value: "stop" },
-            },
-            { opcode: Opcode.STREAM_END, value: { kind: "none" } },
-          ],
-        });
-      },
-    });
-
-    const chunks: Program[] = [];
-    for await (const chunk of executor.stream({ code: [], buffers: [] }, ctx)) {
-      chunks.push(chunk);
-    }
-    const opcodes = chunks.flatMap((chunk) =>
-      chunk.code.map((instruction) => instruction.opcode),
-    );
-
-    expect(
-      opcodes.filter((opcode) => opcode === Opcode.STREAM_END),
-    ).toHaveLength(1);
-    expect(chunks.map(deltaText).filter(Boolean)).toContain("final");
-  });
-
   it("writes reasoning helpers to a sink", async () => {
     const emitted: string[] = [];
     const sink: OutputSink = {
       write(chunk) {
-        emitted.push(decoder.decode(emitChatCompletionsStreamChunk(chunk)));
+        emitted.push(
+          decoder.decode(emitProviderStreamChunk("chat-completions", chunk)),
+        );
       },
       close() {
         emitted.push("[DONE]");
       },
     };
 
-    await writeReasoning(sink, "thinking");
+    await writeThinking(sink, "thinking");
 
     expect(JSON.parse(emitted[0]!).choices[0].delta.reasoning_content).toBe(
       "thinking",
@@ -551,7 +281,7 @@ describe("@neutrome/lilsdk", () => {
     );
 
     expect(calls).toBe(2);
-    expect(contentText(result)).toBe("ok");
+    expect(extractContentText(result)).toBe("ok");
   });
 
   it("falls back to the next executor after failure", async () => {
@@ -569,7 +299,7 @@ describe("@neutrome/lilsdk", () => {
       buildExecutorContext(),
     );
 
-    expect(contentText(result)).toBe("fallback");
+    expect(extractContentText(result)).toBe("fallback");
   });
 
   it("does not retry a stream after exposing a partial chunk", async () => {
@@ -630,7 +360,7 @@ describe("@neutrome/lilsdk", () => {
         ),
       ),
       satisfied(review) {
-        return contentText(review) === "pass";
+        return extractContentText(review) === "pass";
       },
       refine(request) {
         return request;
@@ -643,7 +373,7 @@ describe("@neutrome/lilsdk", () => {
     );
 
     expect(attempts).toBe(2);
-    expect(contentText(result)).toBe("answer 2");
+    expect(extractContentText(result)).toBe("answer 2");
   });
 
   it("streams draft and review passes through each goal iteration", async () => {
@@ -663,7 +393,7 @@ describe("@neutrome/lilsdk", () => {
         );
       }),
       satisfied(review) {
-        return contentText(review) === "pass";
+        return extractContentText(review) === "pass";
       },
       refine(request) {
         return request;
@@ -678,7 +408,7 @@ describe("@neutrome/lilsdk", () => {
       chunks.push(chunk);
     }
 
-    expect(chunks.map(contentText).filter(Boolean)).toEqual([
+    expect(chunks.map(extractContentText).filter(Boolean)).toEqual([
       "answer 1",
       "retry",
       "answer 2",
@@ -745,14 +475,14 @@ describe("@neutrome/lilsdk", () => {
     let reviewedAnswer = "";
     const executor = createGoalExecutor({
       draft: streamingExecutor(async function* () {
-        yield* streamTextResponse("answer");
+        yield* delta.textResponse("answer");
       }),
       review: streamingExecutor(async function* (request) {
-        reviewedAnswer = contentText(request);
-        yield* streamTextResponse("pass");
+        reviewedAnswer = extractContentText(request);
+        yield* delta.textResponse("pass");
       }),
       satisfied(review) {
-        return contentText(review) === "pass";
+        return extractContentText(review) === "pass";
       },
       refine(request) {
         return request;