zeitlich 0.2.28 → 0.2.29

package/dist/index.cjs

@@ -135,6 +135,11 @@ function createToolRouter(options) {
       return null;
     }
     const effectiveArgs = preResult.args;
+    workflow.log.debug("tool call dispatched", {
+      toolName: toolCall.name,
+      toolCallId: toolCall.id,
+      turn
+    });
     let result;
     let content;
     let resultAppended = false;
@@ -161,6 +166,13 @@ function createToolRouter(options) {
         content = JSON.stringify(result, null, 2);
       }
     } catch (error) {
+      workflow.log.warn("tool call failed", {
+        toolName: toolCall.name,
+        toolCallId: toolCall.id,
+        turn,
+        durationMs: Date.now() - startTime,
+        error: error instanceof Error ? error.message : String(error)
+      });
       const recovery = await runFailureHooks(
         toolCall,
         tool,
@@ -186,19 +198,26 @@ function createToolRouter(options) {
         [workflow.uuid4(), config]
       );
     }
+    const durationMs = Date.now() - startTime;
     const toolResult = {
       toolCallId: toolCall.id,
       name: toolCall.name,
       data: result,
       ...metadata && { metadata }
     };
+    workflow.log.debug("tool call completed", {
+      toolName: toolCall.name,
+      toolCallId: toolCall.id,
+      turn,
+      durationMs
+    });
     await runPostHooks(
       toolCall,
       tool,
       toolResult,
       effectiveArgs,
       turn,
-      Date.now() - startTime
+      durationMs
     );
     return toolResult;
   }
@@ -441,6 +460,12 @@ function createSubagentHandler(subagents, options) {
       args: resolvedContext === void 0 ? [args.prompt, workflowInput] : [args.prompt, workflowInput, resolvedContext],
       taskQueue: config.taskQueue ?? parentTaskQueue
     };
+    workflow.log.info("subagent spawned", {
+      subagent: config.agentName,
+      childWorkflowId,
+      threadMode,
+      sandboxSource: sandboxCfg.source
+    });
     const childHandle = await workflow.startChild(config.workflow, childOpts);
     const effectiveShutdown = sandboxCfg.shutdown ?? "destroy";
     const shouldDeferDestroy = effectiveShutdown === "pause-until-parent-close" && (sandboxCfg.source === "own" || allowsContinuation && sandboxCfg.source !== "inherit");
