zeitlich 0.2.1 → 0.2.3

package/src/tools/edit/handler.ts

@@ -1,38 +1,16 @@
-import type { EditToolSchemaType } from "./tool";
+import type { ActivityToolHandler } from "../../lib/tool-router";
+import type { FileEditArgs } from "./tool";
 import type { IFileSystem } from "just-bash";
 
 /**
  * Result of an edit operation
  */
-export interface EditResult {
+interface EditResult {
   path: string;
   success: boolean;
   replacements: number;
 }
 
-/**
- * Edit handler response
- */
-export interface EditHandlerResponse {
-  content: string;
-  result: EditResult;
-}
-
-/**
- * Options for edit handler
- */
-export interface EditHandlerOptions {
-  /**
-   * Set of file paths that have been read in this session.
-   * Required for enforcing read-before-write policy.
-   */
-  readFiles: Set<string>;
-  /**
-   * If true, skip the read-before-write check (not recommended)
-   */
-  skipReadCheck?: boolean;
-}
-
 /**
  * Escape special regex characters in a string
  */
@@ -41,116 +19,93 @@ function escapeRegExp(str: string): string {
 }
 
 /**
- * Edit handler that edits files within the scoped file tree.
+ * Creates an edit handler that edits files within the scoped file tree.
  *
- * @param args - Tool arguments (file_path, old_string, new_string, replace_all)
- * @param options - Additional options (readFiles, skipReadCheck)
+ * @param fs - File system implementation for I/O operations
+ * @returns An ActivityToolHandler for edit tool calls
  */
-export async function editHandler(
-  args: EditToolSchemaType,
+export function createEditHandler(
   fs: IFileSystem
-): Promise<EditHandlerResponse> {
-  const { file_path, old_string, new_string, replace_all = false } = args;
-
-  // Validate old_string !== new_string
-  if (old_string === new_string) {
-    return {
-      content: `Error: old_string and new_string must be different.`,
-      result: {
-        path: file_path,
-        success: false,
-        replacements: 0,
-      },
-    };
-  }
+): ActivityToolHandler<FileEditArgs, EditResult> {
+  return async (args) => {
+    const { file_path, old_string, new_string, replace_all = false } = args;
 
-  try {
-    // Check if file exists
-    const exists = await fs.exists(file_path);
-    if (!exists) {
+    // Validate old_string !== new_string
+    if (old_string === new_string) {
       return {
-        content: `Error: File "${file_path}" does not exist.`,
-        result: {
-          path: file_path,
-          success: false,
-          replacements: 0,
-        },
+        toolResponse: `Error: old_string and new_string must be different.`,
+        data: { path: file_path, success: false, replacements: 0 },
       };
     }
 
-    // Read current content
-    const content = await fs.readFile(file_path);
+    try {
+      // Check if file exists
+      const exists = await fs.exists(file_path);
+      if (!exists) {
+        return {
+          toolResponse: `Error: File "${file_path}" does not exist.`,
+          data: { path: file_path, success: false, replacements: 0 },
+        };
+      }
+
+      // Read current content
+      const content = await fs.readFile(file_path);
+
+      // Check if old_string exists in the file
+      if (!content.includes(old_string)) {
+        return {
+          toolResponse: `Error: Could not find the specified text in "${file_path}". Make sure old_string matches exactly (whitespace-sensitive).`,
+          data: { path: file_path, success: false, replacements: 0 },
+        };
+      }
+
+      // Count occurrences
+      const escapedOldString = escapeRegExp(old_string);
+      const globalRegex = new RegExp(escapedOldString, "g");
+      const occurrences = (content.match(globalRegex) || []).length;
+
+      // Check uniqueness if not replace_all
+      if (!replace_all && occurrences > 1) {
+        return {
+          toolResponse: `Error: old_string appears ${occurrences} times in "${file_path}". Either provide more context to make it unique, or use replace_all: true.`,
+          data: { path: file_path, success: false, replacements: 0 },
+        };
+      }
+
+      // Perform replacement
+      let newContent: string;
+      let replacements: number;
+
+      if (replace_all) {
+        newContent = content.split(old_string).join(new_string);
+        replacements = occurrences;
+      } else {
+        // Replace only the first occurrence
+        const index = content.indexOf(old_string);
+        newContent =
+          content.slice(0, index) +
+          new_string +
+          content.slice(index + old_string.length);
+        replacements = 1;
+      }
+
+      // Write the modified content
+      await fs.writeFile(file_path, newContent);
+
+      const summary = replace_all
+        ? `Replaced ${replacements} occurrence(s)`
+        : `Replaced 1 occurrence`;
 
-    // Check if old_string exists in the file
-    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,
-        },
+        toolResponse: `${summary} in ${file_path}`,
+        data: { path: file_path, success: true, replacements },
       };
-    }
-
-    // Count occurrences
-    const escapedOldString = escapeRegExp(old_string);
-    const globalRegex = new RegExp(escapedOldString, "g");
-    const occurrences = (content.match(globalRegex) || []).length;
-
-    // Check uniqueness if not replace_all
-    if (!replace_all && occurrences > 1) {
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
       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,
-        },
+        toolResponse: `Error editing file "${file_path}": ${message}`,
+        data: { path: file_path, success: false, replacements: 0 },
       };
     }
-
-    // Perform replacement
-    let newContent: string;
-    let replacements: number;
-
-    if (replace_all) {
-      newContent = content.split(old_string).join(new_string);
-      replacements = occurrences;
-    } else {
-      // Replace only the first occurrence
-      const index = content.indexOf(old_string);
-      newContent =
-        content.slice(0, index) +
-        new_string +
-        content.slice(index + old_string.length);
-      replacements = 1;
-    }
-
-    // Write the modified content
-    await fs.writeFile(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,
-      },
-    };
-  }
+  };
 }

