@neutrome/lilsdk 0.3.5 → 0.4.0

package/test/tools.test.ts

@@ -6,9 +6,8 @@ import {
   type Instruction,
   type Program,
 } from "@neutrome/lil-engine";
-import { createTargetExecutor } from "../src/managed/target-executor.ts";
 import { connectTools, ToolArgumentsError } from "../src/tools.ts";
-import type { ExecutionTarget, ExecutorContext, Tool } from "../src/types.ts";
+import type { ExecutorContext, Tool } from "../src/types.ts";
 
 function buildToolCallResponse(
   calls: Array<{ id: string; name: string; args: string }>,
@@ -65,12 +64,47 @@ const calculatorTool: Tool = {
 };
 
 describe("connectTools", () => {
+  it("passes the executor cache to connected tools", async () => {
+    let callCount = 0;
+    const cache = {
+      async get(key: string) {
+        return key === "tool-key" ? "cached-value" : null;
+      },
+      async put() {},
+      async delete() {},
+    };
+    const tool: Tool = {
+      name: "cache-reader",
+      description: "Read a cached value",
+      schema: { type: "object", properties: {} },
+      async execute(_args, ctx) {
+        expect(ctx.cache).toBe(cache);
+        return (await ctx.cache.get("tool-key")) ?? "missing";
+      },
+    };
+    const executor = connectTools([tool], "test-model");
+    const ctx = buildCtx({
+      async invoke() {
+        callCount += 1;
+        return callCount === 1
+          ? buildToolCallResponse([
+              { id: "call_1", name: tool.name, args: "{}" },
+            ])
+          : buildTextResponse("done");
+      },
+      async *invokeStream() {
+        return;
+      },
+    });
+    ctx.cache = cache;
+
+    await executor.execute(createProgram(), ctx);
+
+    expect(callCount).toBe(2);
+  });
+
   it("passes through when LLM returns no tool calls", async () => {
-    const target: ExecutionTarget = { kind: "provider", model: "test-model" };
-    const executor = connectTools(
-      [calculatorTool],
-      createTargetExecutor(target),
-    );
+    const executor = connectTools([calculatorTool], "test-model");
 
     const request = createProgram({
       code: [
@@ -81,17 +115,14 @@ describe("connectTools", () => {
       ],
     });
 
-    const ctx = buildCtx(
-      {
-        async invoke() {
-          return buildTextResponse("Hello!");
-        },
-        async *invokeStream() {
-          yield buildTextResponse("Hello!");
-        },
+    const ctx = buildCtx({
+      async invoke() {
+        return buildTextResponse("Hello!");
       },
-      target,
-    );
+      async *invokeStream() {
+        yield buildTextResponse("Hello!");
+      },
+    });
     const result = await executor.execute(request, ctx);
 
     const hasText = result.code.some(
@@ -104,11 +135,7 @@ describe("connectTools", () => {
   });
 
   it("executes connected tool and loops until text response", async () => {
-    const target: ExecutionTarget = { kind: "provider", model: "test-model" };
-    const executor = connectTools(
-      [calculatorTool],
-      createTargetExecutor(target),
-    );
+    const executor = connectTools([calculatorTool], "test-model");
 
     let callCount = 0;
     const request = createProgram({
@@ -120,23 +147,20 @@ describe("connectTools", () => {
       ],
     });
 
-    const ctx = buildCtx(
-      {
-        async invoke() {
-          callCount += 1;
-          if (callCount === 1) {
-            return buildToolCallResponse([
-              { id: "call_1", name: "calculator", args: '{"expr":"2+2"}' },
-            ]);
-          }
-          return buildTextResponse("The answer is 4");
-        },
-        async *invokeStream() {
-          yield buildTextResponse("The answer is 4");
-        },
+    const ctx = buildCtx({
+      async invoke() {
+        callCount += 1;
+        if (callCount === 1) {
+          return buildToolCallResponse([
+            { id: "call_1", name: "calculator", args: '{"expr":"2+2"}' },
+          ]);
+        }
+        return buildTextResponse("The answer is 4");
       },
-      target,
-    );
+      async *invokeStream() {
+        yield buildTextResponse("The answer is 4");
+      },
+    });
     const result = await executor.execute(request, ctx);
 
     expect(callCount).toBe(2);
@@ -150,24 +174,17 @@ describe("connectTools", () => {
   });
 
   it("rejects malformed connected-tool arguments", async () => {
-    const target: ExecutionTarget = { kind: "provider", model: "test-model" };
-    const executor = connectTools(
-      [calculatorTool],
-      createTargetExecutor(target),
-    );
-    const ctx = buildCtx(
-      {
-        async invoke() {
-          return buildToolCallResponse([
-            { id: "call_1", name: "calculator", args: "{not json}" },
-          ]);
-        },
-        async *invokeStream() {
-          return;
-        },
+    const executor = connectTools([calculatorTool], "test-model");
+    const ctx = buildCtx({
+      async invoke() {
+        return buildToolCallResponse([
+          { id: "call_1", name: "calculator", args: "{not json}" },
+        ]);
       },
-      target,
-    );
+      async *invokeStream() {
+        return;
+      },
+    });
 
     await expect(executor.execute(createProgram(), ctx)).rejects.toBeInstanceOf(
       ToolArgumentsError,
@@ -186,30 +203,25 @@ describe("connectTools", () => {
         return `value_of_${key}`;
       },
     };
-
-    const target: ExecutionTarget = { kind: "provider", model: "test-model" };
-    const executor = connectTools([multiTool], createTargetExecutor(target));
+    const executor = connectTools([multiTool], "test-model");
 
     let callCount = 0;
     const request = createProgram();
-    const ctx = buildCtx(
-      {
-        async invoke() {
-          callCount += 1;
-          if (callCount === 1) {
-            return buildToolCallResponse([
-              { id: "call_a", name: "lookup", args: '{"key":"alpha"}' },
-              { id: "call_b", name: "lookup", args: '{"key":"beta"}' },
-            ]);
-          }
-          return buildTextResponse("Done");
-        },
-        async *invokeStream() {
-          yield buildTextResponse("Done");
-        },
+    const ctx = buildCtx({
+      async invoke() {
+        callCount += 1;
+        if (callCount === 1) {
+          return buildToolCallResponse([
+            { id: "call_a", name: "lookup", args: '{"key":"alpha"}' },
+            { id: "call_b", name: "lookup", args: '{"key":"beta"}' },
+          ]);
+        }
+        return buildTextResponse("Done");
       },
-      target,
-    );
+      async *invokeStream() {
+        yield buildTextResponse("Done");
+      },
+    });
     const result = await executor.execute(request, ctx);
 
     expect(callCount).toBe(2);
@@ -218,27 +230,20 @@ describe("connectTools", () => {
   });
 
   it("returns immediately when outer (non-connected) tool calls are present", async () => {
-    const target: ExecutionTarget = { kind: "provider", model: "test-model" };
-    const executor = connectTools(
-      [calculatorTool],
-      createTargetExecutor(target),
-    );
+    const executor = connectTools([calculatorTool], "test-model");
 
     const request = createProgram();
-    const ctx = buildCtx(
-      {
-        async invoke() {
-          return buildToolCallResponse([
-            { id: "call_1", name: "calculator", args: '{"expr":"1+1"}' },
-            { id: "call_2", name: "external_tool", args: "{}" },
-          ]);
-        },
-        async *invokeStream() {
-          return;
-        },
+    const ctx = buildCtx({
+      async invoke() {
+        return buildToolCallResponse([
+          { id: "call_1", name: "calculator", args: '{"expr":"1+1"}' },
+          { id: "call_2", name: "external_tool", args: "{}" },
+        ]);
       },
-      target,
-    );
+      async *invokeStream() {
+        return;
+      },
+    });
     let executions = 0;
     const tool: Tool = {
       ...calculatorTool,
@@ -247,7 +252,7 @@ describe("connectTools", () => {
         return calculatorTool.execute(args, ctx);
       },
     };
-    const guardedExecutor = connectTools([tool], createTargetExecutor(target));
+    const guardedExecutor = connectTools([tool], "test-model");
     const result = await guardedExecutor.execute(request, ctx);
 
     const calls = callData(result);
@@ -257,33 +262,27 @@ describe("connectTools", () => {
   });
 
   it("respects maxIterations", async () => {
-    const target: ExecutionTarget = { kind: "provider", model: "test-model" };
-    const executor = connectTools(
-      [calculatorTool],
-      createTargetExecutor(target),
-      { maxIterations: 2 },
-    );
+    const executor = connectTools([calculatorTool], "test-model", {
+      maxIterations: 2,
+    });
 
     let callCount = 0;
     const request = createProgram();
-    const ctx = buildCtx(
-      {
-        async invoke() {
-          callCount += 1;
-          return buildToolCallResponse([
-            {
-              id: `call_${callCount}`,
-              name: "calculator",
-              args: '{"expr":"1"}',
-            },
-          ]);
-        },
-        async *invokeStream() {
-          yield buildTextResponse("final");
-        },
+    const ctx = buildCtx({
+      async invoke() {
+        callCount += 1;
+        return buildToolCallResponse([
+          {
+            id: `call_${callCount}`,
+            name: "calculator",
+            args: '{"expr":"1"}',
+          },
+        ]);
       },
-      target,
-    );
+      async *invokeStream() {
+        yield buildTextResponse("final");
+      },
+    });
     await executor.execute(request, ctx);
 
     // 2 iterations in the loop + 1 final invoke
@@ -291,50 +290,43 @@ describe("connectTools", () => {
   });
 
   it("streams final response after tool loop completes", async () => {
-    const target: ExecutionTarget = { kind: "provider", model: "test-model" };
-    const executor = connectTools(
-      [calculatorTool],
-      createTargetExecutor(target),
-    );
+    const executor = connectTools([calculatorTool], "test-model");
 
     let callCount = 0;
     const request = createProgram();
-    const ctx = buildCtx(
-      {
-        async invoke() {
-          callCount += 1;
-          if (callCount === 1) {
-            return buildToolCallResponse([
-              { id: "call_1", name: "calculator", args: '{"expr":"3+3"}' },
-            ]);
-          }
-          return buildTextResponse("6");
-        },
-        async *invokeStream() {
-          yield createProgram({
-            code: [{ opcode: Opcode.STREAM_START, value: { kind: "none" } }],
-          });
-          yield createProgram({
-            code: [
-              {
-                opcode: Opcode.STREAM_DELTA,
-                value: { kind: "string", value: "6" },
-              },
-            ],
-          });
-          yield createProgram({
-            code: [
-              {
-                opcode: Opcode.RESP_DONE,
-                value: { kind: "string", value: "stop" },
-              },
-              { opcode: Opcode.STREAM_END, value: { kind: "none" } },
-            ],
-          });
-        },
+    const ctx = buildCtx({
+      async invoke() {
+        callCount += 1;
+        if (callCount === 1) {
+          return buildToolCallResponse([
+            { id: "call_1", name: "calculator", args: '{"expr":"3+3"}' },
+          ]);
+        }
+        return buildTextResponse("6");
       },
-      target,
-    );
+      async *invokeStream() {
+        yield createProgram({
+          code: [{ opcode: Opcode.STREAM_START, value: { kind: "none" } }],
+        });
+        yield createProgram({
+          code: [
+            {
+              opcode: Opcode.STREAM_DELTA,
+              value: { kind: "string", value: "6" },
+            },
+          ],
+        });
+        yield createProgram({
+          code: [
+            {
+              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(request, ctx)) {
@@ -349,7 +341,6 @@ describe("connectTools", () => {
   });
 
   it("assembles split stream tool deltas before executing a connected tool", async () => {
-    const target: ExecutionTarget = { kind: "provider", model: "test-model" };
     const calls: unknown[] = [];
     const tool: Tool = {
       ...calculatorTool,
@@ -358,47 +349,44 @@ describe("connectTools", () => {
         return "4";
       },
     };
-    const executor = connectTools([tool], createTargetExecutor(target));
+    const executor = connectTools([tool], "test-model");
     let invocation = 0;
-    const ctx = buildCtx(
-      {
-        async invoke() {
-          return buildTextResponse("unused");
-        },
-        async *invokeStream() {
-          invocation += 1;
-          if (invocation === 1) {
-            yield streamToolDelta({ index: 0, id: "call_1" });
-            yield streamToolDelta({ index: 0, name: "calculator" });
-            yield streamToolDelta({ index: 0, arguments: '{"expr":"2+2"}' });
-            yield createProgram({
-              code: [
-                {
-                  opcode: Opcode.RESP_DONE,
-                  value: { kind: "string", value: "tool_calls" },
-                },
-                { opcode: Opcode.STREAM_END, value: { kind: "none" } },
-              ],
-            });
-            return;
-          }
+    const ctx = buildCtx({
+      async invoke() {
+        return buildTextResponse("unused");
+      },
+      async *invokeStream() {
+        invocation += 1;
+        if (invocation === 1) {
+          yield streamToolDelta({ index: 0, id: "call_1" });
+          yield streamToolDelta({ index: 0, name: "calculator" });
+          yield streamToolDelta({ index: 0, arguments: '{"expr":"2+2"}' });
           yield createProgram({
             code: [
-              {
-                opcode: Opcode.STREAM_DELTA,
-                value: { kind: "string", value: "4" },
-              },
               {
                 opcode: Opcode.RESP_DONE,
-                value: { kind: "string", value: "stop" },
+                value: { kind: "string", value: "tool_calls" },
               },
               { opcode: Opcode.STREAM_END, value: { kind: "none" } },
             ],
           });
-        },
+          return;
+        }
+        yield createProgram({
+          code: [
+            {
+              opcode: Opcode.STREAM_DELTA,
+              value: { kind: "string", value: "4" },
+            },
+            {
+              opcode: Opcode.RESP_DONE,
+              value: { kind: "string", value: "stop" },
+            },
+            { opcode: Opcode.STREAM_END, value: { kind: "none" } },
+          ],
+        });
       },
-      target,
-    );
+    });
 
     const chunks: Program[] = [];
     for await (const chunk of executor.stream(createProgram(), ctx))
@@ -434,19 +422,27 @@ function streamToolDelta(delta: Record<string, unknown>): Program {
 
 function buildCtx(
   impl: Pick<ExecutorContext, "invoke" | "invokeStream">,
-  target: ExecutionTarget,
 ): ExecutorContext {
   const signal = new AbortController().signal;
   return {
+    cache: testCache,
     requestId: "req_test",
     executionId: "exec_test",
-    async invoke(request: Program, options) {
-      return impl.invoke(request, { target: options?.target ?? target });
+    async invoke(executor, request) {
+      return impl.invoke(executor, request);
     },
-    async *invokeStream(request: Program, options) {
-      yield* impl.invokeStream(request, { target: options?.target ?? target });
+    async *invokeStream(executor, request) {
+      yield* impl.invokeStream(executor, request);
     },
     observe: () => {},
     signal,
   };
 }
+
+const testCache: ExecutorContext["cache"] = {
+  async get() {
+    return null;
+  },
+  async put() {},
+  async delete() {},
+};

package/src/managed/target-executor.ts

@@ -1,12 +0,0 @@
-import type { ExecutionTarget, Executor } from "../types.ts";
-
-export function createTargetExecutor(target: ExecutionTarget): Executor {
-  return {
-    execute(request, context) {
-      return context.invoke(request, { target });
-    },
-    stream(request, context) {
-      return context.invokeStream(request, { target });
-    },
-  };
-}