zeitlich 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1582 @@
+import { workflowInfo, uuid4, executeChild, proxyActivities } from '@temporalio/workflow';
+import z2, { z } from 'zod';
+import { minimatch } from 'minimatch';
+import { SimplePlugin } from '@temporalio/plugin';
+import { mapStoredMessageToChatMessage, SystemMessage, mapStoredMessagesToChatMessages, AIMessage, ToolMessage, HumanMessage } from '@langchain/core/messages';
+import crypto from 'crypto';
+
+// src/lib/session.ts
+var TASK_TOOL = "Task";
+function buildTaskDescription(subagents) {
+  const subagentList = subagents.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+  return `Launch a new agent to handle complex, multi-step tasks autonomously.
+
+The ${TASK_TOOL} tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
+
+Available agent types:
+
+${subagentList}
+
+When using the ${TASK_TOOL} tool, you must specify a subagent parameter to select which agent type to use.
+
+Usage notes:
+
+- Always include a short description (3-5 words) summarizing what the agent will do
+- Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+- When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+- Each invocation starts fresh - provide a detailed task description with all necessary context.
+- Provide clear, detailed prompts so the agent can work autonomously and return exactly the information you need.
+- The agent's outputs should generally be trusted
+- Clearly tell the agent what type of work you expect since it is not aware of the user's intent
+- If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.`;
+}
+function createTaskTool(subagents) {
+  if (subagents.length === 0) {
+    throw new Error("createTaskTool requires at least one subagent");
+  }
+  const names = subagents.map((s) => s.name);
+  return {
+    name: TASK_TOOL,
+    description: buildTaskDescription(subagents),
+    schema: z2.object({
+      subagent: z2.enum(names).describe("The type of subagent to launch"),
+      description: z2.string().describe("A short (3-5 word) description of the task"),
+      prompt: z2.string().describe("The task for the agent to perform")
+    })
+  };
+}
+function createTaskHandler(subagents) {
+  const { workflowId: parentWorkflowId, taskQueue: parentTaskQueue } = workflowInfo();
+  return async (args, _toolCallId) => {
+    const config = subagents.find((s) => s.name === args.subagent);
+    if (!config) {
+      throw new Error(
+        `Unknown subagent: ${args.subagent}. Available: ${subagents.map((s) => s.name).join(", ")}`
+      );
+    }
+    const childWorkflowId = `${parentWorkflowId}-${args.subagent}-${uuid4()}`;
+    const childResult = await executeChild(config.workflowType, {
+      workflowId: childWorkflowId,
+      args: [{ prompt: args.prompt }],
+      taskQueue: config.taskQueue ?? parentTaskQueue
+    });
+    const validated = config.resultSchema ? config.resultSchema.parse(childResult) : childResult;
+    const content = typeof validated === "string" ? validated : JSON.stringify(validated, null, 2);
+    return {
+      content,
+      result: {
+        result: validated,
+        childWorkflowId
+      }
+    };
+  };
+}
+
+// src/lib/subagent-support.ts
+function withSubagentSupport(userTools, config) {
+  if (config.subagents.length === 0) {
+    throw new Error("withSubagentSupport requires at least one subagent");
+  }
+  const taskTool = createTaskTool(config.subagents);
+  const taskHandler = createTaskHandler(config.subagents);
+  return {
+    tools: {
+      ...userTools,
+      Task: taskTool
+    },
+    taskHandler
+  };
+}
+function hasTaskTool(tools) {
+  return "Task" in tools;
+}
+
+// src/lib/session.ts
+var createSession = async ({ threadId, agentName, maxTurns = 50, metadata = {} }, {
+  runAgent,
+  promptManager,
+  toolRouter,
+  toolRegistry,
+  hooks = {}
+}) => {
+  const { initializeThread, appendHumanMessage, parseToolCalls } = proxyActivities({
+    startToCloseTimeout: "30m",
+    retry: {
+      maximumAttempts: 6,
+      initialInterval: "5s",
+      maximumInterval: "15m",
+      backoffCoefficient: 4
+    },
+    heartbeatTimeout: "5m"
+  });
+  const callSessionEnd = async (exitReason, turns) => {
+    if (hooks.onSessionEnd) {
+      await hooks.onSessionEnd({
+        threadId,
+        agentName,
+        exitReason,
+        turns,
+        metadata
+      });
+    }
+  };
+  return {
+    runSession: async (prompt, stateManager) => {
+      if (hooks.onSessionStart) {
+        await hooks.onSessionStart({
+          threadId,
+          agentName,
+          metadata
+        });
+      }
+      await initializeThread(threadId);
+      await appendHumanMessage(
+        threadId,
+        await promptManager.buildContextMessage(prompt)
+      );
+      let exitReason = "completed";
+      try {
+        while (stateManager.isRunning() && !stateManager.isTerminal() && stateManager.getTurns() < maxTurns) {
+          stateManager.incrementTurns();
+          const currentTurn = stateManager.getTurns();
+          const { message, stopReason } = await runAgent(
+            {
+              threadId,
+              agentName,
+              metadata
+            },
+            {
+              systemPrompt: await promptManager.getSystemPrompt()
+            }
+          );
+          if (stopReason === "end_turn") {
+            stateManager.complete();
+            exitReason = "completed";
+            return message;
+          }
+          const rawToolCalls = await parseToolCalls(message);
+          const parsedToolCalls = rawToolCalls.map(
+            (tc) => toolRegistry.parseToolCall(tc)
+          );
+          await toolRouter.processToolCalls(parsedToolCalls, {
+            turn: currentTurn
+          });
+          if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
+            exitReason = "waiting_for_input";
+            break;
+          }
+        }
+        if (stateManager.getTurns() >= maxTurns && stateManager.isRunning()) {
+          exitReason = "max_turns";
+        }
+      } catch (error) {
+        exitReason = "failed";
+        throw error;
+      } finally {
+        await callSessionEnd(exitReason, stateManager.getTurns());
+      }
+      return null;
+    }
+  };
+};
+
+// src/lib/types.ts
+function isTerminalStatus(status) {
+  return status === "COMPLETED" || status === "FAILED" || status === "CANCELLED";
+}
+
+// src/lib/state-manager.ts
+function createAgentStateManager(config) {
+  let status = "RUNNING";
+  let version = 0;
+  let turns = 0;
+  const customState = { ...config?.initialState ?? {} };
+  function buildState() {
+    return {
+      status,
+      version,
+      turns,
+      ...customState
+    };
+  }
+  return {
+    getStatus() {
+      return status;
+    },
+    isRunning() {
+      return status === "RUNNING";
+    },
+    isTerminal() {
+      return isTerminalStatus(status);
+    },
+    getTurns() {
+      return turns;
+    },
+    getVersion() {
+      return version;
+    },
+    run() {
+      status = "RUNNING";
+      version++;
+    },
+    waitForInput() {
+      status = "WAITING_FOR_INPUT";
+      version++;
+    },
+    complete() {
+      status = "COMPLETED";
+      version++;
+    },
+    fail() {
+      status = "FAILED";
+      version++;
+    },
+    cancel() {
+      status = "CANCELLED";
+      version++;
+    },
+    incrementVersion() {
+      version++;
+    },
+    incrementTurns() {
+      turns++;
+    },
+    get(key) {
+      return customState[key];
+    },
+    set(key, value) {
+      customState[key] = value;
+      version++;
+    },
+    getCurrentState() {
+      return buildState();
+    },
+    shouldReturnFromWait(lastKnownVersion) {
+      return version > lastKnownVersion || isTerminalStatus(status);
+    }
+  };
+}
+var AGENT_HANDLER_NAMES = {
+  getAgentState: "getAgentState",
+  waitForStateChange: "waitForStateChange",
+  addMessage: "addMessage"
+};
+
+// src/lib/prompt-manager.ts
+function createPromptManager(config) {
+  const { baseSystemPrompt, instructionsPrompt, buildContextMessage } = config;
+  async function resolvePrompt(prompt) {
+    if (typeof prompt === "function") {
+      return prompt();
+    }
+    return prompt;
+  }
+  return {
+    async getSystemPrompt() {
+      const base = await resolvePrompt(baseSystemPrompt);
+      const instructions = await resolvePrompt(instructionsPrompt);
+      return [base, instructions].join("\n");
+    },
+    async buildContextMessage(context) {
+      return buildContextMessage(context);
+    }
+  };
+}
+
+// src/lib/tool-registry.ts
+function createToolRegistry(tools) {
+  const toolMap = /* @__PURE__ */ new Map();
+  for (const [_key, tool] of Object.entries(tools)) {
+    toolMap.set(tool.name, tool);
+  }
+  return {
+    parseToolCall(toolCall) {
+      const tool = toolMap.get(toolCall.name);
+      if (!tool) {
+        throw new Error(`Tool ${toolCall.name} not found`);
+      }
+      const parsedArgs = tool.schema.parse(toolCall.args);
+      return {
+        id: toolCall.id ?? "",
+        name: toolCall.name,
+        args: parsedArgs
+      };
+    },
+    getToolList() {
+      return Object.values(tools);
+    },
+    getTool(name) {
+      return tools[name];
+    },
+    hasTool(name) {
+      return toolMap.has(name);
+    },
+    getToolNames() {
+      return Array.from(toolMap.keys());
+    }
+  };
+}
+
+// src/lib/tool-router.ts
+function createToolRouter(options, handlers) {
+  const { parallel = true, threadId, appendToolResult, hooks } = options;
+  async function processToolCall(toolCall, turn) {
+    const startTime = Date.now();
+    let effectiveArgs = toolCall.args;
+    if (hooks?.onPreToolUse) {
+      const preResult = await hooks.onPreToolUse({
+        toolCall,
+        threadId,
+        turn
+      });
+      if (preResult?.skip) {
+        await appendToolResult({
+          threadId,
+          toolCallId: toolCall.id,
+          content: JSON.stringify({
+            skipped: true,
+            reason: "Skipped by PreToolUse hook"
+          })
+        });
+        return null;
+      }
+      if (preResult?.modifiedArgs !== void 0) {
+        effectiveArgs = preResult.modifiedArgs;
+      }
+    }
+    const handler = handlers[toolCall.name];
+    let result;
+    let content;
+    try {
+      if (handler) {
+        const response = await handler(
+          effectiveArgs,
+          toolCall.id
+        );
+        result = response.result;
+        content = response.content;
+      } else {
+        result = { error: `Unknown tool: ${toolCall.name}` };
+        content = JSON.stringify(result, null, 2);
+      }
+    } catch (error) {
+      if (hooks?.onPostToolUseFailure) {
+        const failureResult = await hooks.onPostToolUseFailure({
+          toolCall,
+          error: error instanceof Error ? error : new Error(String(error)),
+          threadId,
+          turn
+        });
+        if (failureResult?.fallbackContent !== void 0) {
+          content = failureResult.fallbackContent;
+          result = { error: String(error), recovered: true };
+        } else if (failureResult?.suppress) {
+          content = JSON.stringify({ error: String(error), suppressed: true });
+          result = { error: String(error), suppressed: true };
+        } else {
+          throw error;
+        }
+      } else {
+        throw error;
+      }
+    }
+    await appendToolResult({ threadId, toolCallId: toolCall.id, content });
+    const toolResult = {
+      toolCallId: toolCall.id,
+      name: toolCall.name,
+      result
+    };
+    if (hooks?.onPostToolUse) {
+      const durationMs = Date.now() - startTime;
+      await hooks.onPostToolUse({
+        toolCall,
+        result: toolResult,
+        threadId,
+        turn,
+        durationMs
+      });
+    }
+    return toolResult;
+  }
+  return {
+    async processToolCalls(toolCalls, context) {
+      if (toolCalls.length === 0) {
+        return [];
+      }
+      const turn = context?.turn ?? 0;
+      if (parallel) {
+        const results2 = await Promise.all(
+          toolCalls.map((tc) => processToolCall(tc, turn))
+        );
+        return results2.filter(
+          (r) => r !== null
+        );
+      }
+      const results = [];
+      for (const toolCall of toolCalls) {
+        const result = await processToolCall(toolCall, turn);
+        if (result !== null) {
+          results.push(result);
+        }
+      }
+      return results;
+    },
+    async processToolCallsByName(toolCalls, toolName, handler) {
+      const matchingCalls = toolCalls.filter((tc) => tc.name === toolName);
+      if (matchingCalls.length === 0) {
+        return [];
+      }
+      const processOne = async (toolCall) => {
+        const response = await handler(
+          toolCall.args,
+          toolCall.id
+        );
+        await appendToolResult({
+          threadId,
+          toolCallId: toolCall.id,
+          content: response.content
+        });
+        return {
+          toolCallId: toolCall.id,
+          name: toolCall.name,
+          result: response.result
+        };
+      };
+      if (parallel) {
+        return Promise.all(matchingCalls.map(processOne));
+      }
+      const results = [];
+      for (const toolCall of matchingCalls) {
+        results.push(await processOne(toolCall));
+      }
+      return results;
+    },
+    filterByName(toolCalls, name) {
+      return toolCalls.filter(
+        (tc) => tc.name === name
+      );
+    },
+    hasToolCall(toolCalls, name) {
+      return toolCalls.some((tc) => tc.name === name);
+    },
+    getResultsByName(results, name) {
+      return results.filter(
+        (r) => r.name === name
+      );
+    }
+  };
+}
+function hasNoOtherToolCalls(toolCalls, excludeName) {
+  return toolCalls.filter((tc) => tc.name !== excludeName).length === 0;
+}
+var askUserQuestionTool = {
+  name: "AskUserQuestion",
+  description: `Use this tool when you need to ask the user questions during execution. This allows you to:
+
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+
+* Users will always be able to select "Other" to provide custom text input
+* Use multiSelect: true to allow multiple answers to be selected for a question
+* If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label
+`,
+  schema: z2.object({
+    questions: z2.array(
+      z2.object({
+        question: z2.string().describe("The full question text to display"),
+        header: z2.string().describe("Short label for the question (max 12 characters)"),
+        options: z2.array(
+          z2.object({
+            label: z2.string(),
+            description: z2.string()
+          })
+        ).min(0).max(4).describe("Array of 0-4 choices, each with label and description"),
+        multiSelect: z2.boolean().describe("If true, users can select multiple options")
+      })
+    )
+  }),
+  strict: true
+};
+var globTool = {
+  name: "Glob",
+  description: `Search for files matching a glob pattern within the available file system.
+
+Usage:
+- Use glob patterns like "**/*.ts" to find all TypeScript files
+- Use "docs/**" to find all files in the docs directory
+- Patterns are matched against virtual paths in the file system
+
+Examples:
+- "*.md" - Find all markdown files in the root
+- "**/*.test.ts" - Find all test files recursively
+- "src/**/*.ts" - Find all TypeScript files in src directory
+`,
+  schema: z.object({
+    pattern: z.string().describe("Glob pattern to match files against"),
+    root: z.string().optional().describe("Optional root directory to search from")
+  }),
+  strict: true
+};
+var grepTool = {
+  name: "Grep",
+  description: `Search file contents for a pattern within the available file system.
+
+Usage:
+- Searches for a regex pattern across file contents
+- Returns matching lines with file paths and line numbers
+- Can filter by file patterns and limit results
+
+Examples:
+- Search for "TODO" in all files
+- Search for function definitions with "function.*handleClick"
+- Search case-insensitively with ignoreCase: true
+`,
+  schema: z.object({
+    pattern: z.string().describe("Regex pattern to search for in file contents"),
+    ignoreCase: z.boolean().optional().describe("Case-insensitive search (default: false)"),
+    maxMatches: z.number().optional().describe("Maximum number of matches to return (default: 50)"),
+    includePatterns: z.array(z.string()).optional().describe("Glob patterns to include (e.g., ['*.ts', '*.js'])"),
+    excludePatterns: z.array(z.string()).optional().describe("Glob patterns to exclude (e.g., ['*.test.ts'])"),
+    contextLines: z.number().optional().describe("Number of context lines to show around matches")
+  }),
+  strict: true
+};
+var readTool = {
+  name: "FileRead",
+  description: `Read file contents with optional pagination.
+
+Usage:
+- Provide the virtual path to the file you want to read
+- Supports text files, images, and PDFs
+- For large files, use offset and limit to read specific portions
+
+The tool returns the file content in an appropriate format:
+- Text files: Plain text content
+- Images: Base64-encoded image data
+- PDFs: Extracted text content
+`,
+  schema: z.object({
+    path: z.string().describe("Virtual path to the file to read"),
+    offset: z.number().optional().describe(
+      "Line number to start reading from (1-indexed, for text files)"
+    ),
+    limit: z.number().optional().describe("Maximum number of lines to read (for text files)")
+  }),
+  strict: true
+};
+var writeTool = {
+  name: "FileWrite",
+  description: `Create or overwrite a file with new content.
+
+Usage:
+- Provide the absolute virtual path to the file
+- The file will be created if it doesn't exist
+- If the file exists, it will be completely overwritten
+
+IMPORTANT:
+- You must read the file first (in this session) before writing to it
+- This is an atomic write operation - the entire file is replaced
+- Path must be absolute (e.g., "/docs/readme.md", not "docs/readme.md")
+`,
+  schema: z.object({
+    file_path: z.string().describe("The absolute virtual path to the file to write"),
+    content: z.string().describe("The content to write to the file")
+  }),
+  strict: true
+};
+var editTool = {
+  name: "FileEdit",
+  description: `Edit specific sections of a file by replacing text.
+
+Usage:
+- Provide the exact text to find and replace
+- The old_string must match exactly (whitespace-sensitive)
+- By default, only replaces the first occurrence
+- Use replace_all: true to replace all occurrences
+
+IMPORTANT:
+- You must read the file first (in this session) before editing it
+- old_string must be unique in the file (unless using replace_all)
+- The operation fails if old_string is not found
+- old_string and new_string must be different
+`,
+  schema: z.object({
+    file_path: z.string().describe("The absolute virtual path to the file to modify"),
+    old_string: z.string().describe("The exact text to replace"),
+    new_string: z.string().describe(
+      "The text to replace it with (must be different from old_string)"
+    ),
+    replace_all: z.boolean().optional().describe(
+      "If true, replace all occurrences of old_string (default: false)"
+    )
+  }),
+  strict: true
+};
+
+// src/lib/filesystem/types.ts
+function fileContentToMessageContent(content) {
+  switch (content.type) {
+    case "text":
+      return [{ type: "text", text: content.content }];
+    case "image":
+      return [
+        {
+          type: "image_url",
+          image_url: {
+            url: `data:${content.mimeType};base64,${content.data}`
+          }
+        }
+      ];
+    case "pdf":
+      return [{ type: "text", text: content.content }];
+  }
+}
+var DEFAULT_HEADER = "Available files and directories:";
+var DEFAULT_DESCRIPTION = "You have access to the following files. Use the Read, Glob, and Grep tools to explore them.";
+function isExcluded(path, excludePatterns) {
+  if (!excludePatterns || excludePatterns.length === 0) {
+    return false;
+  }
+  return excludePatterns.some((pattern) => minimatch(path, pattern));
+}
+function renderNode(node, options, depth, indent) {
+  const lines = [];
+  if (options.maxDepth !== void 0 && depth > options.maxDepth) {
+    return lines;
+  }
+  if (isExcluded(node.path, options.excludePatterns)) {
+    return lines;
+  }
+  const parts = node.path.split("/");
+  const name = parts[parts.length - 1] || node.path;
+  let line = indent;
+  if (node.type === "directory") {
+    line += `${name}/`;
+  } else {
+    line += name;
+  }
+  if (options.showMimeTypes && node.mimeType) {
+    line += ` [${node.mimeType}]`;
+  }
+  if (options.showDescriptions !== false && node.description) {
+    line += ` - ${node.description}`;
+  }
+  lines.push(line);
+  if (node.type === "directory" && node.children) {
+    const childIndent = indent + "  ";
+    for (const child of node.children) {
+      lines.push(...renderNode(child, options, depth + 1, childIndent));
+    }
+  }
+  return lines;
+}
+function buildFileTreePrompt(nodes, options = {}) {
+  const header = options.headerText ?? DEFAULT_HEADER;
+  const description = options.descriptionText ?? DEFAULT_DESCRIPTION;
+  const lines = [];
+  for (const node of nodes) {
+    lines.push(...renderNode(node, options, 0, ""));
+  }
+  if (lines.length === 0) {
+    return `<file_system>
+${header}
+
+${description}
+
+(no files available)
+</file_system>`;
+  }
+  return `<file_system>
+${header}
+
+${lines.join("\n")}
+</file_system>`;
+}
+function flattenFileTree(nodes) {
+  const paths = [];
+  function traverse(node) {
+    if (node.type === "file") {
+      paths.push(node.path);
+    }
+    if (node.children) {
+      for (const child of node.children) {
+        traverse(child);
+      }
+    }
+  }
+  for (const node of nodes) {
+    traverse(node);
+  }
+  return paths;
+}
+function isPathInScope(path, scopedNodes) {
+  const allowedPaths = flattenFileTree(scopedNodes);
+  return allowedPaths.includes(path);
+}
+function findNodeByPath(path, nodes) {
+  for (const node of nodes) {
+    if (node.path === path) {
+      return node;
+    }
+    if (node.children) {
+      const found = findNodeByPath(path, node.children);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return void 0;
+}
+var BaseFileSystemProvider = class {
+  scopedNodes;
+  allowedPaths;
+  constructor(scopedNodes) {
+    this.scopedNodes = scopedNodes;
+    this.allowedPaths = new Set(flattenFileTree(scopedNodes));
+  }
+  /**
+   * Validate that a path is within the allowed scope.
+   * Throws an error if the path is not allowed.
+   */
+  validatePath(path) {
+    if (!this.allowedPaths.has(path)) {
+      throw new Error(`Path "${path}" is not within the allowed scope`);
+    }
+  }
+  /**
+   * Filter paths by glob pattern.
+   */
+  filterByPattern(paths, pattern, root) {
+    const effectivePattern = root ? `${root}/${pattern}` : pattern;
+    return paths.filter((path) => {
+      if (root && !path.startsWith(root)) {
+        return false;
+      }
+      return minimatch(path, effectivePattern, { matchBase: true });
+    });
+  }
+  /**
+   * Get all file paths in scope
+   */
+  getAllPaths() {
+    return Array.from(this.allowedPaths);
+  }
+  /**
+   * Find FileNode by path
+   */
+  findNode(path) {
+    const findInNodes = (nodes) => {
+      for (const node of nodes) {
+        if (node.path === path) {
+          return node;
+        }
+        if (node.children) {
+          const found = findInNodes(node.children);
+          if (found) return found;
+        }
+      }
+      return void 0;
+    };
+    return findInNodes(this.scopedNodes);
+  }
+  /**
+   * Read file as text for grep operations.
+   * Default implementation uses readFile, but can be overridden for efficiency.
+   */
+  async readFileAsText(node) {
+    try {
+      const content = await this.readFile(node);
+      if (content.type === "text") {
+        return content.content;
+      }
+      if (content.type === "pdf") {
+        return content.content;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  // ============================================================================
+  // FileSystemProvider implementation
+  // ============================================================================
+  async glob(pattern, root) {
+    const allPaths = this.getAllPaths();
+    const matchingPaths = this.filterByPattern(allPaths, pattern, root);
+    return matchingPaths.map((path) => this.findNode(path)).filter((node) => node !== void 0);
+  }
+  async grep(pattern, options) {
+    const matches = [];
+    const maxMatches = options?.maxMatches ?? 50;
+    const flags = options?.ignoreCase ? "gi" : "g";
+    let regex;
+    try {
+      regex = new RegExp(pattern, flags);
+    } catch {
+      throw new Error(`Invalid regex pattern: ${pattern}`);
+    }
+    let paths = this.getAllPaths();
+    if (options?.includePatterns?.length) {
+      const includePatterns = options.includePatterns;
+      paths = paths.filter(
+        (path) => includePatterns.some((p) => minimatch(path, p, { matchBase: true }))
+      );
+    }
+    if (options?.excludePatterns?.length) {
+      const excludePatterns = options.excludePatterns;
+      paths = paths.filter(
+        (path) => !excludePatterns.some((p) => minimatch(path, p, { matchBase: true }))
+      );
+    }
+    for (const path of paths) {
+      if (matches.length >= maxMatches) break;
+      const node = this.findNode(path);
+      if (!node || node.type !== "file") continue;
+      const text = await this.readFileAsText(node);
+      if (!text) continue;
+      const lines = text.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (matches.length >= maxMatches) break;
+        const line = lines[i];
+        if (line === void 0) continue;
+        if (regex.test(line)) {
+          regex.lastIndex = 0;
+          const match = {
+            path,
+            lineNumber: i + 1,
+            line: line.trim()
+          };
+          if (options?.contextLines && options.contextLines > 0) {
+            const contextBefore = [];
+            const contextAfter = [];
+            for (let j = Math.max(0, i - options.contextLines); j < i; j++) {
+              const contextLine = lines[j];
+              if (contextLine !== void 0) {
+                contextBefore.push(contextLine.trim());
+              }
+            }
+            for (let j = i + 1; j <= Math.min(lines.length - 1, i + options.contextLines); j++) {
+              const contextLine = lines[j];
+              if (contextLine !== void 0) {
+                contextAfter.push(contextLine.trim());
+              }
+            }
+            match.contextBefore = contextBefore;
+            match.contextAfter = contextAfter;
+          }
+          matches.push(match);
+        }
+      }
+    }
+    return matches;
+  }
+  async read(path) {
+    this.validatePath(path);
+    const node = this.findNode(path);
+    if (!node) {
+      throw new Error(`File not found: ${path}`);
+    }
+    if (node.type !== "file") {
+      throw new Error(`Path is a directory, not a file: ${path}`);
+    }
+    return this.readFile(node);
+  }
+  async exists(path) {
+    return this.allowedPaths.has(path);
+  }
+};
+var InMemoryFileSystemProvider = class _InMemoryFileSystemProvider extends BaseFileSystemProvider {
+  files;
+  constructor(scopedNodes, files) {
+    super(scopedNodes);
+    this.files = files;
+  }
+  async readFile(node) {
+    const content = this.files.get(node.path);
+    if (!content) {
+      throw new Error(`File not found in storage: ${node.path}`);
+    }
+    return content;
+  }
+  /**
+   * Add or update a file in the in-memory storage
+   */
+  setFile(path, content) {
+    this.files.set(path, content);
+  }
+  /**
+   * Write text content to a file
+   */
+  async write(path, content) {
+    this.validatePath(path);
+    this.files.set(path, { type: "text", content });
+  }
+  /**
+   * Create an InMemoryFileSystemProvider from a simple object map
+   */
+  static fromTextFiles(scopedNodes, files) {
+    const fileMap = /* @__PURE__ */ new Map();
+    for (const [path, content] of Object.entries(files)) {
+      fileMap.set(path, { type: "text", content });
+    }
+    return new _InMemoryFileSystemProvider(scopedNodes, fileMap);
+  }
+};
+var CompositeFileSystemProvider = class extends BaseFileSystemProvider {
+  backends;
+  defaultBackend;
+  defaultResolver;
+  constructor(scopedNodes, config) {
+    super(scopedNodes);
+    this.backends = new Map(Object.entries(config.backends));
+    this.defaultBackend = config.defaultBackend;
+    this.defaultResolver = config.defaultResolver;
+  }
+  /**
+   * Get the backend name for a file node
+   */
+  getBackendName(node) {
+    const backend = node.metadata?.backend;
+    if (typeof backend === "string") {
+      return backend;
+    }
+    return this.defaultBackend;
+  }
+  /**
+   * Resolve content using a resolver (function or provider)
+   */
+  async resolveContent(resolver, node) {
+    if (typeof resolver === "function") {
+      return resolver(node);
+    }
+    return resolver.read(node.path);
+  }
+  async readFile(node) {
+    const backendName = this.getBackendName(node);
+    if (backendName) {
+      const config = this.backends.get(backendName);
+      if (config) {
+        return this.resolveContent(config.resolver, node);
+      }
+    }
+    if (this.defaultResolver) {
+      return this.defaultResolver(node);
+    }
+    const availableBackends = Array.from(this.backends.keys()).join(", ");
+    throw new Error(
+      `No resolver for file "${node.path}". Backend: ${backendName ?? "(none)"}. Available backends: ${availableBackends || "(none)"}`
+    );
+  }
+  /**
+   * Add or update a backend configuration
+   */
+  setBackend(name, config) {
+    this.backends.set(name, config);
+  }
+  /**
+   * Remove a backend
+   */
+  removeBackend(name) {
+    return this.backends.delete(name);
+  }
+  /**
+   * Check if a backend exists
+   */
+  hasBackend(name) {
+    return this.backends.has(name);
+  }
+};
+
+// node_modules/uuid/dist/esm-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+var native_default = {
+  randomUUID: crypto.randomUUID
+};
+
+// node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/lib/thread-manager.ts
+var THREAD_TTL_SECONDS = 60 * 60 * 24 * 90;
+function getThreadKey(threadId, key) {
+  return `thread:${threadId}:${key}`;
+}
+function createThreadManager(config) {
+  const { redis, threadId, key = "messages" } = config;
+  const redisKey = getThreadKey(threadId, key);
+  return {
+    async initialize() {
+      await redis.del(redisKey);
+    },
+    async load() {
+      const data = await redis.lrange(redisKey, 0, -1);
+      return data.map((item) => JSON.parse(item));
+    },
+    async append(messages) {
+      if (messages.length > 0) {
+        await redis.rpush(redisKey, ...messages.map((m) => JSON.stringify(m)));
+        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+      }
+    },
+    async delete() {
+      await redis.del(redisKey);
+    },
+    createHumanMessage(content) {
+      return new HumanMessage({
+        id: v4_default(),
+        content
+      }).toDict();
+    },
+    createAIMessage(content, kwargs) {
+      return new AIMessage({
+        id: v4_default(),
+        content,
+        additional_kwargs: kwargs ? {
+          header: kwargs.header,
+          options: kwargs.options,
+          multiSelect: kwargs.multiSelect
+        } : void 0
+      }).toDict();
+    },
+    createToolMessage(content, toolCallId) {
+      return new ToolMessage({
+        // Cast needed due to langchain type compatibility
+        content,
+        tool_call_id: toolCallId
+      }).toDict();
+    },
+    async appendHumanMessage(content) {
+      const message = this.createHumanMessage(content);
+      await this.append([message]);
+    },
+    async appendToolMessage(content, toolCallId) {
+      const message = this.createToolMessage(content, toolCallId);
+      await this.append([message]);
+    },
+    async appendAIMessage(content) {
+      const message = this.createAIMessage(content);
+      await this.append([message]);
+    }
+  };
+}
+function createSharedActivities(redis) {
+  return {
+    async appendToolResult(config) {
+      const { threadId, toolCallId, content } = config;
+      const thread = createThreadManager({ redis, threadId });
+      await thread.appendToolMessage(content, toolCallId);
+    },
+    async initializeThread(threadId) {
+      const thread = createThreadManager({ redis, threadId });
+      await thread.initialize();
+    },
+    async appendThreadMessages(threadId, messages) {
+      const thread = createThreadManager({ redis, threadId });
+      await thread.append(messages);
+    },
+    async appendHumanMessage(threadId, content) {
+      const thread = createThreadManager({ redis, threadId });
+      await thread.appendHumanMessage(content);
+    },
+    async parseToolCalls(storedMessage) {
+      const message = mapStoredMessageToChatMessage(storedMessage);
+      const toolCalls = message.tool_calls ?? [];
+      return toolCalls.map((toolCall) => ({
+        id: toolCall.id,
+        name: toolCall.name,
+        args: toolCall.args
+      }));
+    }
+  };
+}
+
+// src/plugin.ts
+var ZeitlichPlugin = class extends SimplePlugin {
+  constructor(options) {
+    super({
+      name: "ZeitlichPlugin",
+      activities: createSharedActivities(options.redis)
+    });
+  }
+};
+async function invokeModel(redis, { threadId, agentName, tools }, model, { systemPrompt }) {
+  const thread = createThreadManager({ redis, threadId });
+  const runId = v4_default();
+  const messages = await thread.load();
+  const response = await model.invoke(
+    [
+      new SystemMessage(systemPrompt),
+      ...mapStoredMessagesToChatMessages(messages)
+    ],
+    {
+      runName: agentName,
+      runId,
+      metadata: { thread_id: threadId },
+      tools
+    }
+  );
+  await thread.append([response.toDict()]);
+  return {
+    message: response.toDict(),
+    stopReason: response.response_metadata?.stop_reason ?? null,
+    usage: {
+      input_tokens: response.usage_metadata?.input_tokens,
+      output_tokens: response.usage_metadata?.output_tokens,
+      total_tokens: response.usage_metadata?.total_tokens
+    }
+  };
+}
+var handleAskUserQuestionToolResult = async (args) => {
+  const messages = args.questions.map(
+    ({ question, header, options, multiSelect }) => new AIMessage({
+      content: question,
+      additional_kwargs: {
+        header,
+        options,
+        multiSelect
+      }
+    }).toDict()
+  );
+  return { content: "Question submitted", result: { chatMessages: messages } };
+};
+
+// src/tools/glob/handler.ts
+function createGlobHandler(config) {
+  return async (args) => {
+    const { pattern, root } = args;
+    try {
+      const matches = await config.provider.glob(pattern, root);
+      if (matches.length === 0) {
+        return {
+          content: `No files found matching pattern: ${pattern}`,
+          result: { files: [] }
+        };
+      }
+      const paths = matches.map((node) => node.path);
+      const fileList = paths.map((p) => `  ${p}`).join("\n");
+      return {
+        content: `Found ${matches.length} file(s) matching "${pattern}":
+${fileList}`,
+        result: { files: matches }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: `Error searching for files: ${message}`,
+        result: { files: [] }
+      };
+    }
+  };
+}
+
+// src/tools/grep/handler.ts
+function formatMatch(match, showContext) {
+  const lines = [];
+  if (showContext && match.contextBefore?.length) {
+    for (let i = 0; i < match.contextBefore.length; i++) {
+      const lineNum = match.lineNumber - match.contextBefore.length + i;
+      lines.push(`${match.path}:${lineNum}-${match.contextBefore[i]}`);
+    }
+  }
+  lines.push(`${match.path}:${match.lineNumber}:${match.line}`);
+  if (showContext && match.contextAfter?.length) {
+    for (let i = 0; i < match.contextAfter.length; i++) {
+      const lineNum = match.lineNumber + 1 + i;
+      lines.push(`${match.path}:${lineNum}-${match.contextAfter[i]}`);
+    }
+  }
+  return lines.join("\n");
+}
+function createGrepHandler(config) {
+  return async (args) => {
+    const {
+      pattern,
+      ignoreCase,
+      maxMatches,
+      includePatterns,
+      excludePatterns,
+      contextLines
+    } = args;
+    try {
+      const matches = await config.provider.grep(pattern, {
+        ignoreCase,
+        maxMatches: maxMatches ?? 50,
+        includePatterns,
+        excludePatterns,
+        contextLines
+      });
+      if (matches.length === 0) {
+        return {
+          content: `No matches found for pattern: ${pattern}`,
+          result: { matches: [] }
+        };
+      }
+      const showContext = contextLines !== void 0 && contextLines > 0;
+      const formattedMatches = matches.map((m) => formatMatch(m, showContext)).join("\n");
+      return {
+        content: `Found ${matches.length} match(es) for "${pattern}":
+
+${formattedMatches}`,
+        result: { matches }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: `Error searching file contents: ${message}`,
+        result: { matches: [] }
+      };
+    }
+  };
+}
+
+// src/tools/read/handler.ts
+function applyTextRange(content, offset, limit) {
+  if (offset === void 0 && limit === void 0) {
+    return content;
+  }
+  const lines = content.split("\n");
+  const startLine = offset !== void 0 ? Math.max(0, offset - 1) : 0;
+  const endLine = limit !== void 0 ? startLine + limit : lines.length;
+  const selectedLines = lines.slice(startLine, endLine);
+  return selectedLines.map((line, i) => {
+    const lineNum = (startLine + i + 1).toString().padStart(6, " ");
+    return `${lineNum}|${line}`;
+  }).join("\n");
+}
+function createReadHandler(config) {
+  return async (args) => {
+    const { path, offset, limit } = args;
+    if (!isPathInScope(path, config.scopedNodes)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Path "${path}" is not within the available file system scope.`
+          }
+        ],
+        result: {
+          path,
+          content: {
+            type: "text",
+            content: "Error: Path is not within the available file system scope."
+          }
+        }
+      };
+    }
+    try {
+      const exists = await config.provider.exists(path);
+      if (!exists) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: File "${path}" does not exist.`
+            }
+          ],
+          result: {
+            path,
+            content: { type: "text", content: "Error: File does not exist." }
+          }
+        };
+      }
+      const fileContent = await config.provider.read(path);
+      if (fileContent.type === "text") {
+        const processedContent = applyTextRange(
+          fileContent.content,
+          offset,
+          limit
+        );
+        let header = `File: ${path}`;
+        if (offset !== void 0 || limit !== void 0) {
+          const startLine = offset ?? 1;
+          const endInfo = limit ? `, showing ${limit} lines` : "";
+          header += ` (from line ${startLine}${endInfo})`;
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${header}
+
+${processedContent}`
+            }
+          ],
+          result: {
+            path,
+            content: {
+              type: "text",
+              content: `${header}
+
+${processedContent}`
+            }
+          }
+        };
+      }
+      const messageContent = fileContentToMessageContent(fileContent);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `File: ${path} (${fileContent.type})`
+          },
+          ...messageContent
+        ],
+        result: { path, content: fileContent }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error reading file "${path}": ${message}`
+          }
+        ],
+        result: {
+          path,
+          content: {
+            type: "text",
+            content: `Error reading file "${path}": ${message}`
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/tools/write/handler.ts
+function createWriteHandler(config) {
+  return async (args) => {
+    const { file_path, content } = args;
+    if (!isPathInScope(file_path, config.scopedNodes)) {
+      return {
+        content: `Error: Path "${file_path}" is not within the available file system scope.`,
+        result: {
+          path: file_path,
+          success: false,
+          created: false,
+          bytesWritten: 0
+        }
+      };
+    }
+    if (!config.skipReadCheck && !config.readFiles.has(file_path)) {
+      const exists = await config.provider.exists(file_path);
+      if (exists) {
+        return {
+          content: `Error: You must read "${file_path}" before writing to it. Use FileRead first.`,
+          result: {
+            path: file_path,
+            success: false,
+            created: false,
+            bytesWritten: 0
+          }
+        };
+      }
+    }
+    try {
+      const exists = await config.provider.exists(file_path);
+      if (!config.provider.write) {
+        return {
+          content: `Error: The file system provider does not support write operations.`,
+          result: {
+            path: file_path,
+            success: false,
+            created: false,
+            bytesWritten: 0
+          }
+        };
+      }
+      await config.provider.write(file_path, content);
+      const bytesWritten = Buffer.byteLength(content, "utf-8");
+      const action = exists ? "Updated" : "Created";
+      return {
+        content: `${action} file: ${file_path} (${bytesWritten} bytes)`,
+        result: {
+          path: file_path,
+          success: true,
+          created: !exists,
+          bytesWritten
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: `Error writing file "${file_path}": ${message}`,
+        result: {
+          path: file_path,
+          success: false,
+          created: false,
+          bytesWritten: 0
+        }
+      };
+    }
+  };
+}
+
+// src/tools/edit/handler.ts
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createEditHandler(config) {
+  return async (args) => {
+    const { file_path, old_string, new_string, replace_all = false } = args;
+    if (old_string === new_string) {
+      return {
+        content: `Error: old_string and new_string must be different.`,
+        result: {
+          path: file_path,
+          success: false,
+          replacements: 0
+        }
+      };
+    }
+    if (!isPathInScope(file_path, config.scopedNodes)) {
+      return {
+        content: `Error: Path "${file_path}" is not within the available file system scope.`,
+        result: {
+          path: file_path,
+          success: false,
+          replacements: 0
+        }
+      };
+    }
+    if (!config.skipReadCheck && !config.readFiles.has(file_path)) {
+      return {
+        content: `Error: You must read "${file_path}" before editing it. Use FileRead first.`,
+        result: {
+          path: file_path,
+          success: false,
+          replacements: 0
+        }
+      };
+    }
+    try {
+      const exists = await config.provider.exists(file_path);
+      if (!exists) {
+        return {
+          content: `Error: File "${file_path}" does not exist.`,
+          result: {
+            path: file_path,
+            success: false,
+            replacements: 0
+          }
+        };
+      }
+      if (!config.provider.write) {
+        return {
+          content: `Error: The file system provider does not support write operations.`,
+          result: {
+            path: file_path,
+            success: false,
+            replacements: 0
+          }
+        };
+      }
+      const fileContent = await config.provider.read(file_path);
+      if (fileContent.type !== "text") {
+        return {
+          content: `Error: FileEdit only works with text files. "${file_path}" is ${fileContent.type}.`,
+          result: {
+            path: file_path,
+            success: false,
+            replacements: 0
+          }
+        };
+      }
+      const content = fileContent.content;
+      if (!content.includes(old_string)) {
+        return {
+          content: `Error: Could not find the specified text in "${file_path}". Make sure old_string matches exactly (whitespace-sensitive).`,
+          result: {
+            path: file_path,
+            success: false,
+            replacements: 0
+          }
+        };
+      }
+      const escapedOldString = escapeRegExp(old_string);
+      const globalRegex = new RegExp(escapedOldString, "g");
+      const occurrences = (content.match(globalRegex) || []).length;
+      if (!replace_all && occurrences > 1) {
+        return {
+          content: `Error: old_string appears ${occurrences} times in "${file_path}". Either provide more context to make it unique, or use replace_all: true.`,
+          result: {
+            path: file_path,
+            success: false,
+            replacements: 0
+          }
+        };
+      }
+      let newContent;
+      let replacements;
+      if (replace_all) {
+        newContent = content.split(old_string).join(new_string);
+        replacements = occurrences;
+      } else {
+        const index = content.indexOf(old_string);
+        newContent = content.slice(0, index) + new_string + content.slice(index + old_string.length);
+        replacements = 1;
+      }
+      await config.provider.write(file_path, newContent);
+      const summary = replace_all ? `Replaced ${replacements} occurrence(s)` : `Replaced 1 occurrence`;
+      return {
+        content: `${summary} in ${file_path}`,
+        result: {
+          path: file_path,
+          success: true,
+          replacements
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: `Error editing file "${file_path}": ${message}`,
+        result: {
+          path: file_path,
+          success: false,
+          replacements: 0
+        }
+      };
+    }
+  };
+}
+
+export { AGENT_HANDLER_NAMES, BaseFileSystemProvider, CompositeFileSystemProvider, InMemoryFileSystemProvider, ZeitlichPlugin, askUserQuestionTool, buildFileTreePrompt, createAgentStateManager, createEditHandler, createGlobHandler, createGrepHandler, createPromptManager, createReadHandler, createSession, createSharedActivities, createTaskHandler, createTaskTool, createToolRegistry, createToolRouter, createWriteHandler, editTool, fileContentToMessageContent, findNodeByPath, flattenFileTree, globTool, grepTool, handleAskUserQuestionToolResult, hasNoOtherToolCalls, hasTaskTool, invokeModel, isPathInScope, isTerminalStatus, readTool, withSubagentSupport, writeTool };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map