package/src/tools/edit/tool.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const editTool = {
   name: "FileEdit" as const,
@@ -34,6 +35,6 @@ IMPORTANT:
       ),
   }),
   strict: true,
-};
+} satisfies ToolDefinition;
 
-export type EditToolSchemaType = z.infer<typeof editTool.schema>;
+export type FileEditArgs = z.infer<typeof editTool.schema>;

package/src/tools/glob/handler.ts

@@ -1,62 +1,31 @@
+import type { ActivityToolHandler } from "../../lib/tool-router";
+import type { GlobArgs } from "./tool";
 import type { IFileSystem } from "just-bash";
 import { Bash } from "just-bash";
-import type { GlobToolSchemaType } from "./tool";
 
 /**
  * Result of a glob operation
  */
-export interface GlobResult {
+interface GlobResult {
   files: string[];
 }
 
 /**
- * Glob handler response
- */
-export interface GlobHandlerResponse {
-  content: string;
-  result: GlobResult;
-}
-
-/**
- * Glob handler that searches within the scoped file tree.
+ * Creates a glob handler that searches within the scoped file tree.
  *
- * @param args - Tool arguments (pattern, root)
- * @param provider - FileSystemProvider for I/O operations
+ * @param fs - File system implementation for I/O operations
+ * @returns An ActivityToolHandler for glob tool calls
  */
-export async function globHandler(
-  _args: GlobToolSchemaType,
+export function createGlobHandler(
   fs: IFileSystem
-): Promise<GlobHandlerResponse> {
-  // const { pattern, root } = args;
-  const _bash = new Bash({ fs });
-
-  return Promise.resolve({
-    content: "Hello, world!",
-    result: { files: [] },
-  });
-
-  // try {
-  //   const matches = await bash.exec(`glob ${root} -name "${pattern}"`);
-
-  //   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}":\n${fileList}`,
-  //     result: { files: matches },
-  //   };
-  // } catch (error) {
-  //   const message = error instanceof Error ? error.message : "Unknown error";
-  //   return {
-  //     content: `Error searching for files: ${message}`,
-  //     result: { files: [] },
-  //   };
-  // }
+): ActivityToolHandler<GlobArgs, GlobResult> {
+  return async (_args) => {
+    // const { pattern, root } = args;
+    const _bash = new Bash({ fs });
+
+    return {
+      toolResponse: "Hello, world!",
+      data: { files: [] },
+    };
+  };
 }

package/src/tools/glob/tool.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const globTool = {
   name: "Glob" as const,
@@ -22,6 +23,6 @@ Examples:
       .describe("Optional root directory to search from"),
   }),
   strict: true,
-};
+} satisfies ToolDefinition;
 
