zeitlich 0.2.23 → 0.2.24

package/dist/index.cjs

@@ -6,6 +6,7 @@ var crypto = require('crypto');
 var common = require('@temporalio/common');
 var path = require('path');
 var activity = require('@temporalio/activity');
+var fs = require('fs');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -18,8 +19,8 @@ function createToolRouter(options) {
   for (const [_key, tool] of Object.entries(options.tools)) {
     toolMap.set(tool.name, tool);
   }
-  const resolve = (v) => typeof v === "function" ? v() : v;
-  const isEnabled = (tool) => resolve(tool.enabled) ?? true;
+  const resolve2 = (v) => typeof v === "function" ? v() : v;
+  const isEnabled = (tool) => resolve2(tool.enabled) ?? true;
   if (options.plugins) {
     for (const plugin of options.plugins) {
       toolMap.set(plugin.name, plugin);
@@ -116,7 +117,7 @@ function createToolRouter(options) {
       });
     }
   }
-  async function processToolCall(toolCall, turn, sandboxId) {
+  async function processToolCall(toolCall, turn, sandboxId, sandboxStateUpdate) {
     const startTime = Date.now();
     const tool = toolMap.get(toolCall.name);
     const preResult = await runPreHooks(toolCall, tool, turn);
@@ -143,7 +144,8 @@ function createToolRouter(options) {
           threadId: options.threadId,
           toolCallId: toolCall.id,
           toolName: toolCall.name,
-          ...sandboxId !== void 0 && { sandboxId }
+          ...sandboxId !== void 0 && { sandboxId },
+          ...sandboxStateUpdate && { sandboxStateUpdate }
         };
         const response = await tool.handler(
           effectiveArgs,
@@ -207,7 +209,7 @@ function createToolRouter(options) {
       if (!tool || !isEnabled(tool)) {
         throw new Error(`Tool ${toolCall.name} not found`);
       }
-      const parsedArgs = resolve(tool.schema).parse(toolCall.args);
+      const parsedArgs = resolve2(tool.schema).parse(toolCall.args);
       return {
         id: toolCall.id ?? "",
         name: toolCall.name,
@@ -224,8 +226,8 @@ function createToolRouter(options) {
     getToolDefinitions() {
       return Array.from(toolMap).filter(([, tool]) => isEnabled(tool)).map(([name, tool]) => ({
         name,
-        description: resolve(tool.description),
-        schema: resolve(tool.schema),
+        description: resolve2(tool.description),
+        schema: resolve2(tool.schema),
         strict: tool.strict,
         max_uses: tool.max_uses
       }));
@@ -236,9 +238,10 @@ function createToolRouter(options) {
       }
       const turn = context?.turn ?? 0;
       const sandboxId = context?.sandboxId;
+      const sandboxStateUpdate = context?.sandboxStateUpdate;
       if (options.parallel) {
         const results2 = await Promise.all(
-          toolCalls.map((tc) => processToolCall(tc, turn, sandboxId))
+          toolCalls.map((tc) => processToolCall(tc, turn, sandboxId, sandboxStateUpdate))
         );
         return results2.filter(
           (r) => r !== null
@@ -246,7 +249,7 @@ function createToolRouter(options) {
       }
       const results = [];
       for (const toolCall of toolCalls) {
-        const result = await processToolCall(toolCall, turn, sandboxId);
+        const result = await processToolCall(toolCall, turn, sandboxId, sandboxStateUpdate);
         if (result !== null) {
           results.push(result);
         }
@@ -412,7 +415,11 @@ function createSubagentHandler(subagents) {
     }
     let sandbox;
     if (sandboxCfg.source === "inherit" && parentSandboxId) {
-      sandbox = { mode: "inherit", sandboxId: parentSandboxId };
+      sandbox = {
+        mode: "inherit",
+        sandboxId: parentSandboxId,
+        ...context.sandboxStateUpdate && { stateUpdate: context.sandboxStateUpdate }
+      };
     } else if (sandboxCfg.source === "own") {
       const prevSbId = continuationThreadId ? threadSandboxes.get(continuationThreadId) : void 0;
       if (prevSbId) {
@@ -568,6 +575,29 @@ function createReadSkillTool(skills) {
 }
 
 // src/lib/skills/handler.ts
+function formatSkillResponse(skill) {
+  const parts = [];
+  parts.push(`<skill_content name="${skill.name}">`);
+  parts.push(skill.instructions);
+  if (skill.location) {
+    parts.push(`
+Skill directory: ${skill.location}`);
+    parts.push(
+      "Relative paths in this skill resolve against the skill directory above."
+    );
+  }
+  const resources = skill.resourceContents ? Object.keys(skill.resourceContents) : [];
+  if (resources.length > 0) {
+    parts.push("");
+    parts.push("<skill_resources>");
+    for (const r of resources) {
+      parts.push(`  <file>${r}</file>`);
+    }
+    parts.push("</skill_resources>");
+  }
+  parts.push("</skill_content>");
+  return parts.join("\n");
+}
 function createReadSkillHandler(skills) {
   const skillMap = new Map(skills.map((s) => [s.name, s]));
   return (args) => {
@@ -581,20 +611,41 @@ function createReadSkillHandler(skills) {
       };
     }
     return {
-      toolResponse: skill.instructions,
+      toolResponse: formatSkillResponse(skill),
       data: null
     };
   };
 }
 
 // src/lib/skills/register.ts
+function validateSkillNames(skills) {
+  const names = skills.map((s) => s.name);
+  const dupes = names.filter((n, i) => names.indexOf(n) !== i);
+  if (dupes.length > 0) {
+    throw new Error(
+      `Duplicate skill names: ${[...new Set(dupes)].join(", ")}`
+    );
+  }
+}
 function buildSkillRegistration(skills) {
   if (skills.length === 0) return null;
+  validateSkillNames(skills);
   return {
     ...createReadSkillTool(skills),
     handler: createReadSkillHandler(skills)
   };
 }
+function collectSkillFiles(skills) {
+  let files;
+  for (const skill of skills) {
+    if (!skill.resourceContents || !skill.location) continue;
+    for (const [relPath, content] of Object.entries(skill.resourceContents)) {
+      files ??= {};
+      files[`${skill.location}/${relPath}`] = content;
+    }
+  }
+  return files;
+}
 async function createSession({
   agentName,
   maxTurns = 50,
@@ -694,8 +745,14 @@ async function createSession({
       const sandboxMode = sandboxInit?.mode;
       let sandboxId;
       let sandboxOwned = false;
+      let sandboxStateUpdate;
       if (sandboxMode === "inherit") {
-        sandboxId = sandboxInit.sandboxId;
+        const inheritInit = sandboxInit;
+        sandboxId = inheritInit.sandboxId;
+        if (inheritInit.stateUpdate) {
+          sandboxStateUpdate = inheritInit.stateUpdate;
+          stateManager.mergeUpdate(inheritInit.stateUpdate);
+        }
         if (!sandboxOps) {
           throw workflow.ApplicationFailure.create({
             message: "sandboxId provided but no sandboxOps \u2014 cannot manage sandbox lifecycle",
@@ -723,10 +780,14 @@ async function createSession({
         );
         sandboxOwned = true;
       } else if (sandboxOps) {
-        const result = await sandboxOps.createSandbox();
+        const skillFiles = skills ? collectSkillFiles(skills) : void 0;
+        const result = await sandboxOps.createSandbox(
+          skillFiles ? { initialFiles: skillFiles } : void 0
+        );
         sandboxId = result.sandboxId;
         sandboxOwned = true;
         if (result.stateUpdate) {
+          sandboxStateUpdate = result.stateUpdate;
           stateManager.mergeUpdate(result.stateUpdate);
         }
       }
@@ -798,7 +859,8 @@ async function createSession({
             parsedToolCalls,
             {
               turn: currentTurn,
-              ...sandboxId !== void 0 && { sandboxId }
+              ...sandboxId !== void 0 && { sandboxId },
+              ...sandboxStateUpdate && { sandboxStateUpdate }
             }
           );
           for (const result of toolCallResults) {
@@ -1739,7 +1801,11 @@ var FileSystemSkillProvider = class {
     for (const dir of dirs) {
       const raw = await this.fs.readFile(path.join(this.baseDir, dir, "SKILL.md"));
       const { frontmatter } = parseSkillFile(raw);
-      skills.push(frontmatter);
+      const location = path.join(this.baseDir, dir);
+      skills.push({
+        ...frontmatter,
+        location
+      });
     }
     return skills;
   }
@@ -1753,7 +1819,15 @@ var FileSystemSkillProvider = class {
         `Skill directory "${name}" contains SKILL.md with mismatched name "${frontmatter.name}"`
       );
     }
-    return { ...frontmatter, instructions: body };
+    const location = path.join(this.baseDir, name);
+    const resourcePaths = await this.discoverResources(name);
+    const resourceContents = await this.readResourceContents(location, resourcePaths);
+    return {
+      ...frontmatter,
+      instructions: body,
+      location,
+      ...resourceContents && { resourceContents }
+    };
   }
   /**
    * Convenience method to load all skills with full instructions.
@@ -1765,10 +1839,48 @@ var FileSystemSkillProvider = class {
     for (const dir of dirs) {
       const raw = await this.fs.readFile(path.join(this.baseDir, dir, "SKILL.md"));
       const { frontmatter, body } = parseSkillFile(raw);
-      skills.push({ ...frontmatter, instructions: body });
+      const location = path.join(this.baseDir, dir);
+      const resourcePaths = await this.discoverResources(dir);
+      const resourceContents = await this.readResourceContents(location, resourcePaths);
+      skills.push({
+        ...frontmatter,
+        instructions: body,
+        location,
+        ...resourceContents && { resourceContents }
+      });
     }
     return skills;
   }
+  /**
+   * Recursively discovers all non-SKILL.md files inside the skill directory
+   * and returns their paths relative to the skill root.
+   */
+  async discoverResources(skillDir) {
+    const skillRoot = path.join(this.baseDir, skillDir);
+    const resources = [];
+    const walk2 = async (dir, prefix) => {
+      const entries = await this.fs.readdirWithFileTypes(dir);
+      for (const e of entries) {
+        if (e.name.startsWith(".")) continue;
+        const relPath = prefix ? `${prefix}/${e.name}` : e.name;
+        if (e.isDirectory) {
+          await walk2(path.join(dir, e.name), relPath);
+        } else if (e.isFile && e.name !== "SKILL.md") {
+          resources.push(relPath);
+        }
+      }
+    };
+    await walk2(skillRoot, "");
+    return resources;
+  }
+  async readResourceContents(location, resources) {
+    if (resources.length === 0) return void 0;
+    const contents = {};
+    for (const r of resources) {
+      contents[r] = await this.fs.readFile(path.join(location, r));
+    }
+    return contents;
+  }
   async discoverSkillDirs() {
     const entries = await this.fs.readdirWithFileTypes(this.baseDir);
     const dirs = [];
@@ -1960,6 +2072,75 @@ var SandboxManager = class {
     );
   }
 };
+var NodeFsSandboxFileSystem = class {
+  workspaceBase;
+  constructor(workspaceBase) {
+    this.workspaceBase = workspaceBase;
+  }
+  abs(path$1) {
+    return path.resolve(this.workspaceBase, path$1);
+  }
+  async readFile(path) {
+    return fs.promises.readFile(this.abs(path), "utf-8");
+  }
+  async readFileBuffer(path) {
+    return fs.promises.readFile(this.abs(path));
+  }
+  async writeFile(path, content) {
+    await fs.promises.writeFile(this.abs(path), content);
+  }
+  async appendFile(path, content) {
+    await fs.promises.appendFile(this.abs(path), content);
+  }
+  async exists(path) {
+    try {
+      await fs.promises.access(this.abs(path));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async stat(path) {
+    const s = await fs.promises.stat(this.abs(path));
+    return {
+      isFile: s.isFile(),
+      isDirectory: s.isDirectory(),
+      isSymbolicLink: s.isSymbolicLink(),
+      size: s.size,
+      mtime: s.mtime
+    };
+  }
+  async mkdir(path, options) {
+    await fs.promises.mkdir(this.abs(path), options);
+  }
+  async readdir(path) {
+    return fs.promises.readdir(this.abs(path));
+  }
+  async readdirWithFileTypes(path) {
+    const entries = await fs.promises.readdir(this.abs(path), { withFileTypes: true });
+    return entries.map((e) => ({
+      name: e.name,
+      isFile: e.isFile(),
+      isDirectory: e.isDirectory(),
+      isSymbolicLink: e.isSymbolicLink()
+    }));
+  }
+  async rm(path, options) {
+    await fs.promises.rm(this.abs(path), options);
+  }
+  async cp(src, dest, options) {
+    await fs.promises.cp(this.abs(src), this.abs(dest), options);
+  }
+  async mv(src, dest) {
+    await fs.promises.rename(this.abs(src), this.abs(dest));
+  }
+  async readlink(path) {
+    return fs.promises.readlink(this.abs(path));
+  }
+  resolvePath(base, path$1) {
+    return path.posix.resolve(base, path$1);
+  }
+};
 
 // src/tools/bash/handler.ts
 var bashHandler = async (args, { sandbox }) => {
@@ -2216,6 +2397,7 @@ var toTree = async (fs, opts = {}) => {
 };
 
 exports.FileSystemSkillProvider = FileSystemSkillProvider;
+exports.NodeFsSandboxFileSystem = NodeFsSandboxFileSystem;
 exports.SandboxManager = SandboxManager;
 exports.SandboxNotFoundError = SandboxNotFoundError;
 exports.SandboxNotSupportedError = SandboxNotSupportedError;