zeitlich 0.2.4 → 0.2.5

package/dist/{workflow-PjeURKw4.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 */
@@ -66,7 +68,7 @@ declare function createThreadManager<T>(config: ThreadManagerConfig<T>): BaseThr
  * @example
  * const subagentTool = createSubagentTool([
  *   {
- *     name: "researcher",
+ *     agentName: "researcher",
  *     description: "Researches topics and gathers information",
  *     workflow: "researcherWorkflow",
  *     resultSchema: z.object({ findings: z.string() }),
@@ -503,6 +505,8 @@ interface ThreadOps {
     appendHumanMessage(threadId: string, content: string | MessageContent): Promise<void>;
     /** Append a tool result to the thread */
     appendToolResult(config: ToolResultConfig): Promise<void>;
+    /** Append a system message to the thread */
+    appendSystemMessage(threadId: string, content: string): Promise<void>;
 }
 /**
  * Configuration for a Zeitlich agent session
@@ -510,12 +514,16 @@ interface ThreadOps {
 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;
+    threadOps?: ThreadOps;
     /** Tool router for processing tool calls (optional if agent has no tools) */
     tools?: T;
     /** Subagent configurations */
@@ -572,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 */
@@ -910,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.
@@ -947,6 +957,10 @@ interface ZeitlichSharedActivities {
      * Append a human message to a thread.
      */
     appendHumanMessage(threadId: string, content: string | MessageContent): Promise<void>;
+    /**
+     * Append a system message to a thread.
+     */
+    appendSystemMessage(threadId: string, content: string): Promise<void>;
 }
 /**
  * Creates shared Temporal activities for thread management

package/dist/{workflow-PjeURKw4.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 */
@@ -66,7 +68,7 @@ declare function createThreadManager<T>(config: ThreadManagerConfig<T>): BaseThr
  * @example
  * const subagentTool = createSubagentTool([
  *   {
- *     name: "researcher",
+ *     agentName: "researcher",
  *     description: "Researches topics and gathers information",
  *     workflow: "researcherWorkflow",
  *     resultSchema: z.object({ findings: z.string() }),
@@ -503,6 +505,8 @@ interface ThreadOps {
     appendHumanMessage(threadId: string, content: string | MessageContent): Promise<void>;
     /** Append a tool result to the thread */
     appendToolResult(config: ToolResultConfig): Promise<void>;
+    /** Append a system message to the thread */
+    appendSystemMessage(threadId: string, content: string): Promise<void>;
 }
 /**
  * Configuration for a Zeitlich agent session
@@ -510,12 +514,16 @@ interface ThreadOps {
 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;
+    threadOps?: ThreadOps;
     /** Tool router for processing tool calls (optional if agent has no tools) */
     tools?: T;
     /** Subagent configurations */
@@ -572,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 */
@@ -910,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.
@@ -947,6 +957,10 @@ interface ZeitlichSharedActivities {
      * Append a human message to a thread.
      */
     appendHumanMessage(threadId: string, content: string | MessageContent): Promise<void>;
+    /**
+     * Append a system message to a thread.
+     */
+    appendSystemMessage(threadId: string, content: string): Promise<void>;
 }
 /**
  * Creates shared Temporal activities for thread management

package/dist/workflow.cjs

@@ -10,7 +10,7 @@ var z3__default = /*#__PURE__*/_interopDefault(z3);
 // src/lib/session.ts
 var SUBAGENT_TOOL = "Subagent";
 function buildSubagentDescription(subagents) {
-  const subagentList = subagents.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+  const subagentList = subagents.map((s) => `- **${s.agentName}**: ${s.description}`).join("\n");
   return `Launch a new agent to handle complex tasks autonomously.
 
 The ${SUBAGENT_TOOL} tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
@@ -36,7 +36,7 @@ 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: SUBAGENT_TOOL,
     description: buildSubagentDescription(subagents),
@@ -48,15 +48,15 @@ function createSubagentTool(subagents) {
   };
 }
 function createSubagentHandler(subagents) {
-  const { workflowId: parentWorkflowId, taskQueue: parentTaskQueue } = workflow.workflowInfo();
+  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 }
@@ -84,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("Subagent", {
-      ...createSubagentTool(options.subagents),
-      handler: createSubagentHandler(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();
@@ -389,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,
@@ -420,8 +433,11 @@ 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) {
@@ -442,7 +458,7 @@ var createSession = async ({
             try {
               parsedToolCalls.push(toolRouter.parseToolCall(tc));
             } catch (error) {
-              await threadOps.appendToolResult({
+              await appendToolResult({
                 threadId,
                 toolCallId: tc.id ?? "",
                 toolName: tc.name,
@@ -489,7 +505,8 @@ function proxyDefaultThreadOps(options) {
   return {
     initializeThread: activities.initializeThread,
     appendHumanMessage: activities.appendHumanMessage,
-    appendToolResult: activities.appendToolResult
+    appendToolResult: activities.appendToolResult,
+    appendSystemMessage: activities.appendSystemMessage
   };
 }