-export type GlobToolSchemaType = z.infer<typeof globTool.schema>;
+export type GlobArgs = z.infer<typeof globTool.schema>;

package/src/tools/grep/tool.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const grepTool = {
   name: "Grep" as const,
@@ -40,6 +41,6 @@ Examples:
       .describe("Number of context lines to show around matches"),
   }),
   strict: true,
-};
+} satisfies ToolDefinition;
 
-export type GrepToolSchemaType = z.infer<typeof grepTool.schema>;
+export type GrepArgs = z.infer<typeof grepTool.schema>;

package/src/tools/{read → read-file}/tool.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const readTool = {
   name: "FileRead" as const,
@@ -28,6 +29,6 @@ The tool returns the file content in an appropriate format:
       .describe("Maximum number of lines to read (for text files)"),
   }),
   strict: true,
-};
+} satisfies ToolDefinition;
 
-export type ReadToolSchemaType = z.infer<typeof readTool.schema>;
+export type FileReadArgs = z.infer<typeof readTool.schema>;

package/src/tools/task/handler.ts

@@ -1,7 +1,7 @@
 import { executeChild, workflowInfo, uuid4 } from "@temporalio/workflow";
 import type { ToolHandlerResponse } from "../../lib/tool-router";
 import type { SubagentConfig, SubagentInput } from "../../lib/types";
-import type { GenericTaskToolSchemaType } from "./tool";
+import type { TaskArgs } from "./tool";
 
 /**
  * Result from a task handler execution
@@ -24,7 +24,7 @@ export interface TaskHandlerResult<TResult = unknown> {
  *   {
  *     name: "researcher",
  *     description: "Researches topics",
- *     workflowType: "researcherWorkflow",
+ *     workflow: "researcherWorkflow",
  *     resultSchema: z.object({ findings: z.string() }),
  *   },
  * ]);
@@ -34,7 +34,7 @@ export function createTaskHandler(subagents: SubagentConfig[]) {
     workflowInfo();
 
   return async (
-    args: GenericTaskToolSchemaType
+    args: TaskArgs
   ): Promise<ToolHandlerResponse<TaskHandlerResult>> => {
     const config = subagents.find((s) => s.name === args.subagent);
 
@@ -47,11 +47,21 @@ export function createTaskHandler(subagents: SubagentConfig[]) {
     const childWorkflowId = `${parentWorkflowId}-${args.subagent}-${uuid4()}`;
 
     // Execute the child workflow
-    const childResult = await executeChild(config.workflowType, {
+    const input: SubagentInput = {
+      prompt: args.prompt,
+      ...(config.context && { context: config.context }),
+    };
+
+    const childOpts = {
       workflowId: childWorkflowId,
-      args: [{ prompt: args.prompt } satisfies SubagentInput],
+      args: [input],
       taskQueue: config.taskQueue ?? parentTaskQueue,
-    });
+    };
+
+    const childResult =
+      typeof config.workflow === "string"
+        ? await executeChild(config.workflow, childOpts)
+        : await executeChild(config.workflow, childOpts);
 
     // Validate result if schema provided, otherwise pass through as-is
     const validated = config.resultSchema
@@ -59,14 +69,14 @@ export function createTaskHandler(subagents: SubagentConfig[]) {
       : childResult;
 
     // Format content - stringify objects, pass strings through
-    const content =
+    const toolResponse =
       typeof validated === "string"
         ? validated
         : JSON.stringify(validated, null, 2);
 
     return {
-      content,
-      result: {
+      toolResponse,
+      data: {
         result: validated,
         childWorkflowId,
       },

package/src/tools/task/tool.ts

@@ -44,7 +44,7 @@ Usage notes:
  *   {
  *     name: "researcher",
  *     description: "Researches topics and gathers information",
- *     workflowType: "researcherWorkflow",
+ *     workflow: "researcherWorkflow",
  *     resultSchema: z.object({ findings: z.string() }),
  *   },
  * ]);
@@ -80,16 +80,9 @@ export function createTaskTool<T extends SubagentConfig[]>(
 }
 
 /**
- * Infer the schema type for a task tool created with specific subagents
+ * Task tool args type (when subagent names are not known at compile time)
  */
