zeitlich 0.2.11 → 0.2.13

package/dist/thread-manager-qc0g5Rvd.d.cts

@@ -0,0 +1,39 @@
+import Redis from 'ioredis';
+
+interface ThreadManagerConfig<T> {
+    redis: Redis;
+    threadId: string;
+    /** Thread key, defaults to 'messages' */
+    key?: string;
+    /** Custom serializer, defaults to JSON.stringify */
+    serialize?: (message: T) => string;
+    /** Custom deserializer, defaults to JSON.parse */
+    deserialize?: (raw: string) => T;
+    /**
+     * Extract a unique id from a message for idempotent appends.
+     * When provided, `append` uses an atomic Lua script to skip duplicate writes.
+     */
+    idOf?: (message: T) => string;
+}
+/** Generic thread manager for any message type */
+interface BaseThreadManager<T> {
+    /** Initialize an empty thread */
+    initialize(): Promise<void>;
+    /** Load all messages from the thread */
+    load(): Promise<T[]>;
+    /**
+     * Append messages to the thread.
+     * When `idOf` is configured, appends are idempotent — retries with the
+     * same message ids are atomically skipped via a Redis Lua script.
+     */
+    append(messages: T[]): Promise<void>;
+    /** Delete the thread */
+    delete(): Promise<void>;
+}
+/**
+ * Creates a generic thread manager for handling conversation state in Redis.
+ * Framework-agnostic — works with any serializable message type.
+ */
+declare function createThreadManager<T>(config: ThreadManagerConfig<T>): BaseThreadManager<T>;
+
+export { type BaseThreadManager as B, type ThreadManagerConfig as T, createThreadManager as c };

package/dist/thread-manager-qc0g5Rvd.d.ts

@@ -0,0 +1,39 @@
+import Redis from 'ioredis';
+
+interface ThreadManagerConfig<T> {
+    redis: Redis;
+    threadId: string;
+    /** Thread key, defaults to 'messages' */
+    key?: string;
+    /** Custom serializer, defaults to JSON.stringify */
+    serialize?: (message: T) => string;
+    /** Custom deserializer, defaults to JSON.parse */
+    deserialize?: (raw: string) => T;
+    /**
+     * Extract a unique id from a message for idempotent appends.
+     * When provided, `append` uses an atomic Lua script to skip duplicate writes.
+     */
+    idOf?: (message: T) => string;
+}
+/** Generic thread manager for any message type */
+interface BaseThreadManager<T> {
+    /** Initialize an empty thread */
+    initialize(): Promise<void>;
+    /** Load all messages from the thread */
+    load(): Promise<T[]>;
+    /**
+     * Append messages to the thread.
+     * When `idOf` is configured, appends are idempotent — retries with the
+     * same message ids are atomically skipped via a Redis Lua script.
+     */
+    append(messages: T[]): Promise<void>;
+    /** Delete the thread */
+    delete(): Promise<void>;
+}
+/**
+ * Creates a generic thread manager for handling conversation state in Redis.
+ * Framework-agnostic — works with any serializable message type.
+ */
+declare function createThreadManager<T>(config: ThreadManagerConfig<T>): BaseThreadManager<T>;
+
+export { type BaseThreadManager as B, type ThreadManagerConfig as T, createThreadManager as c };

package/dist/workflow.cjs

@@ -10,8 +10,11 @@ var z14__default = /*#__PURE__*/_interopDefault(z14);
 // 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:
@@ -23,16 +26,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__default.default.enum(names).describe("The type of subagent to launch"),
+    description: z14__default.default.string().describe("A short (3-5 word) description of the task"),
+    prompt: z14__default.default.string().describe("The task for the agent to perform")
+  };
+  const schema = hasThreadContinuation ? z14__default.default.object({
+    ...baseFields,
+    threadId: z14__default.default.string().nullable().describe(
+      "Thread ID to continue an existing conversation, or null to start a new one"
+    )
+  }) : z14__default.default.object(baseFields);
   return {
     name: SUBAGENT_TOOL_NAME,
     description: buildSubagentDescription(subagents),
-    schema: z14__default.default.object({
-      subagent: z14__default.default.enum(names).describe("The type of subagent to launch"),
-      description: z14__default.default.string().describe("A short (3-5 word) description of the task"),
-      prompt: z14__default.default.string().describe("The task for the agent to perform")
-    })
+    schema
   };
 }
+var BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function getShortId(length = 12) {
+  const hex = workflow.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 } = workflow.workflowInfo();
   return async (args) => {
@@ -42,17 +67,18 @@ function createSubagentHandler(subagents) {
         `Unknown subagent: ${args.subagent}. Available: ${subagents.map((s) => s.agentName).join(", ")}`
       );
     }
-    const childWorkflowId = `${args.subagent}-${workflow.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 workflow.executeChild(config.workflow, childOpts) : await workflow.executeChild(config.workflow, childOpts);
+    const { toolResponse, data, usage, threadId: childThreadId } = typeof config.workflow === "string" ? await workflow.executeChild(config.workflow, childOpts) : await workflow.executeChild(config.workflow, childOpts);
     if (!toolResponse) {
       return {
         toolResponse: "Subagent workflow returned no response",
@@ -68,8 +94,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 }
     };
@@ -438,7 +470,7 @@ function hasNoOtherToolCalls(toolCalls, excludeName) {
 
 // src/lib/session.ts
 var createSession = async ({
-  threadId,
+  threadId: providedThreadId,
   agentName,
   maxTurns = 50,
   metadata = {},
@@ -451,8 +483,10 @@ var createSession = async ({
   processToolsInParallel = true,
   hooks = {},
   appendSystemPrompt = true,
+  continueThread = false,
   waitForInputTimeout = "48h"
 }) => {
+  const threadId = providedThreadId ?? getShortId();
   const {
     appendToolResult,
     appendHumanMessage,
@@ -510,15 +544,18 @@ var createSession = async ({
         });
       }
       const systemPrompt = stateManager.getSystemPrompt();
-      await initializeThread(threadId);
-      if (appendSystemPrompt) {
-        if (!systemPrompt || systemPrompt.trim() === "") {
-          throw workflow.ApplicationFailure.create({
-            message: "No system prompt in state",
-            nonRetryable: true
-          });
+      if (!continueThread) {
+        if (appendSystemPrompt) {
+          if (!systemPrompt || systemPrompt.trim() === "") {
+            throw workflow.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";
@@ -600,7 +637,7 @@ var createSession = async ({
   };
 };
 function proxyDefaultThreadOps(options) {
-  const activities = workflow.proxyActivities(
+  return workflow.proxyActivities(
     options ?? {
       startToCloseTimeout: "10s",
       retry: {
@@ -611,12 +648,6 @@ function proxyDefaultThreadOps(options) {
       }
     }
   );
-  return {
-    initializeThread: activities.initializeThread,
-    appendHumanMessage: activities.appendHumanMessage,
-    appendToolResult: activities.appendToolResult,
-    appendSystemMessage: activities.appendSystemMessage
-  };
 }
 
 // src/lib/types.ts
@@ -1222,6 +1253,7 @@ exports.createToolRouter = createToolRouter;
 exports.defineSubagent = defineSubagent;
 exports.defineTool = defineTool;
 exports.editTool = editTool;
+exports.getShortId = getShortId;
 exports.globTool = globTool;
 exports.grepTool = grepTool;
 exports.hasNoOtherToolCalls = hasNoOtherToolCalls;