zeitlich 0.2.11 → 0.2.13

package/dist/index.js

@@ -1,8 +1,5 @@
-import { setHandler, defineUpdate, ApplicationFailure, condition, proxyActivities, defineQuery, uuid4, workflowInfo, executeChild } from '@temporalio/workflow';
+import { uuid4, setHandler, defineUpdate, ApplicationFailure, condition, proxyActivities, defineQuery, workflowInfo, executeChild } from '@temporalio/workflow';
 import z14, { z } from 'zod';
-import { SimplePlugin } from '@temporalio/plugin';
-import { mapStoredMessagesToChatMessages, ToolMessage, AIMessage, SystemMessage, HumanMessage } from '@langchain/core/messages';
-import { randomUUID, randomFillSync } from 'crypto';
 import { Context } from '@temporalio/activity';
 import { Bash } from 'just-bash';
 import { readFile, readdir } from 'fs/promises';
@@ -11,8 +8,11 @@ import { join } from 'path';
 // src/lib/session.ts
 var SUBAGENT_TOOL_NAME = "Subagent";
 function buildSubagentDescription(subagents) {
-  const subagentList = subagents.map((s) => `## ${s.agentName}
-${s.description}`).join("\n\n");
+  const subagentList = subagents.map((s) => {
+    const continuation = s.allowThreadContinuation ? "\n*(Supports thread continuation \u2014 pass a threadId to resume a previous conversation)*" : "";
+    return `## ${s.agentName}
+${s.description}${continuation}`;
+  }).join("\n\n");
   return `The ${SUBAGENT_TOOL_NAME} tool launches specialized agents (subagents) that autonomously handle complex work. Each agent type has specific capabilities and tools available to it.
 
 # Available subagents:
@@ -24,16 +24,38 @@ function createSubagentTool(subagents) {
     throw new Error("createTaskTool requires at least one subagent");
   }
   const names = subagents.map((s) => s.agentName);
+  const hasThreadContinuation = subagents.some(
+    (s) => s.allowThreadContinuation
+  );
+  const baseFields = {
+    subagent: z14.enum(names).describe("The type of subagent to launch"),
+    description: z14.string().describe("A short (3-5 word) description of the task"),
+    prompt: z14.string().describe("The task for the agent to perform")
+  };
+  const schema = hasThreadContinuation ? z14.object({
+    ...baseFields,
+    threadId: z14.string().nullable().describe(
+      "Thread ID to continue an existing conversation, or null to start a new one"
+    )
+  }) : z14.object(baseFields);
   return {
     name: SUBAGENT_TOOL_NAME,
     description: buildSubagentDescription(subagents),
-    schema: z14.object({
-      subagent: z14.enum(names).describe("The type of subagent to launch"),
-      description: z14.string().describe("A short (3-5 word) description of the task"),
-      prompt: z14.string().describe("The task for the agent to perform")
-    })
+    schema
   };
 }
+var BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function getShortId(length = 12) {
+  const hex = uuid4().replace(/-/g, "");
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    const byte = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    result += BASE62[byte % BASE62.length];
+  }
+  return result;
+}
+
+// src/tools/subagent/handler.ts
 function createSubagentHandler(subagents) {
   const { taskQueue: parentTaskQueue } = workflowInfo();
   return async (args) => {
@@ -43,17 +65,18 @@ function createSubagentHandler(subagents) {
         `Unknown subagent: ${args.subagent}. Available: ${subagents.map((s) => s.agentName).join(", ")}`
       );
     }
-    const childWorkflowId = `${args.subagent}-${uuid4()}`;
+    const childWorkflowId = `${args.subagent}-${getShortId()}`;
     const input = {
       prompt: args.prompt,
-      ...config.context && { context: config.context }
+      ...config.context && { context: config.context },
+      ...args.threadId && config.allowThreadContinuation && { threadId: args.threadId }
     };
     const childOpts = {
       workflowId: childWorkflowId,
       args: [input],
       taskQueue: config.taskQueue ?? parentTaskQueue
     };
-    const { toolResponse, data, usage } = typeof config.workflow === "string" ? await executeChild(config.workflow, childOpts) : await executeChild(config.workflow, childOpts);
+    const { toolResponse, data, usage, threadId: childThreadId } = typeof config.workflow === "string" ? await executeChild(config.workflow, childOpts) : await executeChild(config.workflow, childOpts);
     if (!toolResponse) {
       return {
         toolResponse: "Subagent workflow returned no response",
@@ -69,8 +92,14 @@ function createSubagentHandler(subagents) {
         ...usage && { usage }
       };
     }
+    let finalToolResponse = toolResponse;
+    if (config.allowThreadContinuation && childThreadId) {
+      finalToolResponse = typeof toolResponse === "string" ? `${toolResponse}
+
+[Thread ID: ${childThreadId}]` : toolResponse;
+    }
     return {
-      toolResponse,
+      toolResponse: finalToolResponse,
       data: validated ? validated.data : data,
       ...usage && { usage }
     };
@@ -458,7 +487,7 @@ function hasNoOtherToolCalls(toolCalls, excludeName) {
 
 // src/lib/session.ts
 var createSession = async ({
-  threadId,
+  threadId: providedThreadId,
   agentName,
   maxTurns = 50,
   metadata = {},
@@ -471,8 +500,10 @@ var createSession = async ({
   processToolsInParallel = true,
   hooks = {},
   appendSystemPrompt = true,
+  continueThread = false,
   waitForInputTimeout = "48h"
 }) => {
+  const threadId = providedThreadId ?? getShortId();
   const {
     appendToolResult,
     appendHumanMessage,
@@ -530,15 +561,18 @@ var createSession = async ({
         });
       }
       const systemPrompt = stateManager.getSystemPrompt();
-      await initializeThread(threadId);
-      if (appendSystemPrompt) {
-        if (!systemPrompt || systemPrompt.trim() === "") {
-          throw ApplicationFailure.create({
-            message: "No system prompt in state",
-            nonRetryable: true
-          });
+      if (!continueThread) {
+        if (appendSystemPrompt) {
+          if (!systemPrompt || systemPrompt.trim() === "") {
+            throw ApplicationFailure.create({
+              message: "No system prompt in state",
+              nonRetryable: true
+            });
+          }
+          await appendSystemMessage(threadId, systemPrompt);
+        } else {
+          await initializeThread(threadId);
         }
-        await appendSystemMessage(threadId, systemPrompt);
       }
       await appendHumanMessage(threadId, await buildContextMessage());
       let exitReason = "completed";
@@ -620,7 +654,7 @@ var createSession = async ({
   };
 };
 function proxyDefaultThreadOps(options) {
-  const activities = proxyActivities(
+  return proxyActivities(
     options ?? {
       startToCloseTimeout: "10s",
       retry: {
@@ -631,12 +665,6 @@ function proxyDefaultThreadOps(options) {
       }
     }
   );
-  return {
-    initializeThread: activities.initializeThread,
-    appendHumanMessage: activities.appendHumanMessage,
-    appendToolResult: activities.appendToolResult,
-    appendSystemMessage: activities.appendSystemMessage
-  };
 }
 
 // src/lib/types.ts
@@ -1223,51 +1251,6 @@ var createAskUserQuestionHandler = () => async (args) => {
   };
 };
 
-// node_modules/uuid/dist/esm/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) {
-    randomFillSync(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-var native_default = { randomUUID };
-
-// node_modules/uuid/dist/esm/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();
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    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;
 var APPEND_IDEMPOTENT_SCRIPT = `
@@ -1284,29 +1267,36 @@ return 1
 function getThreadKey(threadId, key) {
   return `thread:${threadId}:${key}`;
 }
-function storedMessageId(msg) {
-  return msg.data.id ?? "";
-}
 function createThreadManager(config) {
   const {
     redis,
     threadId,
     key = "messages",
     serialize = (m) => JSON.stringify(m),
-    deserialize = (raw) => JSON.parse(raw)
+    deserialize = (raw) => JSON.parse(raw),
+    idOf
   } = config;
   const redisKey = getThreadKey(threadId, key);
-  const idOf = config.idOf ?? (!config.serialize ? storedMessageId : void 0);
-  const base = {
+  const metaKey = getThreadKey(threadId, `${key}:meta`);
+  async function assertThreadExists() {
+    const exists = await redis.exists(metaKey);
+    if (!exists) {
+      throw new Error(`Thread "${threadId}" (key: ${key}) does not exist`);
+    }
+  }
+  return {
     async initialize() {
       await redis.del(redisKey);
+      await redis.set(metaKey, "1", "EX", THREAD_TTL_SECONDS);
     },
     async load() {
+      await assertThreadExists();
       const data = await redis.lrange(redisKey, 0, -1);
       return data.map(deserialize);
     },
     async append(messages) {
       if (messages.length === 0) return;
+      await assertThreadExists();
       if (idOf) {
         const dedupId = messages.map(idOf).join(":");
         const dedupKey = getThreadKey(threadId, `dedup:${dedupId}`);
@@ -1324,135 +1314,25 @@ function createThreadManager(config) {
       }
     },
     async delete() {
-      await redis.del(redisKey);
-    }
-  };
-  const helpers = {
-    createHumanMessage(content) {
-      return new HumanMessage({
-        id: v4_default(),
-        content
-      }).toDict();
-    },
-    createSystemMessage(content) {
-      return new SystemMessage({
-        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({
-        id: v4_default(),
-        content,
-        tool_call_id: toolCallId
-      }).toDict();
-    },
-    async appendHumanMessage(content) {
-      const message = helpers.createHumanMessage(content);
-      await base.append([message]);
-    },
-    async appendToolMessage(content, toolCallId) {
-      const message = helpers.createToolMessage(content, toolCallId);
-      await base.append([message]);
-    },
-    async appendAIMessage(content) {
-      const message = helpers.createAIMessage(content);
-      await base.append([message]);
-    },
-    async appendSystemMessage(content) {
-      const message = helpers.createSystemMessage(content);
-      await base.append([message]);
-    }
-  };
-  return Object.assign(base, helpers);
-}
-
-// src/activities.ts
-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 appendSystemMessage(threadId, content) {
-      const thread = createThreadManager({ redis, threadId });
-      await thread.appendSystemMessage(content);
+      await redis.del(redisKey, metaKey);
     }
   };
 }
-
-// src/plugin.ts
-var ZeitlichPlugin = class extends SimplePlugin {
-  constructor(options) {
-    super({
-      name: "ZeitlichPlugin",
-      activities: createSharedActivities(options.redis)
-    });
-  }
-};
-async function invokeModel({
-  redis,
-  model,
-  client,
-  config: { threadId, agentName }
-}) {
-  const thread = createThreadManager({ redis, threadId });
-  const runId = v4_default();
-  const info = Context.current().info;
-  const parentWorkflowId = info.workflowExecution.workflowId;
-  const parentRunId = info.workflowExecution.runId;
-  const handle = client.getHandle(parentWorkflowId, parentRunId);
-  const { tools } = await handle.query(agentQueryName(agentName));
-  const messages = await thread.load();
-  const response = await model.invoke(
-    [...mapStoredMessagesToChatMessages(messages)],
-    {
-      runName: agentName,
-      runId,
-      metadata: { thread_id: threadId },
-      tools
-    }
+async function queryParentWorkflowState(client, queryName) {
+  const { workflowExecution } = Context.current().info;
+  const handle = client.getHandle(
+    workflowExecution.workflowId,
+    workflowExecution.runId
   );
-  await thread.append([response.toDict()]);
-  const toolCalls = response.tool_calls ?? [];
-  return {
-    message: response.toDict(),
-    rawToolCalls: toolCalls.map((tc) => ({
-      id: tc.id,
-      name: tc.name,
-      args: tc.args
-    })),
-    usage: {
-      inputTokens: response.usage_metadata?.input_tokens,
-      outputTokens: response.usage_metadata?.output_tokens,
-      reasonTokens: response.usage_metadata?.output_token_details?.reasoning,
-      cachedWriteTokens: response.usage_metadata?.input_token_details?.cache_creation,
-      cachedReadTokens: response.usage_metadata?.input_token_details?.cache_read
-    }
+  return handle.query(queryName);
+}
+function createRunAgentActivity(client, invoker) {
+  return async (config) => {
+    const state = await queryParentWorkflowState(
+      client,
+      agentQueryName(config.agentName)
+    );
+    return invoker({ ...config, state });
   };
 }
 function createGlobHandler(fs) {
@@ -1679,6 +1559,6 @@ var FileSystemSkillProvider = class {
   }
 };
 
-export { FileSystemSkillProvider, ZeitlichPlugin, agentQueryName, agentStateChangeUpdateName, askUserQuestionTool, bashTool, createAgentStateManager, createAskUserQuestionHandler, createBashHandler, createBashToolDescription, createEditHandler, createGlobHandler, createReadSkillHandler, createReadSkillTool, createSession, createSharedActivities, createSubagentTool, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createThreadManager, createToolRouter, defineSubagent, defineTool, editTool, globTool, grepTool, hasNoOtherToolCalls, invokeModel, isTerminalStatus, parseSkillFile, proxyDefaultThreadOps, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, withAutoAppend, writeFileTool };
+export { FileSystemSkillProvider, agentQueryName, agentStateChangeUpdateName, askUserQuestionTool, bashTool, createAgentStateManager, createAskUserQuestionHandler, createBashHandler, createBashToolDescription, createEditHandler, createGlobHandler, createReadSkillHandler, createReadSkillTool, createRunAgentActivity, createSession, createSubagentTool, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createThreadManager, createToolRouter, defineSubagent, defineTool, editTool, getShortId, globTool, grepTool, hasNoOtherToolCalls, isTerminalStatus, parseSkillFile, proxyDefaultThreadOps, queryParentWorkflowState, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, withAutoAppend, writeFileTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map