-export type TaskToolSchemaType<T extends SubagentConfig[]> = z.infer<
-  ReturnType<typeof createTaskTool<T>>["schema"]
->;
-
-/**
- * Generic task tool schema type (when subagent names are not known at compile time)
- */
-export type GenericTaskToolSchemaType = {
+export type TaskArgs = {
   subagent: string;
   description: string;
   prompt: string;

package/src/tools/task-create/handler.ts

@@ -2,34 +2,25 @@ import type {
   AgentStateManager,
   JsonSerializable,
 } from "../../lib/state-manager";
-import type { ToolHandlerResponse } from "../../lib/tool-router";
+import type { ToolHandler } from "../../lib/tool-router";
 import type { WorkflowTask } from "../../lib/types";
-import type { TaskCreateToolSchemaType } from "./tool";
+import type { TaskCreateArgs } from "./tool";
+import { uuid4 } from "@temporalio/workflow";
 
 /**
  * Creates a TaskCreate handler that adds tasks to the workflow state.
  *
  * @param stateManager - State manager containing tasks state
- * @param idGenerator - Function to generate unique task IDs (e.g., uuid4 from Temporal)
- * @returns A tool handler function
- *
- * @example
- * const handler = createTaskCreateHandler(stateManager, uuid4);
+ * @returns A ToolHandler for TaskCreate tool calls
  */
 export function createTaskCreateHandler<
   TCustom extends JsonSerializable<TCustom>,
->({
-  stateManager,
-  idGenerator,
-}: {
-  stateManager: AgentStateManager<TCustom>;
-  idGenerator: () => string;
-}): (args: TaskCreateToolSchemaType) => ToolHandlerResponse<WorkflowTask> {
-  return (
-    args: TaskCreateToolSchemaType
-  ): ToolHandlerResponse<WorkflowTask> => {
+>(
+  stateManager: AgentStateManager<TCustom>
+): ToolHandler<TaskCreateArgs, WorkflowTask> {
+  return (args) => {
     const task: WorkflowTask = {
-      id: idGenerator(),
+      id: uuid4(),
       subject: args.subject,
       description: args.description,
       activeForm: args.activeForm,
@@ -42,8 +33,8 @@ export function createTaskCreateHandler<
     stateManager.setTask(task);
 
     return {
-      content: JSON.stringify(task, null, 2),
-      result: task,
+      toolResponse: JSON.stringify(task, null, 2),
+      data: task,
     };
   };
 }

package/src/tools/task-create/tool.ts

@@ -1,4 +1,5 @@
 import z from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const taskCreateTool = {
   name: "TaskCreate" as const,
@@ -61,6 +62,6 @@ export const taskCreateTool = {
       .record(z.string(), z.string())
       .describe("Arbitrary key-value pairs for tracking"),
   }),
-};
+} satisfies ToolDefinition;
 
-export type TaskCreateToolSchemaType = z.infer<typeof taskCreateTool.schema>;
+export type TaskCreateArgs = z.infer<typeof taskCreateTool.schema>;

package/src/tools/task-get/handler.ts

@@ -2,37 +2,32 @@ import type {
   AgentStateManager,
   JsonSerializable,
 } from "../../lib/state-manager";
-import type { ToolHandlerResponse } from "../../lib/tool-router";
+import type { ToolHandler } from "../../lib/tool-router";
 import type { WorkflowTask } from "../../lib/types";
-import type { TaskGetToolSchemaType } from "./tool";
+import type { TaskGetArgs } from "./tool";
 
 /**
  * Creates a TaskGet handler that retrieves a task by ID.
  *
  * @param stateManager - State manager containing tasks state
- * @returns A tool handler function
- *
- * @example
- * const handler = createTaskGetHandler(stateManager);
+ * @returns A ToolHandler for TaskGet tool calls
  */
 export function createTaskGetHandler<TCustom extends JsonSerializable<TCustom>>(
   stateManager: AgentStateManager<TCustom>
-): (args: TaskGetToolSchemaType) => ToolHandlerResponse<WorkflowTask | null> {
-  return (
-    args: TaskGetToolSchemaType
-  ): ToolHandlerResponse<WorkflowTask | null> => {
+): ToolHandler<TaskGetArgs, WorkflowTask | null> {
+  return (args) => {
     const task = stateManager.getTask(args.taskId) ?? null;
 
     if (!task) {
       return {
-        content: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
-        result: null,
+        toolResponse: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
+        data: null,
       };
     }
 
     return {
-      content: JSON.stringify(task, null, 2),
-      result: task,
+      toolResponse: JSON.stringify(task, null, 2),
+      data: task,
     };
   };
 }

package/src/tools/task-get/tool.ts

@@ -1,4 +1,5 @@
 import z from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const taskGetTool = {
   name: "TaskGet" as const,
@@ -6,6 +7,6 @@ export const taskGetTool = {
   schema: z.object({
     taskId: z.string().describe("The ID of the task to get"),
   }),
-};
+} satisfies ToolDefinition;
 
-export type TaskGetToolSchemaType = z.infer<typeof taskGetTool.schema>;
+export type TaskGetArgs = z.infer<typeof taskGetTool.schema>;

package/src/tools/task-list/handler.ts

@@ -2,32 +2,27 @@ import type {
   AgentStateManager,
   JsonSerializable,
 } from "../../lib/state-manager";
-import type { ToolHandlerResponse } from "../../lib/tool-router";
+import type { ToolHandler } from "../../lib/tool-router";
 import type { WorkflowTask } from "../../lib/types";
-import type { TaskListToolSchemaType } from "./tool";
+import type { TaskListArgs } from "./tool";
 
 /**
  * Creates a TaskList handler that returns all tasks.
  *
  * @param stateManager - State manager containing tasks state
- * @returns A tool handler function
- *
- * @example
- * const handler = createTaskListHandler(stateManager);
+ * @returns A ToolHandler for TaskList tool calls
  */
 export function createTaskListHandler<
   TCustom extends JsonSerializable<TCustom>,
 >(
   stateManager: AgentStateManager<TCustom>
-): (args: TaskListToolSchemaType) => ToolHandlerResponse<WorkflowTask[]> {
-  return (
-    _args: TaskListToolSchemaType
-  ): ToolHandlerResponse<WorkflowTask[]> => {
+): ToolHandler<TaskListArgs, WorkflowTask[]> {
+  return () => {
     const taskList = stateManager.getTasks();
 
     return {
-      content: JSON.stringify(taskList, null, 2),
-      result: taskList,
+      toolResponse: JSON.stringify(taskList, null, 2),
+      data: taskList,
     };
   };
 }

package/src/tools/task-list/tool.ts

@@ -1,9 +1,10 @@
 import z from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const taskListTool = {
   name: "TaskList" as const,
   description: `List all tasks with current state.`,
   schema: z.object({}),
-};
+} satisfies ToolDefinition;
 
-export type TaskListToolSchemaType = z.infer<typeof taskListTool.schema>;
+export type TaskListArgs = z.infer<typeof taskListTool.schema>;