zeitlich 0.2.40 → 0.2.42

package/src/lib/tool-router/auto-append-sandbox.integration.test.ts

@@ -4,6 +4,7 @@ import { withSandbox } from "./with-sandbox";
 import type { RouterContext, ToolHandlerResponse } from "./types";
 import type { ToolResultConfig } from "../types";
 import type { Sandbox } from "../sandbox/types";
+import { SandboxNotFoundError } from "../sandbox/types";
 
 // ---------------------------------------------------------------------------
 // withAutoAppend
@@ -332,6 +333,163 @@ describe("withSandbox", () => {
     ).rejects.toThrow("sandbox not found");
   });
 
+  it("propagates SandboxNotFoundError by default (no translate option)", async () => {
+    const manager = {
+      getSandbox: async (): Promise<Sandbox> => {
+        throw new SandboxNotFoundError("sb-gone");
+      },
+    };
+
+    const handler = async (): Promise<ToolHandlerResponse<null>> => ({
+      toolResponse: "ok",
+      data: null,
+    });
+
+    const wrapped = withSandbox(manager, handler);
+
+    await expect(
+      wrapped(
+        {},
+        {
+          threadId: "t",
+          toolCallId: "tc",
+          toolName: "Bash",
+          sandboxId: "sb-gone",
+        }
+      )
+    ).rejects.toBeInstanceOf(SandboxNotFoundError);
+  });
+
+  it("translates SandboxNotFoundError into a structured response when opted in", async () => {
+    const manager = {
+      getSandbox: async (): Promise<Sandbox> => {
+        throw new SandboxNotFoundError("sb-gone");
+      },
+    };
+
+    const innerCalled = vi.fn();
+    const handler = async (): Promise<ToolHandlerResponse<null>> => {
+      innerCalled();
+      return { toolResponse: "ok", data: null };
+    };
+
+    const wrapped = withSandbox(manager, handler, {
+      translateSandboxNotFound: true,
+    });
+
+    const result = await wrapped(
+      {},
+      {
+        threadId: "t",
+        toolCallId: "tc",
+        toolName: "Bash",
+        sandboxId: "sb-gone",
+      }
+    );
+
+    expect(result.toolResponse).toContain("Bash");
+    expect(result.toolResponse).toContain("execution environment");
+    expect(result.toolResponse).toContain("no longer available");
+    expect(result.toolResponse).toContain("could not be completed");
+    expect(result.toolResponse).not.toContain("session cannot continue");
+    expect(result.data).toBeNull();
+    expect(innerCalled).not.toHaveBeenCalled();
+  });
+
+  it("uses sandboxNotFoundToolResponse as the tool response when set", async () => {
+    const manager = {
+      getSandbox: async (): Promise<Sandbox> => {
+        throw new SandboxNotFoundError("sb-gone");
+      },
+    };
+
+    const handler = async (): Promise<ToolHandlerResponse<null>> => ({
+      toolResponse: "ok",
+      data: null,
+    });
+
+    const wrapped = withSandbox(manager, handler, {
+      translateSandboxNotFound: true,
+      sandboxNotFoundToolResponse:
+        "El entorno de ejecución ya no está disponible. Reinicia el agente.",
+    });
+
+    const result = await wrapped(
+      {},
+      {
+        threadId: "t",
+        toolCallId: "tc",
+        toolName: "Bash",
+        sandboxId: "sb-gone",
+      }
+    );
+
+    expect(result.toolResponse).toBe(
+      "El entorno de ejecución ya no está disponible. Reinicia el agente."
+    );
+    expect(result.toolResponse).not.toContain("execution environment");
+    expect(result.toolResponse).not.toContain("Bash");
+    expect(result.data).toBeNull();
+  });
+
+  it("ignores sandboxNotFoundToolResponse when translateSandboxNotFound is not enabled", async () => {
+    const manager = {
+      getSandbox: async (): Promise<Sandbox> => {
+        throw new SandboxNotFoundError("sb-gone");
+      },
+    };
+
+    const handler = async (): Promise<ToolHandlerResponse<null>> => ({
+      toolResponse: "ok",
+      data: null,
+    });
+
+    const wrapped = withSandbox(manager, handler, {
+      sandboxNotFoundToolResponse: "should not be used",
+    });
+
+    await expect(
+      wrapped(
+        {},
+        {
+          threadId: "t",
+          toolCallId: "tc",
+          toolName: "Bash",
+          sandboxId: "sb-gone",
+        }
+      )
+    ).rejects.toBeInstanceOf(SandboxNotFoundError);
+  });
+
+  it("does not translate non-SandboxNotFoundError errors when translate option is set", async () => {
+    const manager = {
+      getSandbox: async (): Promise<Sandbox> => {
+        throw new Error("network down");
+      },
+    };
+
+    const handler = async (): Promise<ToolHandlerResponse<null>> => ({
+      toolResponse: "ok",
+      data: null,
+    });
+
+    const wrapped = withSandbox(manager, handler, {
+      translateSandboxNotFound: true,
+    });
+
+    await expect(
+      wrapped(
+        {},
+        {
+          threadId: "t",
+          toolCallId: "tc",
+          toolName: "Bash",
+          sandboxId: "sb-gone",
+        }
+      )
+    ).rejects.toThrow("network down");
+  });
+
   it("passes all RouterContext fields through to inner handler", async () => {
     const mockSandbox = createMockSandbox();
     const manager = { getSandbox: async () => mockSandbox };

package/src/lib/tool-router/index.ts

@@ -1,7 +1,7 @@
 export { createToolRouter, defineTool, hasNoOtherToolCalls } from "./router";
 export { withAutoAppend } from "./auto-append";
 export { withSandbox } from "./with-sandbox";
-export type { SandboxContext } from "./with-sandbox";
+export type { SandboxContext, WithSandboxOptions } from "./with-sandbox";
 
 export type {
   ToolDefinition,

package/src/lib/tool-router/with-sandbox.ts

@@ -1,4 +1,5 @@
 import type { Sandbox } from "../sandbox/types";
+import { SandboxNotFoundError } from "../sandbox/types";
 import type { JsonValue } from "../state/types";
 import type {
   ActivityToolHandler,
@@ -6,6 +7,33 @@ import type {
   ToolHandlerResponse,
 } from "./types";
 
+/**
+ * Options for {@link withSandbox}.
+ */
+export interface WithSandboxOptions {
+  /**
+   * If `true`, a {@link SandboxNotFoundError} thrown by `manager.getSandbox`
+   * is translated into a structured tool-handler response (instead of
+   * propagating). This lets the agent return a graceful error to the model
+   * rather than crashing the workflow when the backing sandbox has been
+   * killed mid-run (e.g. because the E2B `timeoutMs` lifetime elapsed).
+   *
+   * Off by default to preserve the existing contract for callers that rely
+   * on the error bubbling out. New callers should generally enable this in
+   * combination with the E2B `keepAliveMs` provider option.
+   *
+   * @default false
+   */
+  translateSandboxNotFound?: boolean;
+  /**
+   * Custom tool response returned to the agent when the backing sandbox
+   * is not found and `translateSandboxNotFound` is `true`. Defaults to a
+   * generic English message. Use this to localize, match agent persona,
+   * or give the model more specific recovery instructions.
+   */
+  sandboxNotFoundToolResponse?: string;
+}
+
 /**
  * Extended router context with a resolved {@link Sandbox} instance.
  *
@@ -65,13 +93,15 @@ export function withSandbox<
   handler: (
     args: TArgs,
     context: RouterContext & { sandbox: TSandbox; sandboxId: string }
-  ) => Promise<ToolHandlerResponse<TResult, TToolResponse>>
+  ) => Promise<ToolHandlerResponse<TResult, TToolResponse>>,
+  options?: WithSandboxOptions
 ): ActivityToolHandler<
   TArgs,
   TResult | null,
   RouterContext,
   TToolResponse | string
 > {
+  const translateSandboxNotFound = options?.translateSandboxNotFound ?? false;
   return async (args, context) => {
     if (!context.sandboxId) {
       return {
@@ -79,7 +109,20 @@ export function withSandbox<
         data: null,
       };
     }
-    const sandbox = await manager.getSandbox(context.sandboxId);
+    let sandbox: TSandbox;
+    try {
+      sandbox = await manager.getSandbox(context.sandboxId);
+    } catch (err) {
+      if (translateSandboxNotFound && err instanceof SandboxNotFoundError) {
+        return {
+          toolResponse:
+            options?.sandboxNotFoundToolResponse ??
+            `Error: the execution environment for the ${context.toolName} tool is no longer available, so this tool call could not be completed.`,
+          data: null,
+        };
+      }
+      throw err;
+    }
     return handler(args, { ...context, sandbox, sandboxId: context.sandboxId });
   };
 }

package/src/lib/virtual-fs/filesystem.ts

@@ -104,7 +104,7 @@ export class VirtualFileSystem<
     if (inline !== undefined) return inline;
     const entry = this.entries.get(norm);
     if (!entry) throw new Error(`ENOENT: no such file: ${path}`);
-    return this.resolver.readFile(entry.id, this.ctx, entry.metadata);
+    return this.readEntryContent(entry);
   }
 
   async readFileBuffer(path: string): Promise<Uint8Array> {
@@ -113,9 +113,25 @@ export class VirtualFileSystem<
     if (inline !== undefined) return new TextEncoder().encode(inline);
     const entry = this.entries.get(norm);
     if (!entry) throw new Error(`ENOENT: no such file: ${path}`);
+    if (entry.inlineContent !== undefined) {
+      return new TextEncoder().encode(entry.inlineContent);
+    }
     return this.resolver.readFileBuffer(entry.id, this.ctx, entry.metadata);
   }
 
+  /**
+   * Resolve the string content for an entry, preferring inline content
+   * carried on the entry itself before consulting the resolver. Used by
+   * `readFile`, `appendFile`, and `cp` so all read paths agree on the
+   * lookup precedence.
+   */
+  private readEntryContent(entry: FileEntry<TMeta>): Promise<string> {
+    if (entry.inlineContent !== undefined) {
+      return Promise.resolve(entry.inlineContent);
+    }
+    return this.resolver.readFile(entry.id, this.ctx, entry.metadata);
+  }
+
   // --------------------------------------------------------------------------
   // Metadata operations — pure, resolved from the tree
   // --------------------------------------------------------------------------
@@ -196,6 +212,11 @@ export class VirtualFileSystem<
     const existing = this.entries.get(norm);
 
     if (existing) {
+      if (existing.inlineContent !== undefined) {
+        throw new Error(
+          `EROFS: cannot write to inline (read-only) entry: ${path}`
+        );
+      }
       await this.resolver.writeFile(
         existing.id,
         content,
@@ -230,11 +251,13 @@ export class VirtualFileSystem<
       return this.writeFile(path, content);
     }
 
-    const current = await this.resolver.readFile(
-      existing.id,
-      this.ctx,
-      existing.metadata
-    );
+    if (existing.inlineContent !== undefined) {
+      throw new Error(
+        `EROFS: cannot append to inline (read-only) entry: ${path}`
+      );
+    }
+
+    const current = await this.readEntryContent(existing);
     const appended =
       typeof content === "string"
         ? current + content
@@ -283,6 +306,11 @@ export class VirtualFileSystem<
     const entry = this.entries.get(norm);
 
     if (entry) {
+      if (entry.inlineContent !== undefined) {
+        throw new Error(
+          `EROFS: cannot remove inline (read-only) entry: ${path}`
+        );
+      }
       await this.resolver.deleteFile(entry.id, this.ctx, entry.metadata);
       this.entries.delete(norm);
       this.mutations.push({ type: "remove", path: norm });
@@ -296,6 +324,11 @@ export class VirtualFileSystem<
       const prefix = norm === "/" ? "/" : norm + "/";
       for (const [p, e] of this.entries) {
         if (p.startsWith(prefix)) {
+          if (e.inlineContent !== undefined) {
+            throw new Error(
+              `EROFS: cannot remove inline (read-only) entry: ${p}`
+            );
+          }
           await this.resolver.deleteFile(e.id, this.ctx, e.metadata);
           this.entries.delete(p);
           this.mutations.push({ type: "remove", path: p });
@@ -323,11 +356,7 @@ export class VirtualFileSystem<
 
     const entry = this.entries.get(normSrc);
     if (entry) {
-      const content = await this.resolver.readFile(
-        entry.id,
-        this.ctx,
-        entry.metadata
-      );
+      const content = await this.readEntryContent(entry);
       await this.writeFile(normDest, content);
       return;
     }
@@ -343,11 +372,7 @@ export class VirtualFileSystem<
     for (const [p, e] of this.entries) {
       if (p.startsWith(prefix)) {
         const relative = p.slice(normSrc.length);
-        const content = await this.resolver.readFile(
-          e.id,
-          this.ctx,
-          e.metadata
-        );
+        const content = await this.readEntryContent(e);
         await this.writeFile(normDest + relative, content);
       }
     }

package/src/lib/virtual-fs/types.ts

@@ -20,6 +20,25 @@ export interface FileEntry<TMeta = FileEntryMetadata> {
   /** ISO-8601 date string (JSON-safe) */
   mtime: string;
   metadata: TMeta;
+  /**
+   * Optional inline content carried directly on the entry. When present the
+   * {@link VirtualFileSystem} returns this string from `readFile` /
+   * `readFileBuffer` (and uses it as the source for `cp` / `appendFile`)
+   * without consulting the resolver.
+   *
+   * Use this for files that exist purely in workflow state and have no
+   * backing in the consumer's data layer (e.g. skill resources bundled at
+   * session creation time). Because the content travels with the entry,
+   * any tool handler that constructs a `VirtualFileSystem` from `fileTree`
+   * sees the same content — no separate `inlineFiles` plumbing required.
+   *
+   * Read-only: entries with `inlineContent` reject in-place mutations
+   * (`writeFile`, `appendFile`, `rm`, `mv` of the entry, `cp` over the
+   * entry as destination). The resolver has no contract for the synthetic
+   * `id` these entries carry, so attempting a mutation throws an `EROFS`
+   * error instead of silently routing a doomed call through the resolver.
+   */
+  inlineContent?: string;
 }
 
 // ============================================================================

package/src/lib/virtual-fs/virtual-fs.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, beforeEach } from "vitest";
+import { describe, expect, it, beforeEach, vi } from "vitest";
 import type { FileEntry, FileResolver } from "./types";
 import { VirtualFileSystem } from "./filesystem";
 import { applyVirtualTreeMutations } from "./mutations";
@@ -387,6 +387,209 @@ describe("VirtualFileSystem — inlineFiles", () => {
   });
 });
 
+// ============================================================================
+// VirtualFileSystem — entry.inlineContent
+// ============================================================================
+
+describe("VirtualFileSystem — entry.inlineContent", () => {
+  const inlineEntry: FileEntry = {
+    id: "skill:code-review:checklist.md",
+    path: "/skills/code-review/checklist.md",
+    size: 18,
+    mtime: "2025-01-01T00:00:00.000Z",
+    metadata: {},
+    inlineContent: "# Review checklist",
+  };
+
+  function createFsWithInlineEntry(): VirtualFileSystem<TestCtx> {
+    const { resolver } = createMockResolver();
+    return new VirtualFileSystem([...sampleTree, inlineEntry], resolver, ctx);
+  }
+
+  it("readFile returns entry.inlineContent without hitting the resolver", async () => {
+    const { resolver, store } = createMockResolver();
+    const readFileSpy = vi.spyOn(resolver, "readFile");
+    const fs = new VirtualFileSystem(
+      [...sampleTree, inlineEntry],
+      resolver,
+      ctx
+    );
+
+    const content = await fs.readFile("/skills/code-review/checklist.md");
+    expect(content).toBe("# Review checklist");
+    expect(readFileSpy).not.toHaveBeenCalled();
+    expect(store.size).toBeGreaterThan(0);
+  });
+
+  it("readFileBuffer returns entry.inlineContent encoded as Uint8Array", async () => {
+    const fs = createFsWithInlineEntry();
+    const buf = await fs.readFileBuffer("/skills/code-review/checklist.md");
+    expect(buf).toBeInstanceOf(Uint8Array);
+    expect(new TextDecoder().decode(buf)).toBe("# Review checklist");
+  });
+
+  it("entry.inlineContent files participate in directory inference", async () => {
+    const fs = createFsWithInlineEntry();
+    expect(await fs.exists("/skills")).toBe(true);
+    expect(await fs.exists("/skills/code-review")).toBe(true);
+    expect(await fs.readdir("/skills/code-review")).toContain("checklist.md");
+  });
+
+  it("inlineFiles map still wins over entry.inlineContent for the same path", async () => {
+    const { resolver } = createMockResolver();
+    const fs = new VirtualFileSystem(
+      [...sampleTree, inlineEntry],
+      resolver,
+      ctx,
+      "/",
+      { "/skills/code-review/checklist.md": "OVERRIDE" }
+    );
+    expect(await fs.readFile("/skills/code-review/checklist.md")).toBe(
+      "OVERRIDE"
+    );
+  });
+
+  it("readFile resolves entry.inlineContent for non-normalized paths (no leading slash)", async () => {
+    const fs = createFsWithInlineEntry();
+    const content = await fs.readFile("skills/code-review/checklist.md");
+    expect(content).toBe("# Review checklist");
+  });
+
+  it("empty-string entry.inlineContent is served without falling through to the resolver", async () => {
+    const { resolver } = createMockResolver();
+    const readFileSpy = vi.spyOn(resolver, "readFile");
+    const fs = new VirtualFileSystem(
+      [
+        ...sampleTree,
+        {
+          id: "skill:empty",
+          path: "/skills/empty.md",
+          size: 0,
+          mtime: "2025-01-01T00:00:00.000Z",
+          metadata: {},
+          inlineContent: "",
+        } satisfies FileEntry,
+      ],
+      resolver,
+      ctx
+    );
+    expect(await fs.readFile("/skills/empty.md")).toBe("");
+    expect(readFileSpy).not.toHaveBeenCalled();
+  });
+
+  it("stat reports entry.inlineContent files as files", async () => {
+    const fs = createFsWithInlineEntry();
+    const stat = await fs.stat("/skills/code-review/checklist.md");
+    expect(stat.isFile).toBe(true);
+    expect(stat.isDirectory).toBe(false);
+  });
+
+  it("non-inline entries in the same tree still go through the resolver", async () => {
+    const { resolver } = createMockResolver();
+    const readFileSpy = vi.spyOn(resolver, "readFile");
+    const fs = new VirtualFileSystem(
+      [...sampleTree, inlineEntry],
+      resolver,
+      ctx
+    );
+    const content = await fs.readFile("/src/index.ts");
+    expect(content).toBe('console.log("hello");');
+    expect(readFileSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ============================================================================
+// VirtualFileSystem — entry.inlineContent read-only contract
+// ============================================================================
+
+describe("VirtualFileSystem — entry.inlineContent read-only", () => {
+  const inlineEntry: FileEntry = {
+    id: "skill:demo:notes.md",
+    path: "/skills/demo/notes.md",
+    size: 8,
+    mtime: "2025-01-01T00:00:00.000Z",
+    metadata: {},
+    inlineContent: "original",
+  };
+
+  function makeFs(): {
+    fs: VirtualFileSystem<TestCtx>;
+    resolver: FileResolver<TestCtx>;
+    spies: {
+      writeFile: ReturnType<typeof vi.spyOn>;
+      deleteFile: ReturnType<typeof vi.spyOn>;
+    };
+  } {
+    const { resolver } = createMockResolver();
+    const writeFile = vi.spyOn(resolver, "writeFile");
+    const deleteFile = vi.spyOn(resolver, "deleteFile");
+    const fs = new VirtualFileSystem(
+      [...sampleTree, inlineEntry],
+      resolver,
+      ctx
+    );
+    return { fs, resolver, spies: { writeFile, deleteFile } };
+  }
+
+  it("writeFile on inline entry throws EROFS and never calls resolver.writeFile", async () => {
+    const { fs, spies } = makeFs();
+    await expect(fs.writeFile("/skills/demo/notes.md", "new")).rejects.toThrow(
+      /EROFS/
+    );
+    expect(spies.writeFile).not.toHaveBeenCalled();
+  });
+
+  it("appendFile on inline entry throws EROFS and never calls resolver.writeFile", async () => {
+    const { fs, spies } = makeFs();
+    await expect(
+      fs.appendFile("/skills/demo/notes.md", "more")
+    ).rejects.toThrow(/EROFS/);
+    expect(spies.writeFile).not.toHaveBeenCalled();
+  });
+
+  it("rm on inline entry throws EROFS and never calls resolver.deleteFile", async () => {
+    const { fs, spies } = makeFs();
+    await expect(fs.rm("/skills/demo/notes.md")).rejects.toThrow(/EROFS/);
+    expect(spies.deleteFile).not.toHaveBeenCalled();
+  });
+
+  it("rm recursive on a directory containing an inline entry throws EROFS", async () => {
+    const { fs, spies } = makeFs();
+    await expect(fs.rm("/skills", { recursive: true })).rejects.toThrow(
+      /EROFS/
+    );
+    expect(spies.deleteFile).not.toHaveBeenCalled();
+  });
+
+  it("mv of an inline entry throws EROFS (rm step rejects after copy)", async () => {
+    const { fs } = makeFs();
+    await expect(fs.mv("/skills/demo/notes.md", "/copy.md")).rejects.toThrow(
+      /EROFS/
+    );
+  });
+
+  it("cp from inline source to a fresh destination uses inlineContent and creates via resolver", async () => {
+    const { fs } = makeFs();
+    await fs.cp("/skills/demo/notes.md", "/copied.md");
+    expect(await fs.readFile("/copied.md")).toBe("original");
+    expect(await fs.exists("/copied.md")).toBe(true);
+  });
+
+  it("appendFile to a missing path under an inline-only directory delegates to writeFile", async () => {
+    const { fs } = makeFs();
+    await fs.appendFile("/skills/demo/new.md", "hello");
+    expect(await fs.readFile("/skills/demo/new.md")).toBe("hello");
+  });
+
+  it("cp over an inline destination throws EROFS", async () => {
+    const { fs, spies } = makeFs();
+    await expect(
+      fs.cp("/src/index.ts", "/skills/demo/notes.md")
+    ).rejects.toThrow(/EROFS/);
+    expect(spies.writeFile).not.toHaveBeenCalled();
+  });
+});
+
 // ============================================================================
 // createVirtualFsActivities
 // ============================================================================

package/src/tools/read-file/handler.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it, vi } from "vitest";
+import { readFileHandler } from "./handler";
+import { VirtualFileSystem } from "../../lib/virtual-fs/filesystem";
+import type { FileEntry, FileResolver } from "../../lib/virtual-fs/types";
+
+interface TestCtx {
+  projectId: string;
+}
+
+function createNoopResolver(): FileResolver<TestCtx> {
+  return {
+    resolveEntries: async () => [],
+    readFile: vi.fn(async () => {
+      throw new Error(
+        "resolver.readFile should not be called for inline entries"
+      );
+    }),
+    readFileBuffer: vi.fn(async () => {
+      throw new Error(
+        "resolver.readFileBuffer should not be called for inline entries"
+      );
+    }),
+    writeFile: vi.fn(async () => {}),
+    createFile: vi.fn(async () => {
+      throw new Error("not implemented");
+    }),
+    deleteFile: vi.fn(async () => {}),
+  };
+}
+
+const ctx: TestCtx = { projectId: "p" };
+
+const skillEntry: FileEntry = {
+  id: "skill:demo:notes.md",
+  path: "/skills/demo/notes.md",
+  size: 9,
+  mtime: "2025-01-01T00:00:00.000Z",
+  metadata: {},
+  inlineContent: "# notes\n",
+};
+
+describe("readFileHandler — entry.inlineContent (skill resources)", () => {
+  it("returns the inline content even when the resolver has no backing", async () => {
+    const resolver = createNoopResolver();
+    const fs = new VirtualFileSystem([skillEntry], resolver, ctx);
+
+    const response = await readFileHandler(
+      { path: "/skills/demo/notes.md" },
+      {
+        threadId: "t",
+        toolCallId: "tc",
+        toolName: "FileRead",
+        // The handler signature requires SandboxContext, which expects a
+        // SandboxFileSystem — VirtualFileSystem implements that interface.
+        sandbox: { fs } as never,
+        sandboxId: "ignored",
+      }
+    );
+
+    expect(typeof response.toolResponse).toBe("string");
+    expect(response.toolResponse).toContain("# notes");
+    expect(response.data).not.toBeNull();
+  });
+
+  it("works with non-normalized agent-supplied paths (no leading slash)", async () => {
+    const resolver = createNoopResolver();
+    const fs = new VirtualFileSystem([skillEntry], resolver, ctx);
+
+    const response = await readFileHandler(
+      { path: "skills/demo/notes.md" },
+      {
+        threadId: "t",
+        toolCallId: "tc",
+        toolName: "FileRead",
+        sandbox: { fs } as never,
+        sandboxId: "ignored",
+      }
+    );
+
+    expect(response.toolResponse).toContain("# notes");
+    expect(response.data).not.toBeNull();
+  });
+});