@@ -457,11 +482,20 @@ function createSubagentHandler(subagents, options) {
     const childResult = childResults.get(childWorkflowId);
     childResults.delete(childWorkflowId);
     if (!childResult) {
+      workflow.log.warn("subagent returned no result", {
+        subagent: config.agentName,
+        childWorkflowId
+      });
       return {
         toolResponse: "Subagent workflow did not signal a result",
         data: null
       };
     }
+    workflow.log.info("subagent completed", {
+      subagent: config.agentName,
+      childWorkflowId,
+      ...childResult.usage && { usage: childResult.usage }
+    });
     const {
       toolResponse,
       data,
@@ -678,7 +712,8 @@ async function createSession({
   sandboxOps,
   thread: threadInit,
   sandbox: sandboxInit,
-  sandboxShutdown = "destroy"
+  sandboxShutdown = "destroy",
+  virtualFs: virtualFsConfig
 }) {
   const threadMode = threadInit?.mode ?? "new";
   let threadId;
@@ -818,6 +853,17 @@ async function createSession({
           stateManager.mergeUpdate(result.stateUpdate);
         }
       }
+      if (virtualFsConfig) {
+        const result = await virtualFsConfig.ops.resolveFileTree(
+          virtualFsConfig.resolverContext
+        );
+        stateManager.mergeUpdate({
+          fileTree: result.fileTree,
+          resolverContext: virtualFsConfig.resolverContext,
+          workspaceBase: virtualFsConfig.workspaceBase ?? "/",
+          ...result.stateUpdate
+        });
+      }
       if (hooks.onSessionStart) {
         await hooks.onSessionStart({
           threadId,
@@ -825,6 +871,14 @@ async function createSession({
           metadata
         });
       }
+      workflow.log.info("session started", {
+        agentName,
+        threadId,
+        threadMode,
+        maxTurns,
+        ...sandboxId && { sandboxId }
+      });
+      const sessionStartMs = Date.now();
       const systemPrompt = stateManager.getSystemPrompt();
       if (threadMode === "fork" && sourceThreadId) {
         await forkThread(sourceThreadId, threadId, threadKey);
@@ -847,6 +901,7 @@ async function createSession({
         while (stateManager.isRunning() && !stateManager.isTerminal() && stateManager.getTurns() < maxTurns) {
           stateManager.incrementTurns();
           const currentTurn = stateManager.getTurns();
+          workflow.log.debug("turn started", { agentName, threadId, turn: currentTurn });
           stateManager.setTools(toolRouter.getToolDefinitions());
           const { message, rawToolCalls, usage } = await runAgent({
             threadId,
@@ -857,9 +912,24 @@ async function createSession({
           if (usage) {
             stateManager.updateUsage(usage);
           }
+          workflow.log.debug("model response received", {
+            agentName,
+            threadId,
+            turn: currentTurn,
+            toolCallCount: rawToolCalls.length,
+            ...usage && { usage }
+          });
           if (!toolRouter.hasTools() || rawToolCalls.length === 0) {
             stateManager.complete();
             exitReason = "completed";
+            workflow.log.info("session ended", {
+              agentName,
+              threadId,
+              exitReason,
+              turns: currentTurn,
+              durationMs: Date.now() - sessionStartMs,
+              usage: stateManager.getTotalUsage()
+            });
             return {
               threadId,
               finalMessage: message,
@@ -911,9 +981,21 @@ async function createSession({
         }
         if (stateManager.getTurns() >= maxTurns && stateManager.isRunning()) {
           exitReason = "max_turns";
+          workflow.log.warn("session hit max turns", {
+            agentName,
+            threadId,
+            maxTurns
+          });
         }
       } catch (error) {
         exitReason = "failed";
+        workflow.log.error("session failed", {
+          agentName,
+          threadId,
+          turns: stateManager.getTurns(),
+          durationMs: Date.now() - sessionStartMs,
+          error: error instanceof Error ? error.message : String(error)
+        });
         throw workflow.ApplicationFailure.fromError(error);
       } finally {
         await callSessionEnd(exitReason, stateManager.getTurns());
@@ -932,6 +1014,14 @@ async function createSession({
           await destroySubagentSandboxes();
         }
       }
+      workflow.log.info("session ended", {
+        agentName,
+        threadId,
+        exitReason,
+        turns: stateManager.getTurns(),
+        durationMs: Date.now() - sessionStartMs,
+        usage: stateManager.getTotalUsage()
+      });
       return {
         threadId,
         finalMessage: null,
@@ -1269,6 +1359,60 @@ function defineSubagentWorkflow(config, fn) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   });
 }
+function createObservabilityHooks(agentName) {
+  const { zeitlichMetrics } = workflow.proxySinks();
+  let sessionStartMs = Date.now();
+  return {
+    onSessionStart: (ctx) => {
+      sessionStartMs = Date.now();
+      zeitlichMetrics.sessionStarted({
+        agentName,
+        threadId: ctx.threadId,
+        metadata: ctx.metadata
+      });
+    },
+    onSessionEnd: (ctx) => {
+      zeitlichMetrics.sessionEnded({
+        agentName,
+        threadId: ctx.threadId,
+        exitReason: ctx.exitReason,
+        turns: ctx.turns,
+        usage: {},
+        durationMs: Date.now() - sessionStartMs
+      });
+    },
+    onPostToolUse: (ctx) => {
+      zeitlichMetrics.toolExecuted({
+        agentName,
+        toolName: ctx.toolCall.name,
+        durationMs: ctx.durationMs,
+        success: true,
+        threadId: ctx.threadId,
+        turn: ctx.turn
+      });
+    },
+    onPostToolUseFailure: (ctx) => {
+      zeitlichMetrics.toolExecuted({
+        agentName,
+        toolName: ctx.toolCall.name,
+        durationMs: 0,
+        success: false,
+        threadId: ctx.threadId,
+        turn: ctx.turn
+      });
+      return {};
+    }
+  };
+}
+function composeHooks(...fns) {
+  return async (...args) => {
+    let lastResult;
+    for (const fn of fns) {
+      lastResult = await fn(...args);
+    }
+    return lastResult;
+  };
+}
 var SandboxNotSupportedError = class extends common.ApplicationFailure {
   constructor(operation) {
     super(
@@ -1284,7 +1428,7 @@ var SandboxNotFoundError = class extends common.ApplicationFailure {
   }
 };
 
-// src/adapters/sandbox/virtual/mutations.ts
+// src/lib/virtual-fs/mutations.ts
 function applyVirtualTreeMutations(stateManager, mutations) {
   let tree = [...stateManager.get("fileTree")];
   for (const m of mutations) {
@@ -1306,7 +1450,7 @@ function applyVirtualTreeMutations(stateManager, mutations) {
   return tree;
 }
 
-// src/adapters/sandbox/virtual/tree.ts
+// src/lib/virtual-fs/tree.ts
 var buildTree = (entries) => {
   const root = { name: "/", children: /* @__PURE__ */ new Map(), isFile: false };
   for (const entry of entries) {
@@ -1354,7 +1498,7 @@ function formatVirtualFileTree(entries, opts = {}) {
   return "/" + printNode(root, "", sort);
 }
 
-// src/adapters/sandbox/virtual/queries.ts
+// src/lib/virtual-fs/queries.ts
 function hasFileWithMimeType(stateManager, pattern) {
   const tree = stateManager.get("fileTree");
   const matchers = (Array.isArray(pattern) ? pattern : [pattern]).map(buildMatcher);
@@ -1395,6 +1539,25 @@ function buildGlobMatcher(pattern) {
   );
   return (v) => re.test(v);
 }
+function proxyVirtualFsOps(scope, options) {
+  const resolvedScope = scope ?? workflow.workflowInfo().workflowType;
+  const acts = workflow.proxyActivities(
+    options ?? {
+      startToCloseTimeout: "30s",
+      retry: {
+        maximumAttempts: 3,
+        initialInterval: "2s",
+        maximumInterval: "30s",
+        backoffCoefficient: 2
+      }
+    }
+  );
+  const prefix = resolvedScope;
+  const p = (key) => `${prefix}${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+  return {
+    resolveFileTree: acts[p("resolveFileTree")]
+  };
+}
 
 // src/lib/skills/parse.ts
 function parseSkillFile(raw) {
@@ -2071,9 +2234,9 @@ var SandboxManager = class {
    * manager.createActivities("CodingAgent");
    * // registers: inMemoryCodingAgentCreateSandbox, inMemoryCodingAgentDestroySandbox, …
    *
-   * const vmgr = new SandboxManager(new VirtualSandboxProvider(resolver));
-   * vmgr.createActivities("CodingAgent");
-   * // registers: virtualCodingAgentCreateSandbox, …
+   * const dmgr = new SandboxManager(new DaytonaSandboxProvider(config));
+   * dmgr.createActivities("CodingAgent");
+   * // registers: daytonaCodingAgentCreateSandbox, …
    * ```
    */
   createActivities(scope) {
@@ -2170,6 +2333,328 @@ var NodeFsSandboxFileSystem = class {
     return path.posix.resolve(base, path$1);
   }
 };
+function normalisePath(p, workspaceBase = "/") {
+  return path.posix.resolve(workspaceBase, p);
+}
+function parentDir(p) {
+  const idx = p.lastIndexOf("/");
+  return idx <= 0 ? "/" : p.slice(0, idx);
+}
+function inferDirectories(entries, workspaceBase) {
+  const dirs = /* @__PURE__ */ new Set();
+  dirs.add("/");
+  for (const entry of entries) {
+    let dir = parentDir(normalisePath(entry.path, workspaceBase));
+    while (dir !== "/" && !dirs.has(dir)) {
+      dirs.add(dir);
+      dir = parentDir(dir);
+    }
+    dirs.add("/");
+  }
+  return dirs;
+}
+var VirtualFileSystem = class {
+  constructor(tree, resolver, ctx, workspaceBase = "/") {
+    this.resolver = resolver;
+    this.ctx = ctx;
+    this.workspaceBase = normalisePath(workspaceBase);
+    this.entries = new Map(
+      tree.map((e) => [normalisePath(e.path, this.workspaceBase), e])
+    );
+    this.directories = inferDirectories(tree, this.workspaceBase);
+  }
+  workspaceBase;
+  entries;
+  directories;
+  mutations = [];
+  /** Return all mutations accumulated during this invocation. */
+  getMutations() {
+    return this.mutations;
+  }
+  /** Look up a file entry by virtual path. */
+  getEntry(path) {
+    return this.entries.get(normalisePath(path, this.workspaceBase));
+  }
+  // --------------------------------------------------------------------------
+  // Read operations — delegate to resolver lazily
+  // --------------------------------------------------------------------------
+  async readFile(path) {
+    const norm = normalisePath(path, this.workspaceBase);
+    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);
+  }
+  async readFileBuffer(path) {
+    const norm = normalisePath(path, this.workspaceBase);
+    const entry = this.entries.get(norm);
+    if (!entry) throw new Error(`ENOENT: no such file: ${path}`);
+    return this.resolver.readFileBuffer(entry.id, this.ctx, entry.metadata);
+  }
+  // --------------------------------------------------------------------------
+  // Metadata operations — pure, resolved from the tree
+  // --------------------------------------------------------------------------
+  async exists(path) {
+    const norm = normalisePath(path, this.workspaceBase);
+    return this.entries.has(norm) || this.directories.has(norm);
+  }
+  async stat(path) {
+    const norm = normalisePath(path, this.workspaceBase);
+    const entry = this.entries.get(norm);
+    if (entry) {
+      return {
+        isFile: true,
+        isDirectory: false,
+        isSymbolicLink: false,
+        size: entry.size,
+        mtime: new Date(entry.mtime)
+      };
+    }
+    if (this.directories.has(norm)) {
+      return {
+        isFile: false,
+        isDirectory: true,
+        isSymbolicLink: false,
+        size: 0,
+        mtime: /* @__PURE__ */ new Date()
+      };
+    }
+    throw new Error(`ENOENT: no such file or directory: ${path}`);
+  }
+  async readdir(path) {
+    const norm = normalisePath(path, this.workspaceBase);
+    if (!this.directories.has(norm)) {
+      throw new Error(`ENOENT: no such directory: ${path}`);
+    }
+    const prefix = norm === "/" ? "/" : norm + "/";
+    const names = /* @__PURE__ */ new Set();
+    for (const p of this.entries.keys()) {
+      if (p.startsWith(prefix)) {
+        const rest = p.slice(prefix.length);
+        const seg = rest.split("/")[0];
+        if (seg) names.add(seg);
+      }
+    }
+    for (const d of this.directories) {
+      if (d.startsWith(prefix) && d !== norm) {
+        const rest = d.slice(prefix.length);
+        const seg = rest.split("/")[0];
+        if (seg) names.add(seg);
+      }
+    }
+    return [...names].sort();
+  }
+  async readdirWithFileTypes(path) {
+    const names = await this.readdir(path);
+    const norm = normalisePath(path, this.workspaceBase);
+    const prefix = norm === "/" ? "/" : norm + "/";
+    return names.map((name) => {
+      const full = prefix + name;
+      const isFile = this.entries.has(full);
+      const isDirectory = this.directories.has(full);
+      return { name, isFile, isDirectory, isSymbolicLink: false };
+    });
+  }
+  // --------------------------------------------------------------------------
+  // Write operations — delegate to resolver, record mutations
+  // --------------------------------------------------------------------------
+  async writeFile(path, content) {
+    const norm = normalisePath(path, this.workspaceBase);
+    const existing = this.entries.get(norm);
+    if (existing) {
+      await this.resolver.writeFile(
+        existing.id,
+        content,
+        this.ctx,
+        existing.metadata
+      );
+      const size = typeof content === "string" ? new TextEncoder().encode(content).byteLength : content.byteLength;
+      const updated = {
+        ...existing,
+        size,
+        mtime: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.entries.set(norm, updated);
+      this.mutations.push({ type: "update", path: norm, entry: updated });
+    } else {
+      const entry = await this.resolver.createFile(norm, content, this.ctx);
+      const normalised = { ...entry, path: norm };
+      this.entries.set(norm, normalised);
+      this.addParentDirectories(norm);
+      this.mutations.push({ type: "add", entry: normalised });
+    }
+  }
+  async appendFile(path, content) {
+    const norm = normalisePath(path, this.workspaceBase);
+    const existing = this.entries.get(norm);
+    if (!existing) {
+      return this.writeFile(path, content);
+    }
+    const current = await this.resolver.readFile(
+      existing.id,
+      this.ctx,
+      existing.metadata
+    );
+    const appended = typeof content === "string" ? current + content : current + new TextDecoder().decode(content);
+    await this.resolver.writeFile(
+      existing.id,
+      appended,
+      this.ctx,
+      existing.metadata
+    );
+    const size = new TextEncoder().encode(appended).byteLength;
+    const updated = {
+      ...existing,
+      size,
+      mtime: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.entries.set(norm, updated);
+    this.mutations.push({ type: "update", path: norm, entry: updated });
+  }
+  async mkdir(_path, _options) {
+    const norm = normalisePath(_path, this.workspaceBase);
+    if (this.directories.has(norm)) return;
+    if (_options?.recursive) {
+      this.addParentDirectories(norm + "/placeholder");
+      this.directories.add(norm);
+    } else {
+      const parent = parentDir(norm);
+      if (!this.directories.has(parent)) {
+        throw new Error(`ENOENT: no such directory: ${parent}`);
+      }
+      this.directories.add(norm);
+    }
+  }
+  async rm(path, options) {
+    const norm = normalisePath(path, this.workspaceBase);
+    const entry = this.entries.get(norm);
+    if (entry) {
+      await this.resolver.deleteFile(entry.id, this.ctx, entry.metadata);
+      this.entries.delete(norm);
+      this.mutations.push({ type: "remove", path: norm });
+      return;
+    }
+    if (this.directories.has(norm)) {
+      if (!options?.recursive) {
+        throw new Error(`EISDIR: is a directory (use recursive): ${path}`);
+      }
+      const prefix = norm === "/" ? "/" : norm + "/";
+      for (const [p, e] of this.entries) {
+        if (p.startsWith(prefix)) {
+          await this.resolver.deleteFile(e.id, this.ctx, e.metadata);
+          this.entries.delete(p);
+          this.mutations.push({ type: "remove", path: p });
+        }
+      }
+      for (const d of this.directories) {
+        if (d.startsWith(prefix)) this.directories.delete(d);
+      }
+      this.directories.delete(norm);
+      return;
+    }
+    if (!options?.force) {
+      throw new Error(`ENOENT: no such file or directory: ${path}`);
+    }
+  }
+  async cp(src, dest, _options) {
+    const normSrc = normalisePath(src, this.workspaceBase);
+    const normDest = normalisePath(dest, this.workspaceBase);
+    const entry = this.entries.get(normSrc);
+    if (entry) {
+      const content = await this.resolver.readFile(
+        entry.id,
+        this.ctx,
+        entry.metadata
+      );
+      await this.writeFile(normDest, content);
+      return;
+    }
+    if (!this.directories.has(normSrc)) {
+      throw new Error(`ENOENT: no such file or directory: ${src}`);
+    }
+    if (!_options?.recursive) {
+      throw new Error(`EISDIR: is a directory (use recursive): ${src}`);
+    }
+    const prefix = normSrc === "/" ? "/" : normSrc + "/";
+    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
+        );
+        await this.writeFile(normDest + relative, content);
+      }
+    }
+  }
+  async mv(src, dest) {
+    await this.cp(src, dest, { recursive: true });
+    await this.rm(src, { recursive: true });
+  }
+  // --------------------------------------------------------------------------
+  // Unsupported
+  // --------------------------------------------------------------------------
+  async readlink(_path) {
+    throw new SandboxNotSupportedError("readlink");
+  }
+  resolvePath(base, path$1) {
+    return path.posix.resolve(normalisePath(base, this.workspaceBase), path$1);
+  }
+  // --------------------------------------------------------------------------
+  // Helpers
+  // --------------------------------------------------------------------------
+  addParentDirectories(filePath) {
+    let dir = parentDir(normalisePath(filePath, this.workspaceBase));
+    while (!this.directories.has(dir)) {
+      this.directories.add(dir);
+      dir = parentDir(dir);
+    }
+  }
+};
+
+// src/lib/virtual-fs/with-virtual-fs.ts
+function withVirtualFs(client, resolver, handler) {
+  return async (args, context) => {
+    const state = await queryParentWorkflowState(client);
+    const { fileTree, resolverContext, workspaceBase } = state;
+    if (!fileTree) {
+      return {
+        toolResponse: `Error: No fileTree in agent state. The ${context.toolName} tool requires a virtual filesystem.`,
+        data: null
+      };
+    }
+    const virtualFs = new VirtualFileSystem(
+      fileTree,
+      resolver,
+      resolverContext,
+      workspaceBase ?? "/"
+    );
+    const response = await handler(args, { ...context, virtualFs });
+    const mutations = virtualFs.getMutations();
+    return {
+      toolResponse: response.toolResponse,
+      data: {
+        ...response.data ?? {},
+        treeMutations: mutations
+      }
+    };
+  };
+}
+
+// src/lib/virtual-fs/manager.ts
+function createVirtualFsActivities(resolver, scope) {
+  const ops = {
+    resolveFileTree: async (ctx) => {
+      const fileTree = await resolver.resolveEntries(ctx);
+      return { fileTree };
+    }
+  };
+  const prefix = scope;
+  const cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+  return Object.fromEntries(
+    Object.entries(ops).map(([k, v]) => [`${prefix}${cap(k)}`, v])
+  );
+}
 
 // src/tools/bash/handler.ts
 var bashHandler = async (args, { sandbox }) => {
@@ -2430,13 +2915,16 @@ exports.NodeFsSandboxFileSystem = NodeFsSandboxFileSystem;
 exports.SandboxManager = SandboxManager;
 exports.SandboxNotFoundError = SandboxNotFoundError;
 exports.SandboxNotSupportedError = SandboxNotSupportedError;
+exports.VirtualFileSystem = VirtualFileSystem;
 exports.applyVirtualTreeMutations = applyVirtualTreeMutations;
 exports.askUserQuestionTool = askUserQuestionTool;
 exports.bashHandler = bashHandler;
 exports.bashTool = bashTool;
+exports.composeHooks = composeHooks;
 exports.createAgentStateManager = createAgentStateManager;
 exports.createAskUserQuestionHandler = createAskUserQuestionHandler;
 exports.createBashToolDescription = createBashToolDescription;
+exports.createObservabilityHooks = createObservabilityHooks;
 exports.createReadSkillHandler = createReadSkillHandler;
 exports.createReadSkillTool = createReadSkillTool;
 exports.createRunAgentActivity = createRunAgentActivity;
@@ -2447,6 +2935,7 @@ exports.createTaskListHandler = createTaskListHandler;
 exports.createTaskUpdateHandler = createTaskUpdateHandler;
 exports.createThreadManager = createThreadManager;
 exports.createToolRouter = createToolRouter;
+exports.createVirtualFsActivities = createVirtualFsActivities;
 exports.defineSubagent = defineSubagent;
 exports.defineSubagentWorkflow = defineSubagentWorkflow;
 exports.defineTool = defineTool;
@@ -2464,6 +2953,7 @@ exports.hasFileWithMimeType = hasFileWithMimeType;
 exports.hasNoOtherToolCalls = hasNoOtherToolCalls;
 exports.isTerminalStatus = isTerminalStatus;
 exports.parseSkillFile = parseSkillFile;
+exports.proxyVirtualFsOps = proxyVirtualFsOps;
 exports.queryParentWorkflowState = queryParentWorkflowState;
 exports.readFileHandler = readFileHandler;
 exports.readFileTool = readFileTool;
@@ -2475,6 +2965,7 @@ exports.toTree = toTree;
 exports.withAutoAppend = withAutoAppend;
 exports.withParentWorkflowState = withParentWorkflowState;
 exports.withSandbox = withSandbox;
+exports.withVirtualFs = withVirtualFs;
 exports.writeFileHandler = writeFileHandler;
 exports.writeFileTool = writeFileTool;
 //# sourceMappingURL=index.cjs.map