zeitlich 0.2.0 → 0.2.2

package/src/tools/bash/bash.test.ts

@@ -10,95 +10,95 @@ describe("bash with default options", () => {
   const fs = new OverlayFs({ root: __dirname, mountPoint: "/home/user" });
 
   it("executes echo and captures stdout", async () => {
-    const { result } = await handleBashTool(fs)(
+    const { data } = await handleBashTool({fs})(
       { command: "echo 'hello world'" },
       {}
     );
-    expect(result).not.toBeNull();
-    expect(result?.stdout.trim()).toBe("hello world");
-    expect(result?.exitCode).toBe(0);
+    expect(data).not.toBeNull();
+    expect(data?.stdout.trim()).toBe("hello world");
+    expect(data?.exitCode).toBe(0);
   });
 
   it("returns exit code 0 for successful commands", async () => {
-    const { result } = await handleBashTool(fs)({ command: "true" }, {});
-    expect(result?.exitCode).toBe(0);
+    const { data } = await handleBashTool({fs})({ command: "true" }, {});
+    expect(data?.exitCode).toBe(0);
   });
 
   it("returns non-zero exit code for failed commands", async () => {
-    const { result } = await handleBashTool(fs)({ command: "false" }, {});
-    expect(result?.exitCode).toBe(1);
+    const { data } = await handleBashTool({fs})({ command: "false" }, {});
+    expect(data?.exitCode).toBe(1);
   });
 
   it("captures stderr output", async () => {
-    const { result } = await handleBashTool(fs)(
+    const { data } = await handleBashTool({fs})(
       { command: "echo 'error message' >&2" },
       {}
     );
-    expect(result?.stderr.trim()).toBe("error message");
-    expect(result?.stdout.trim()).toBe("");
+    expect(data?.stderr.trim()).toBe("error message");
+    expect(data?.stdout.trim()).toBe("");
   });
 
   it("supports piping between commands", async () => {
-    const { result } = await handleBashTool(fs)(
+    const { data } = await handleBashTool({fs})(
       { command: "echo 'hello world' | tr 'a-z' 'A-Z'" },
       {}
     );
-    expect(result?.stdout.trim()).toBe("HELLO WORLD");
+    expect(data?.stdout.trim()).toBe("HELLO WORLD");
   });
 
   it("supports command chaining with &&", async () => {
-    const { result } = await handleBashTool(fs)(
+    const { data } = await handleBashTool({fs})(
       { command: "echo 'first' && echo 'second'" },
       {}
     );
-    expect(result?.stdout).toContain("first");
-    expect(result?.stdout).toContain("second");
+    expect(data?.stdout).toContain("first");
+    expect(data?.stdout).toContain("second");
   });
 
   it("handles multi-line output", async () => {
-    const { result } = await handleBashTool(fs)(
+    const { data } = await handleBashTool({fs})(
       { command: "printf 'line1\\nline2\\nline3'" },
       {}
     );
-    const lines = result?.stdout.split("\n");
+    const lines = data?.stdout.split("\n");
     expect(lines).toHaveLength(3);
     expect(lines?.[0]).toBe("line1");
     expect(lines?.[2]).toBe("line3");
   });
 
   it("handles commands with arguments and flags", async () => {
-    const { result } = await handleBashTool(fs)(
+    const { data } = await handleBashTool({fs})(
       { command: "echo -n 'no newline'" },
       {}
     );
-    expect(result?.stdout).toBe("no newline");
+    expect(data?.stdout).toBe("no newline");
   });
 
   it("supports command substitution", async () => {
-    const { result } = await handleBashTool(fs)(
+    const { data } = await handleBashTool({fs})(
       { command: "echo \"count: $(echo 'a b c' | wc -w | tr -d ' ')\"" },
       {}
     );
-    expect(result?.stdout.trim()).toBe("count: 3");
+    expect(data?.stdout.trim()).toBe("count: 3");
   });
 
-  it("returns content string with formatted output", async () => {
-    const { content } = await handleBashTool(fs)(
+  it("returns toolResponse string with formatted output", async () => {
+    const { toolResponse } = await handleBashTool({fs})(
       { command: "echo 'test'" },
       {}
     );
-    expect(content).toContain("Exit code: 0");
-    expect(content).toContain("stdout:");
-    expect(content).toContain("test");
+    expect(toolResponse).toContain("Exit code: 0");
+    expect(toolResponse).toContain("stdout:");
+    expect(toolResponse).toContain("test");
   });
 });
 
 describe("bash with overlay filesystem", () => {
   it("sees files in the current directory", async () => {
     const fs = new OverlayFs({ root: __dirname, mountPoint: "/home/user" });
-    const { result } = await handleBashTool(fs)({ command: "ls" }, {});
-    expect(result?.stdout).toContain("bash.test.ts");
-    expect(result?.stdout).toContain("handler.ts");
-    expect(result?.stdout).toContain("tool.ts");
+    const { data } = await handleBashTool({fs})({ command: "ls" }, {});
+    expect(data?.stdout).toContain("bash.test.ts");
+    expect(data?.stdout).toContain("handler.ts");
+    expect(data?.stdout).toContain("tool.ts");
   });
 });

package/src/tools/bash/handler.ts

@@ -1,6 +1,6 @@
 import type { ActivityToolHandler } from "../../workflow";
 import type { bashToolSchemaType } from "./tool";
-import { Bash, type IFileSystem } from "just-bash";
+import { Bash, type BashOptions } from "just-bash";
 
 type BashExecOut = {
   exitCode: number;
@@ -8,29 +8,38 @@ type BashExecOut = {
   stdout: string;
 };
 
+/** BashOptions with `fs` required */
+type BashToolOptions = Required<Pick<BashOptions, "fs">> & Omit<BashOptions, "fs">;
+
 export const handleBashTool: (
-  fs: IFileSystem
+    bashOptions: BashToolOptions,
 ) => ActivityToolHandler<bashToolSchemaType, BashExecOut | null> =
-  (fs: IFileSystem) => async (args: bashToolSchemaType, _context) => {
+  (bashOptions: BashToolOptions) => async (args: bashToolSchemaType, _context) => {
     const { command } = args;
 
-    const bashOptions = fs ? { fs } : {};
+    const mergedOptions: BashOptions = {
+      ...bashOptions,
+      executionLimits: {
+        maxStringLength: 52428800, // 50MB default
+        ...bashOptions.executionLimits,
+      },
+    };
 
-    const bash = new Bash(bashOptions);
+    const bash = new Bash(mergedOptions);
 
     try {
       const { exitCode, stderr, stdout } = await bash.exec(command);
       const bashExecOut = { exitCode, stderr, stdout };
 
       return {
-        content: `Exit code: ${exitCode}\n\nstdout:\n${stdout}\n\nstderr:\n${stderr}`,
-        result: bashExecOut,
+        toolResponse: `Exit code: ${exitCode}\n\nstdout:\n${stdout}\n\nstderr:\n${stderr}`,
+        data: bashExecOut,
       };
     } catch (error) {
       const err = error instanceof Error ? error : new Error("Unknown error");
       return {
-        content: `Error executing bash command: ${err.message}`,
-        result: null,
+        toolResponse: `Error executing bash command: ${err.message}`,
+        data: null,
       };
     }
   };

package/src/tools/bash/tool.ts

@@ -4,15 +4,31 @@ export const createBashToolDescription = ({
   fileTree,
 }: {
   fileTree: string;
-}): string => `tool to execute bash commands, the file tree is: ${fileTree}`;
+}): string => `Execute shell commands in a bash environment.
+
+Use this tool to:
+- Run shell commands (ls, cat, grep, find, etc.)
+- Execute scripts and chain commands with pipes (|) or logical operators (&&, ||)
+- Inspect files and directories
+
+Current file tree:
+${fileTree}`;
 
 export const bashTool = {
   name: "Bash" as const,
-  description: "tool to execute bash commands",
+  description: `Execute shell commands in a sandboxed bash environment.
+
+Use this tool to:
+- Run shell commands (ls, cat, grep, find, etc.)
+- Execute scripts and chain commands with pipes (|) or logical operators (&&, ||)
+- Inspect files and directories
+`,
   schema: z.object({
     command: z
       .string()
-      .describe("stringified command to be executed inside the Bash"),
+      .describe(
+        "The bash command to execute. Can include pipes (|), redirects (>, >>), logical operators (&&, ||), and shell features like command substitution $(...)."
+      ),
   }),
   strict: true,
 };

package/src/tools/edit/handler.ts

@@ -14,8 +14,8 @@ export interface EditResult {
  * Edit handler response
  */
 export interface EditHandlerResponse {
-  content: string;
-  result: EditResult;
+  toolResponse: string;
+  data: EditResult;
 }
 
 /**
@@ -55,8 +55,8 @@ export async function editHandler(
   // Validate old_string !== new_string
   if (old_string === new_string) {
     return {
-      content: `Error: old_string and new_string must be different.`,
-      result: {
+      toolResponse: `Error: old_string and new_string must be different.`,
+      data: {
         path: file_path,
         success: false,
         replacements: 0,
@@ -69,8 +69,8 @@ export async function editHandler(
     const exists = await fs.exists(file_path);
     if (!exists) {
       return {
-        content: `Error: File "${file_path}" does not exist.`,
-        result: {
+        toolResponse: `Error: File "${file_path}" does not exist.`,
+        data: {
           path: file_path,
           success: false,
           replacements: 0,
@@ -84,8 +84,8 @@ export async function editHandler(
     // 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: {
+        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,
@@ -101,8 +101,8 @@ export async function editHandler(
     // Check uniqueness if not replace_all
     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: {
+        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,
@@ -135,8 +135,8 @@ export async function editHandler(
       : `Replaced 1 occurrence`;
 
     return {
-      content: `${summary} in ${file_path}`,
-      result: {
+      toolResponse: `${summary} in ${file_path}`,
+      data: {
         path: file_path,
         success: true,
         replacements,
@@ -145,8 +145,8 @@ export async function editHandler(
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
     return {
-      content: `Error editing file "${file_path}": ${message}`,
-      result: {
+      toolResponse: `Error editing file "${file_path}": ${message}`,
+      data: {
         path: file_path,
         success: false,
         replacements: 0,

package/src/tools/glob/handler.ts

@@ -13,8 +13,8 @@ export interface GlobResult {
  * Glob handler response
  */
 export interface GlobHandlerResponse {
-  content: string;
-  result: GlobResult;
+  toolResponse: string;
+  data: GlobResult;
 }
 
 /**
@@ -31,8 +31,8 @@ export async function globHandler(
   const _bash = new Bash({ fs });
 
   return Promise.resolve({
-    content: "Hello, world!",
-    result: { files: [] },
+    toolResponse: "Hello, world!",
+    data: { files: [] },
   });
 
   // try {

package/src/tools/task/handler.ts

@@ -24,7 +24,7 @@ export interface TaskHandlerResult<TResult = unknown> {
  *   {
  *     name: "researcher",
  *     description: "Researches topics",
- *     workflowType: "researcherWorkflow",
+ *     workflow: "researcherWorkflow",
  *     resultSchema: z.object({ findings: z.string() }),
  *   },
  * ]);
@@ -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() }),
  *   },
  * ]);

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

@@ -5,6 +5,7 @@ import type {
 import type { ToolHandlerResponse } from "../../lib/tool-router";
 import type { WorkflowTask } from "../../lib/types";
 import type { TaskCreateToolSchemaType } from "./tool";
+import { uuid4 } from "@temporalio/workflow";
 
 /**
  * Creates a TaskCreate handler that adds tasks to the workflow state.
@@ -18,18 +19,14 @@ import type { TaskCreateToolSchemaType } from "./tool";
  */
 export function createTaskCreateHandler<
   TCustom extends JsonSerializable<TCustom>,
->({
-  stateManager,
-  idGenerator,
-}: {
-  stateManager: AgentStateManager<TCustom>;
-  idGenerator: () => string;
-}): (args: TaskCreateToolSchemaType) => ToolHandlerResponse<WorkflowTask> {
+>(
+  stateManager: AgentStateManager<TCustom>
+): (args: TaskCreateToolSchemaType) => ToolHandlerResponse<WorkflowTask> {
   return (
     args: TaskCreateToolSchemaType
   ): ToolHandlerResponse<WorkflowTask> => {
     const task: WorkflowTask = {
-      id: idGenerator(),
+      id: uuid4(),
       subject: args.subject,
       description: args.description,
       activeForm: args.activeForm,
@@ -42,8 +39,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-get/handler.ts

@@ -25,14 +25,14 @@ export function createTaskGetHandler<TCustom extends JsonSerializable<TCustom>>(
 
     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-list/handler.ts

@@ -26,8 +26,8 @@ export function createTaskListHandler<
     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-update/handler.ts

@@ -29,8 +29,8 @@ export function createTaskUpdateHandler<
 
     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,
       };
     }
 
@@ -72,8 +72,8 @@ export function createTaskUpdateHandler<
     stateManager.setTask(task);
 
     return {
-      content: JSON.stringify(task, null, 2),
-      result: task,
+      toolResponse: JSON.stringify(task, null, 2),
+      data: task,
     };
   };
 }

package/src/workflow.ts

@@ -33,7 +33,7 @@ export type {
 } from "./lib/state-manager";
 
 // Tool router (includes registry functionality)
-export { createToolRouter, hasNoOtherToolCalls } from "./lib/tool-router";
+export { createToolRouter, hasNoOtherToolCalls, defineTool, defineSubagent } from "./lib/tool-router";
 export type {
   // Tool definition types
   ToolDefinition,
@@ -81,11 +81,13 @@ export type {
   PostToolUseFailureHook,
   PostToolUseFailureHookContext,
   PostToolUseFailureHookResult,
+  ToolHooks,
   SessionStartHook,
   SessionStartHookContext,
   SessionEndHook,
   SessionEndHookContext,
   SubagentConfig,
+  SubagentHooks,
   SubagentInput,
   TaskStatus,
   WorkflowTask,

package/tsup.config.ts

@@ -5,7 +5,7 @@ export default defineConfig({
     index: "src/index.ts",
     workflow: "src/workflow.ts",
   },
-  format: ["cjs", "esm"],
+  format: ["esm", "cjs"],
   dts: true,
   clean: true,
   sourcemap: true,
@@ -16,5 +16,7 @@ export default defineConfig({
     /^@temporalio\//,
     /^@langchain\//,
     "ioredis",
+    "@mongodb-js/zstd",
+    "node-liblzma",
   ],
 });