zeitlich 0.2.3 → 0.2.5

package/dist/{workflow-D-2vp4Pq.d.cts → workflow-Dg5JMeOC.d.cts}

@@ -44,6 +44,8 @@ interface ThreadManager extends BaseThreadManager<StoredMessage> {
     createToolMessage(content: ToolMessageContent, toolCallId: string): StoredMessage;
     /** Create and append a HumanMessage */
     appendHumanMessage(content: string | MessageContent): Promise<void>;
+    /** Create and append a SystemMessage */
+    appendSystemMessage(content: string): Promise<void>;
     /** Create and append a ToolMessage */
     appendToolMessage(content: ToolMessageContent, toolCallId: string): Promise<void>;
     /** Create and append an AIMessage */
@@ -58,22 +60,22 @@ declare function createThreadManager(config: ThreadManagerConfig): ThreadManager
 declare function createThreadManager<T>(config: ThreadManagerConfig<T>): BaseThreadManager<T>;
 
 /**
- * Creates a Task tool configured with the available subagents.
+ * Creates a Subagent tool configured with the available subagents.
  *
  * @param subagents - Array of subagent configurations (must have at least one)
  * @returns A tool definition with dynamic schema based on available subagents
  *
  * @example
- * const taskTool = createTaskTool([
+ * const subagentTool = createSubagentTool([
  *   {
- *     name: "researcher",
+ *     agentName: "researcher",
  *     description: "Researches topics and gathers information",
  *     workflow: "researcherWorkflow",
  *     resultSchema: z.object({ findings: z.string() }),
  *   },
  * ]);
  */
-declare function createTaskTool<T extends SubagentConfig[]>(subagents: T): {
+declare function createSubagentTool<T extends SubagentConfig[]>(subagents: T): {
     name: string;
     description: string;
     schema: z.ZodObject<{
@@ -83,9 +85,9 @@ declare function createTaskTool<T extends SubagentConfig[]>(subagents: T): {
     }>;
 };
 /**
- * Task tool args type (when subagent names are not known at compile time)
+ * Subagent tool args type (when subagent names are not known at compile time)
  */
-type TaskArgs = {
+type SubagentArgs = {
     subagent: string;
     description: string;
     prompt: string;
@@ -436,13 +438,13 @@ declare function defineSubagent<TResult extends z$1.ZodType = z$1.ZodType, TCont
         context: TContext;
     }) => Promise<any>);
     context: TContext;
-    hooks?: SubagentHooks<TaskArgs, z$1.infer<TResult>>;
+    hooks?: SubagentHooks<SubagentArgs, z$1.infer<TResult>>;
 }): SubagentConfig<TResult>;
 declare function defineSubagent<TResult extends z$1.ZodType = z$1.ZodType>(config: Omit<SubagentConfig<TResult>, "hooks" | "workflow"> & {
     workflow: string | ((input: {
         prompt: string;
     }) => Promise<any>);
-    hooks?: SubagentHooks<TaskArgs, z$1.infer<TResult>>;
+    hooks?: SubagentHooks<SubagentArgs, z$1.infer<TResult>>;
 }): SubagentConfig<TResult>;
 /**
  * Utility to check if there were no tool calls besides a specific one
@@ -484,7 +486,7 @@ interface AgentFile {
  */
 interface AgentResponse<M = StoredMessage> {
     message: M;
-    stopReason: string | null;
+    rawToolCalls: RawToolCall[];
     usage?: {
         input_tokens?: number;
         output_tokens?: number;
@@ -496,15 +498,15 @@ interface AgentResponse<M = StoredMessage> {
  * Consumers provide these — typically by wrapping Temporal activities.
  * Use `proxyDefaultThreadOps()` for the default StoredMessage implementation.
  */
-interface ThreadOps<M = StoredMessage> {
+interface ThreadOps {
     /** Initialize an empty thread */
     initializeThread(threadId: string): Promise<void>;
     /** Append a human message to the thread */
     appendHumanMessage(threadId: string, content: string | MessageContent): Promise<void>;
     /** Append a tool result to the thread */
     appendToolResult(config: ToolResultConfig): Promise<void>;
-    /** Extract raw tool calls from a message */
-    parseToolCalls(message: M): Promise<RawToolCall[]>;
+    /** Append a system message to the thread */
+    appendSystemMessage(threadId: string, content: string): Promise<void>;
 }
 /**
  * Configuration for a Zeitlich agent session
@@ -512,12 +514,16 @@ interface ThreadOps<M = StoredMessage> {
 interface ZeitlichAgentConfig<T extends ToolMap, M = StoredMessage> {
     threadId: string;
     agentName: string;
+    /** Description, used for sub agents */
+    description?: string;
+    systemPrompt?: string;
     metadata?: Record<string, unknown>;
+    appendSystemPrompt?: boolean;
     maxTurns?: number;
     /** Workflow-specific runAgent activity (with tools pre-bound) */
     runAgent: RunAgentActivity<M>;
     /** Thread operations (initialize, append messages, parse tool calls) */
-    threadOps: ThreadOps<M>;
+    threadOps?: ThreadOps;
     /** Tool router for processing tool calls (optional if agent has no tools) */
     tools?: T;
     /** Subagent configurations */
@@ -574,9 +580,11 @@ interface ToolResultConfig {
  */
 interface SubagentConfig<TResult extends z$1.ZodType = z$1.ZodType> {
     /** Identifier used in Task tool's subagent parameter */
-    name: string;
+    agentName: string;
     /** Description shown to the parent agent explaining what this subagent does */
     description: string;
+    /** Whether this subagent is available (default: true). Disabled subagents are excluded from the Subagent tool. */
+    enabled?: boolean;
     /** Temporal workflow function or type name (used with executeChild) */
     workflow: string | Workflow;
     /** Optional task queue - defaults to parent's queue if not specified */
@@ -912,7 +920,7 @@ interface SessionLifecycleHooks {
     /** Called when session ends */
     onSessionEnd?: SessionEndHook;
 }
-declare const createSession: <T extends ToolMap, M = unknown>({ threadId, agentName, maxTurns, metadata, runAgent, threadOps, buildContextMessage, subagents, tools, processToolsInParallel, hooks, }: ZeitlichAgentConfig<T, M>) => Promise<ZeitlichSession<M>>;
+declare const createSession: <T extends ToolMap, M = unknown>({ threadId, agentName, maxTurns, metadata, runAgent, threadOps, buildContextMessage, subagents, tools, processToolsInParallel, hooks, appendSystemPrompt, systemPrompt, }: ZeitlichAgentConfig<T, M>) => Promise<ZeitlichSession<M>>;
 /**
  * Proxy the default ZeitlichSharedActivities as ThreadOps<StoredMessage>.
  * Call this in workflow code for the standard LangChain/StoredMessage setup.
@@ -925,17 +933,7 @@ declare const createSession: <T extends ToolMap, M = unknown>({ threadId, agentN
  * });
  * ```
  */
-declare function proxyDefaultThreadOps(options?: Parameters<typeof proxyActivities>[0]): ThreadOps<StoredMessage>;
-
-/**
- * Result from a task handler execution
- */
-interface TaskHandlerResult<TResult = unknown> {
-    /** The validated result from the child workflow */
-    result: TResult;
-    /** The child workflow ID (for reference/debugging) */
-    childWorkflowId: string;
-}
+declare function proxyDefaultThreadOps(options?: Parameters<typeof proxyActivities>[0]): ThreadOps;
 
 /**
  * Shared Zeitlich activities - thread management and message handling
@@ -960,10 +958,9 @@ interface ZeitlichSharedActivities {
      */
     appendHumanMessage(threadId: string, content: string | MessageContent): Promise<void>;
     /**
-     * Extract raw tool calls from a stored message.
-     * Returns unvalidated tool calls - use toolRegistry.parseToolCall() to validate.
+     * Append a system message to a thread.
      */
-    parseToolCalls(storedMessage: StoredMessage): Promise<RawToolCall[]>;
+    appendSystemMessage(threadId: string, content: string): Promise<void>;
 }
 /**
  * Creates shared Temporal activities for thread management
@@ -1143,4 +1140,4 @@ declare const bashTool: {
 };
 type BashArgs = z.infer<typeof bashTool.schema>;
 
-export { type ThreadOps as $, type AgentResponse as A, type BashArgs as B, type RunAgentConfig as C, type SessionEndHookContext as D, type SessionExitReason as E, type FileEditArgs as F, type GlobArgs as G, type SessionLifecycleHooks as H, type InferToolResults as I, type JsonPrimitive as J, type SessionStartHook as K, type SessionStartHookContext as L, type SubagentConfig as M, type SubagentHooks as N, type SubagentInput as O, type ParsedToolCall as P, type TaskCreateArgs as Q, type RawToolCall as R, type SessionEndHook as S, type TaskArgs as T, type TaskGetArgs as U, type TaskHandlerResult as V, type TaskListArgs as W, type TaskStatus as X, type TaskUpdateArgs as Y, type ThreadManager as Z, type ThreadManagerConfig as _, type ActivityToolHandler as a, type ToolArgs as a0, type ToolCallResult as a1, type ToolCallResultUnion as a2, type ToolDefinition as a3, type ToolHandler as a4, type ToolHandlerContext as a5, type ToolHandlerResponse as a6, type ToolHooks as a7, type ToolMap as a8, type ToolMessageContent as a9, globTool as aA, grepTool as aB, hasNoOtherToolCalls as aC, isTerminalStatus as aD, proxyDefaultThreadOps as aE, readTool as aF, taskCreateTool as aG, taskGetTool as aH, taskListTool as aI, taskUpdateTool as aJ, withAutoAppend as aK, writeTool as aL, type ToolNames as aa, type ToolResult as ab, type ToolResultConfig as ac, type ToolRouter as ad, type ToolWithHandler as ae, type WorkflowTask as af, type ZeitlichAgentConfig as ag, type ZeitlichSession as ah, type ZeitlichSharedActivities as ai, askUserQuestionTool as aj, bashTool as ak, createAgentStateManager as al, createBashToolDescription as am, createSession as an, createSharedActivities as ao, createTaskCreateHandler as ap, createTaskGetHandler as aq, createTaskListHandler as ar, createTaskTool as as, createTaskUpdateHandler as at, createThreadManager as au, createToolRouter as av, defineSubagent as aw, defineTool as ax, editTool as ay, getStateQuery as az, type AskUserQuestionArgs as b, AGENT_HANDLER_NAMES as c, type AgentFile as d, type AgentState as e, type AgentStateManager as f, type AgentStatus as g, type AppendToolResultFn as h, type BaseAgentState as i, type BaseThreadManager as j, type FileReadArgs as k, type FileWriteArgs as l, type GrepArgs as m, type JsonSerializable as n, type JsonValue as o, type ParsedToolCallUnion as p, type PostToolUseFailureHook as q, type PostToolUseFailureHookContext as r, type PostToolUseFailureHookResult as s, type PostToolUseHook as t, type PostToolUseHookContext as u, type PreToolUseHook as v, type PreToolUseHookContext as w, type PreToolUseHookResult as x, type ProcessToolCallsContext as y, type RunAgentActivity as z };
+export { type ToolArgs as $, type AgentResponse as A, type BashArgs as B, type RunAgentConfig as C, type SessionEndHookContext as D, type SessionExitReason as E, type FileEditArgs as F, type GlobArgs as G, type SessionLifecycleHooks as H, type InferToolResults as I, type JsonPrimitive as J, type SessionStartHook as K, type SessionStartHookContext as L, type SubagentArgs as M, type SubagentConfig as N, type SubagentHooks as O, type ParsedToolCall as P, type SubagentInput as Q, type RawToolCall as R, type SessionEndHook as S, type TaskCreateArgs as T, type TaskGetArgs as U, type TaskListArgs as V, type TaskStatus as W, type TaskUpdateArgs as X, type ThreadManager as Y, type ThreadManagerConfig as Z, type ThreadOps as _, type ActivityToolHandler as a, type ToolCallResult as a0, type ToolCallResultUnion as a1, type ToolDefinition as a2, type ToolHandler as a3, type ToolHandlerContext as a4, type ToolHandlerResponse as a5, type ToolHooks as a6, type ToolMap as a7, type ToolMessageContent as a8, type ToolNames as a9, grepTool as aA, hasNoOtherToolCalls as aB, isTerminalStatus as aC, proxyDefaultThreadOps as aD, readTool as aE, taskCreateTool as aF, taskGetTool as aG, taskListTool as aH, taskUpdateTool as aI, withAutoAppend as aJ, writeTool as aK, type ToolResult as aa, type ToolResultConfig as ab, type ToolRouter as ac, type ToolWithHandler as ad, type WorkflowTask as ae, type ZeitlichAgentConfig as af, type ZeitlichSession as ag, type ZeitlichSharedActivities as ah, askUserQuestionTool as ai, bashTool as aj, createAgentStateManager as ak, createBashToolDescription as al, createSession as am, createSharedActivities as an, createSubagentTool as ao, createTaskCreateHandler as ap, createTaskGetHandler as aq, createTaskListHandler as ar, createTaskUpdateHandler as as, createThreadManager as at, createToolRouter as au, defineSubagent as av, defineTool as aw, editTool as ax, getStateQuery as ay, globTool as az, type AskUserQuestionArgs as b, AGENT_HANDLER_NAMES as c, type AgentFile as d, type AgentState as e, type AgentStateManager as f, type AgentStatus as g, type AppendToolResultFn as h, type BaseAgentState as i, type BaseThreadManager as j, type FileReadArgs as k, type FileWriteArgs as l, type GrepArgs as m, type JsonSerializable as n, type JsonValue as o, type ParsedToolCallUnion as p, type PostToolUseFailureHook as q, type PostToolUseFailureHookContext as r, type PostToolUseFailureHookResult as s, type PostToolUseHook as t, type PostToolUseHookContext as u, type PreToolUseHook as v, type PreToolUseHookContext as w, type PreToolUseHookResult as x, type ProcessToolCallsContext as y, type RunAgentActivity as z };

package/dist/{workflow-D-2vp4Pq.d.ts → workflow-Dg5JMeOC.d.ts}

@@ -44,6 +44,8 @@ interface ThreadManager extends BaseThreadManager<StoredMessage> {
     createToolMessage(content: ToolMessageContent, toolCallId: string): StoredMessage;
     /** Create and append a HumanMessage */
     appendHumanMessage(content: string | MessageContent): Promise<void>;
+    /** Create and append a SystemMessage */
+    appendSystemMessage(content: string): Promise<void>;
     /** Create and append a ToolMessage */
     appendToolMessage(content: ToolMessageContent, toolCallId: string): Promise<void>;
     /** Create and append an AIMessage */
@@ -58,22 +60,22 @@ declare function createThreadManager(config: ThreadManagerConfig): ThreadManager
 declare function createThreadManager<T>(config: ThreadManagerConfig<T>): BaseThreadManager<T>;
 
 /**
- * Creates a Task tool configured with the available subagents.
+ * Creates a Subagent tool configured with the available subagents.
  *
  * @param subagents - Array of subagent configurations (must have at least one)
  * @returns A tool definition with dynamic schema based on available subagents
  *
  * @example
- * const taskTool = createTaskTool([
+ * const subagentTool = createSubagentTool([
  *   {
- *     name: "researcher",
+ *     agentName: "researcher",
  *     description: "Researches topics and gathers information",
  *     workflow: "researcherWorkflow",
  *     resultSchema: z.object({ findings: z.string() }),
  *   },
  * ]);
  */
-declare function createTaskTool<T extends SubagentConfig[]>(subagents: T): {
+declare function createSubagentTool<T extends SubagentConfig[]>(subagents: T): {
     name: string;
     description: string;
     schema: z.ZodObject<{
@@ -83,9 +85,9 @@ declare function createTaskTool<T extends SubagentConfig[]>(subagents: T): {
     }>;
 };
 /**
- * Task tool args type (when subagent names are not known at compile time)
+ * Subagent tool args type (when subagent names are not known at compile time)
  */
-type TaskArgs = {
+type SubagentArgs = {
     subagent: string;
     description: string;
     prompt: string;
@@ -436,13 +438,13 @@ declare function defineSubagent<TResult extends z$1.ZodType = z$1.ZodType, TCont
         context: TContext;
     }) => Promise<any>);
     context: TContext;
-    hooks?: SubagentHooks<TaskArgs, z$1.infer<TResult>>;
+    hooks?: SubagentHooks<SubagentArgs, z$1.infer<TResult>>;
 }): SubagentConfig<TResult>;
 declare function defineSubagent<TResult extends z$1.ZodType = z$1.ZodType>(config: Omit<SubagentConfig<TResult>, "hooks" | "workflow"> & {
     workflow: string | ((input: {
         prompt: string;
     }) => Promise<any>);
-    hooks?: SubagentHooks<TaskArgs, z$1.infer<TResult>>;
+    hooks?: SubagentHooks<SubagentArgs, z$1.infer<TResult>>;
 }): SubagentConfig<TResult>;
 /**
  * Utility to check if there were no tool calls besides a specific one
@@ -484,7 +486,7 @@ interface AgentFile {
  */
 interface AgentResponse<M = StoredMessage> {
     message: M;
-    stopReason: string | null;
+    rawToolCalls: RawToolCall[];
     usage?: {
         input_tokens?: number;
         output_tokens?: number;
@@ -496,15 +498,15 @@ interface AgentResponse<M = StoredMessage> {
  * Consumers provide these — typically by wrapping Temporal activities.
  * Use `proxyDefaultThreadOps()` for the default StoredMessage implementation.
  */
-interface ThreadOps<M = StoredMessage> {
+interface ThreadOps {
     /** Initialize an empty thread */
     initializeThread(threadId: string): Promise<void>;
     /** Append a human message to the thread */
     appendHumanMessage(threadId: string, content: string | MessageContent): Promise<void>;
     /** Append a tool result to the thread */
     appendToolResult(config: ToolResultConfig): Promise<void>;
-    /** Extract raw tool calls from a message */
-    parseToolCalls(message: M): Promise<RawToolCall[]>;
+    /** Append a system message to the thread */
+    appendSystemMessage(threadId: string, content: string): Promise<void>;
 }
 /**
  * Configuration for a Zeitlich agent session
@@ -512,12 +514,16 @@ interface ThreadOps<M = StoredMessage> {
 interface ZeitlichAgentConfig<T extends ToolMap, M = StoredMessage> {
     threadId: string;
     agentName: string;
+    /** Description, used for sub agents */
+    description?: string;
+    systemPrompt?: string;
     metadata?: Record<string, unknown>;
+    appendSystemPrompt?: boolean;
     maxTurns?: number;
     /** Workflow-specific runAgent activity (with tools pre-bound) */
     runAgent: RunAgentActivity<M>;
     /** Thread operations (initialize, append messages, parse tool calls) */
-    threadOps: ThreadOps<M>;
+    threadOps?: ThreadOps;
     /** Tool router for processing tool calls (optional if agent has no tools) */
     tools?: T;
     /** Subagent configurations */
@@ -574,9 +580,11 @@ interface ToolResultConfig {
  */
 interface SubagentConfig<TResult extends z$1.ZodType = z$1.ZodType> {
     /** Identifier used in Task tool's subagent parameter */
-    name: string;
+    agentName: string;
     /** Description shown to the parent agent explaining what this subagent does */
     description: string;
+    /** Whether this subagent is available (default: true). Disabled subagents are excluded from the Subagent tool. */
+    enabled?: boolean;
     /** Temporal workflow function or type name (used with executeChild) */
     workflow: string | Workflow;
     /** Optional task queue - defaults to parent's queue if not specified */
@@ -912,7 +920,7 @@ interface SessionLifecycleHooks {
     /** Called when session ends */
     onSessionEnd?: SessionEndHook;
 }
-declare const createSession: <T extends ToolMap, M = unknown>({ threadId, agentName, maxTurns, metadata, runAgent, threadOps, buildContextMessage, subagents, tools, processToolsInParallel, hooks, }: ZeitlichAgentConfig<T, M>) => Promise<ZeitlichSession<M>>;
+declare const createSession: <T extends ToolMap, M = unknown>({ threadId, agentName, maxTurns, metadata, runAgent, threadOps, buildContextMessage, subagents, tools, processToolsInParallel, hooks, appendSystemPrompt, systemPrompt, }: ZeitlichAgentConfig<T, M>) => Promise<ZeitlichSession<M>>;
 /**
  * Proxy the default ZeitlichSharedActivities as ThreadOps<StoredMessage>.
  * Call this in workflow code for the standard LangChain/StoredMessage setup.
@@ -925,17 +933,7 @@ declare const createSession: <T extends ToolMap, M = unknown>({ threadId, agentN
  * });
  * ```
  */
-declare function proxyDefaultThreadOps(options?: Parameters<typeof proxyActivities>[0]): ThreadOps<StoredMessage>;
-
-/**
- * Result from a task handler execution
- */
-interface TaskHandlerResult<TResult = unknown> {
-    /** The validated result from the child workflow */
-    result: TResult;
-    /** The child workflow ID (for reference/debugging) */
-    childWorkflowId: string;
-}
+declare function proxyDefaultThreadOps(options?: Parameters<typeof proxyActivities>[0]): ThreadOps;
 
 /**
  * Shared Zeitlich activities - thread management and message handling
@@ -960,10 +958,9 @@ interface ZeitlichSharedActivities {
      */
     appendHumanMessage(threadId: string, content: string | MessageContent): Promise<void>;
     /**
-     * Extract raw tool calls from a stored message.
-     * Returns unvalidated tool calls - use toolRegistry.parseToolCall() to validate.
+     * Append a system message to a thread.
      */
-    parseToolCalls(storedMessage: StoredMessage): Promise<RawToolCall[]>;
+    appendSystemMessage(threadId: string, content: string): Promise<void>;
 }
 /**
  * Creates shared Temporal activities for thread management
@@ -1143,4 +1140,4 @@ declare const bashTool: {
 };
 type BashArgs = z.infer<typeof bashTool.schema>;
 
-export { type ThreadOps as $, type AgentResponse as A, type BashArgs as B, type RunAgentConfig as C, type SessionEndHookContext as D, type SessionExitReason as E, type FileEditArgs as F, type GlobArgs as G, type SessionLifecycleHooks as H, type InferToolResults as I, type JsonPrimitive as J, type SessionStartHook as K, type SessionStartHookContext as L, type SubagentConfig as M, type SubagentHooks as N, type SubagentInput as O, type ParsedToolCall as P, type TaskCreateArgs as Q, type RawToolCall as R, type SessionEndHook as S, type TaskArgs as T, type TaskGetArgs as U, type TaskHandlerResult as V, type TaskListArgs as W, type TaskStatus as X, type TaskUpdateArgs as Y, type ThreadManager as Z, type ThreadManagerConfig as _, type ActivityToolHandler as a, type ToolArgs as a0, type ToolCallResult as a1, type ToolCallResultUnion as a2, type ToolDefinition as a3, type ToolHandler as a4, type ToolHandlerContext as a5, type ToolHandlerResponse as a6, type ToolHooks as a7, type ToolMap as a8, type ToolMessageContent as a9, globTool as aA, grepTool as aB, hasNoOtherToolCalls as aC, isTerminalStatus as aD, proxyDefaultThreadOps as aE, readTool as aF, taskCreateTool as aG, taskGetTool as aH, taskListTool as aI, taskUpdateTool as aJ, withAutoAppend as aK, writeTool as aL, type ToolNames as aa, type ToolResult as ab, type ToolResultConfig as ac, type ToolRouter as ad, type ToolWithHandler as ae, type WorkflowTask as af, type ZeitlichAgentConfig as ag, type ZeitlichSession as ah, type ZeitlichSharedActivities as ai, askUserQuestionTool as aj, bashTool as ak, createAgentStateManager as al, createBashToolDescription as am, createSession as an, createSharedActivities as ao, createTaskCreateHandler as ap, createTaskGetHandler as aq, createTaskListHandler as ar, createTaskTool as as, createTaskUpdateHandler as at, createThreadManager as au, createToolRouter as av, defineSubagent as aw, defineTool as ax, editTool as ay, getStateQuery as az, type AskUserQuestionArgs as b, AGENT_HANDLER_NAMES as c, type AgentFile as d, type AgentState as e, type AgentStateManager as f, type AgentStatus as g, type AppendToolResultFn as h, type BaseAgentState as i, type BaseThreadManager as j, type FileReadArgs as k, type FileWriteArgs as l, type GrepArgs as m, type JsonSerializable as n, type JsonValue as o, type ParsedToolCallUnion as p, type PostToolUseFailureHook as q, type PostToolUseFailureHookContext as r, type PostToolUseFailureHookResult as s, type PostToolUseHook as t, type PostToolUseHookContext as u, type PreToolUseHook as v, type PreToolUseHookContext as w, type PreToolUseHookResult as x, type ProcessToolCallsContext as y, type RunAgentActivity as z };
+export { type ToolArgs as $, type AgentResponse as A, type BashArgs as B, type RunAgentConfig as C, type SessionEndHookContext as D, type SessionExitReason as E, type FileEditArgs as F, type GlobArgs as G, type SessionLifecycleHooks as H, type InferToolResults as I, type JsonPrimitive as J, type SessionStartHook as K, type SessionStartHookContext as L, type SubagentArgs as M, type SubagentConfig as N, type SubagentHooks as O, type ParsedToolCall as P, type SubagentInput as Q, type RawToolCall as R, type SessionEndHook as S, type TaskCreateArgs as T, type TaskGetArgs as U, type TaskListArgs as V, type TaskStatus as W, type TaskUpdateArgs as X, type ThreadManager as Y, type ThreadManagerConfig as Z, type ThreadOps as _, type ActivityToolHandler as a, type ToolCallResult as a0, type ToolCallResultUnion as a1, type ToolDefinition as a2, type ToolHandler as a3, type ToolHandlerContext as a4, type ToolHandlerResponse as a5, type ToolHooks as a6, type ToolMap as a7, type ToolMessageContent as a8, type ToolNames as a9, grepTool as aA, hasNoOtherToolCalls as aB, isTerminalStatus as aC, proxyDefaultThreadOps as aD, readTool as aE, taskCreateTool as aF, taskGetTool as aG, taskListTool as aH, taskUpdateTool as aI, withAutoAppend as aJ, writeTool as aK, type ToolResult as aa, type ToolResultConfig as ab, type ToolRouter as ac, type ToolWithHandler as ad, type WorkflowTask as ae, type ZeitlichAgentConfig as af, type ZeitlichSession as ag, type ZeitlichSharedActivities as ah, askUserQuestionTool as ai, bashTool as aj, createAgentStateManager as ak, createBashToolDescription as al, createSession as am, createSharedActivities as an, createSubagentTool as ao, createTaskCreateHandler as ap, createTaskGetHandler as aq, createTaskListHandler as ar, createTaskUpdateHandler as as, createThreadManager as at, createToolRouter as au, defineSubagent as av, defineTool as aw, editTool as ax, getStateQuery as ay, globTool as az, type AskUserQuestionArgs as b, AGENT_HANDLER_NAMES as c, type AgentFile as d, type AgentState as e, type AgentStateManager as f, type AgentStatus as g, type AppendToolResultFn as h, type BaseAgentState as i, type BaseThreadManager as j, type FileReadArgs as k, type FileWriteArgs as l, type GrepArgs as m, type JsonSerializable as n, type JsonValue as o, type ParsedToolCallUnion as p, type PostToolUseFailureHook as q, type PostToolUseFailureHookContext as r, type PostToolUseFailureHookResult as s, type PostToolUseHook as t, type PostToolUseHookContext as u, type PreToolUseHook as v, type PreToolUseHookContext as w, type PreToolUseHookResult as x, type ProcessToolCallsContext as y, type RunAgentActivity as z };

package/dist/workflow.cjs

@@ -8,38 +8,38 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var z3__default = /*#__PURE__*/_interopDefault(z3);
 
 // 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.
+var SUBAGENT_TOOL = "Subagent";
+function buildSubagentDescription(subagents) {
+  const subagentList = subagents.map((s) => `- **${s.agentName}**: ${s.description}`).join("\n");
+  return `Launch a new agent to handle complex 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.
+The ${SUBAGENT_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.
+When using the ${SUBAGENT_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.
+- When the agent is done, it will return a single message back to you.
 - 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) {
+function createSubagentTool(subagents) {
   if (subagents.length === 0) {
     throw new Error("createTaskTool requires at least one subagent");
   }
-  const names = subagents.map((s) => s.name);
+  const names = subagents.map((s) => s.agentName);
   return {
-    name: TASK_TOOL,
-    description: buildTaskDescription(subagents),
+    name: SUBAGENT_TOOL,
+    description: buildSubagentDescription(subagents),
     schema: z3__default.default.object({
       subagent: z3__default.default.enum(names).describe("The type of subagent to launch"),
       description: z3__default.default.string().describe("A short (3-5 word) description of the task"),
@@ -47,16 +47,16 @@ function createTaskTool(subagents) {
     })
   };
 }
-function createTaskHandler(subagents) {
-  const { workflowId: parentWorkflowId, taskQueue: parentTaskQueue } = workflow.workflowInfo();
+function createSubagentHandler(subagents) {
+  const { taskQueue: parentTaskQueue } = workflow.workflowInfo();
   return async (args) => {
-    const config = subagents.find((s) => s.name === args.subagent);
+    const config = subagents.find((s) => s.agentName === args.subagent);
     if (!config) {
       throw new Error(
-        `Unknown subagent: ${args.subagent}. Available: ${subagents.map((s) => s.name).join(", ")}`
+        `Unknown subagent: ${args.subagent}. Available: ${subagents.map((s) => s.agentName).join(", ")}`
       );
     }
-    const childWorkflowId = `${parentWorkflowId}-${args.subagent}-${workflow.uuid4()}`;
+    const childWorkflowId = `${args.subagent}-${workflow.uuid4()}`;
     const input = {
       prompt: args.prompt,
       ...config.context && { context: config.context }
@@ -66,15 +66,11 @@ function createTaskHandler(subagents) {
       args: [input],
       taskQueue: config.taskQueue ?? parentTaskQueue
     };
-    const childResult = typeof config.workflow === "string" ? await workflow.executeChild(config.workflow, childOpts) : await workflow.executeChild(config.workflow, childOpts);
-    const validated = config.resultSchema ? config.resultSchema.parse(childResult) : childResult;
-    const toolResponse = typeof validated === "string" ? validated : JSON.stringify(validated, null, 2);
+    const { toolResponse, data } = typeof config.workflow === "string" ? await workflow.executeChild(config.workflow, childOpts) : await workflow.executeChild(config.workflow, childOpts);
+    const validated = config.resultSchema ? config.resultSchema.parse(data) : null;
     return {
       toolResponse,
-      data: {
-        result: validated,
-        childWorkflowId
-      }
+      data: validated
     };
   };
 }
@@ -88,31 +84,36 @@ function createToolRouter(options) {
   }
   const isEnabled = (tool) => tool.enabled !== false;
   if (options.subagents) {
-    const subagentHooksMap = /* @__PURE__ */ new Map();
-    for (const s of options.subagents) {
-      if (s.hooks) subagentHooksMap.set(s.name, s.hooks);
-    }
-    const resolveSubagentName = (args) => args.subagent;
-    toolMap.set("Task", {
-      ...createTaskTool(options.subagents),
-      handler: createTaskHandler(options.subagents),
-      ...subagentHooksMap.size > 0 && {
-        hooks: {
-          onPreToolUse: async (ctx) => {
-            const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
-            return hooks?.onPreExecution?.(ctx) ?? {};
-          },
-          onPostToolUse: async (ctx) => {
-            const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
-            await hooks?.onPostExecution?.(ctx);
-          },
-          onPostToolUseFailure: async (ctx) => {
-            const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
-            return hooks?.onExecutionFailure?.(ctx) ?? {};
+    const enabledSubagents = options.subagents.filter(
+      (s) => s.enabled !== false
+    );
+    if (enabledSubagents.length > 0) {
+      const subagentHooksMap = /* @__PURE__ */ new Map();
+      for (const s of enabledSubagents) {
+        if (s.hooks) subagentHooksMap.set(s.agentName, s.hooks);
+      }
+      const resolveSubagentName = (args) => args.subagent;
+      toolMap.set("Subagent", {
+        ...createSubagentTool(enabledSubagents),
+        handler: createSubagentHandler(enabledSubagents),
+        ...subagentHooksMap.size > 0 && {
+          hooks: {
+            onPreToolUse: async (ctx) => {
+              const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
+              return hooks?.onPreExecution?.(ctx) ?? {};
+            },
+            onPostToolUse: async (ctx) => {
+              const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
+              await hooks?.onPostExecution?.(ctx);
+            },
+            onPostToolUseFailure: async (ctx) => {
+              const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
+              return hooks?.onExecutionFailure?.(ctx) ?? {};
+            }
           }
         }
-      }
-    });
+      });
+    }
   }
   async function processToolCall(toolCall, turn, handlerContext) {
     const startTime = Date.now();
@@ -393,11 +394,19 @@ var createSession = async ({
   subagents,
   tools = {},
   processToolsInParallel = true,
-  hooks = {}
+  hooks = {},
+  appendSystemPrompt = true,
+  systemPrompt
 }) => {
+  const {
+    appendToolResult,
+    appendHumanMessage,
+    initializeThread,
+    appendSystemMessage
+  } = threadOps ?? proxyDefaultThreadOps();
   const toolRouter = createToolRouter({
     tools,
-    appendToolResult: threadOps.appendToolResult,
+    appendToolResult,
     threadId,
     hooks,
     subagents,
@@ -424,35 +433,32 @@ var createSession = async ({
         });
       }
       stateManager.setTools(toolRouter.getToolDefinitions());
-      await threadOps.initializeThread(threadId);
-      await threadOps.appendHumanMessage(threadId, await buildContextMessage());
+      await initializeThread(threadId);
+      if (appendSystemPrompt && systemPrompt && systemPrompt.trim() !== "") {
+        await appendSystemMessage(threadId, systemPrompt);
+      }
+      await appendHumanMessage(threadId, await buildContextMessage());
       let exitReason = "completed";
       try {
         while (stateManager.isRunning() && !stateManager.isTerminal() && stateManager.getTurns() < maxTurns) {
           stateManager.incrementTurns();
           const currentTurn = stateManager.getTurns();
-          const { message, stopReason } = await runAgent({
+          const { message, rawToolCalls } = await runAgent({
             threadId,
             agentName,
             metadata
           });
-          if (stopReason === "end_turn") {
-            stateManager.complete();
-            exitReason = "completed";
-            return message;
-          }
-          if (!toolRouter.hasTools()) {
+          if (!toolRouter.hasTools() || rawToolCalls.length === 0) {
             stateManager.complete();
             exitReason = "completed";
             return message;
           }
-          const rawToolCalls = await threadOps.parseToolCalls(message);
           const parsedToolCalls = [];
           for (const tc of rawToolCalls) {
             try {
               parsedToolCalls.push(toolRouter.parseToolCall(tc));
             } catch (error) {
-              await threadOps.appendToolResult({
+              await appendToolResult({
                 threadId,
                 toolCallId: tc.id ?? "",
                 toolName: tc.name,
@@ -500,7 +506,7 @@ function proxyDefaultThreadOps(options) {
     initializeThread: activities.initializeThread,
     appendHumanMessage: activities.appendHumanMessage,
     appendToolResult: activities.appendToolResult,
-    parseToolCalls: activities.parseToolCalls
+    appendSystemMessage: activities.appendSystemMessage
   };
 }
 
@@ -973,10 +979,10 @@ exports.bashTool = bashTool;
 exports.createAgentStateManager = createAgentStateManager;
 exports.createBashToolDescription = createBashToolDescription;
 exports.createSession = createSession;
+exports.createSubagentTool = createSubagentTool;
 exports.createTaskCreateHandler = createTaskCreateHandler;
 exports.createTaskGetHandler = createTaskGetHandler;
 exports.createTaskListHandler = createTaskListHandler;
-exports.createTaskTool = createTaskTool;
 exports.createTaskUpdateHandler = createTaskUpdateHandler;
 exports.createToolRouter = createToolRouter;
 exports.defineSubagent = defineSubagent;