@axiom-lattice/core 1.0.45 → 1.0.50

package/dist/index.mjs

@@ -351,10 +351,43 @@ var getModelLattice = (key) => modelLatticeManager.getModelLattice(key);
 import z from "zod";
 
 // src/tool_lattice/ToolLatticeManager.ts
-import {
-  tool
-} from "@langchain/core/tools";
-import { interrupt } from "@langchain/langgraph";
+import { tool } from "@langchain/core/tools";
+
+// src/util/genUIMarkdown.ts
+var genUIMarkdown = (type, data) => {
+  return ["```" + type, JSON.stringify(data), "```"].join("\n");
+};
+
+// src/tool_lattice/createToolApproveWrapper.ts
+import { END, interrupt } from "@langchain/langgraph";
+function createToolApproveWrapper(tool_config, toolExecutor) {
+  return async (input, exe_config) => {
+    const messagePrefix = "Tool execution requires approval";
+    const description = `${messagePrefix}
+
+Tool: ${tool_config.name}
+Args: ${JSON.stringify(input, null, 2)}`;
+    const md = genUIMarkdown("confirm", {
+      message: description,
+      tool_call: {
+        tool_call_id: exe_config.id,
+        tool_name: tool_config.name,
+        tool_args: input,
+        tool_config
+      }
+    });
+    const feedback = await interrupt(md);
+    if (feedback.data.action === "yes") {
+      return await toolExecutor(input, exe_config);
+    } else {
+      return {
+        goto: END
+      };
+    }
+  };
+}
+
+// src/tool_lattice/ToolLatticeManager.ts
 var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
   /**
    * 获取ToolLatticeManager单例实例
@@ -378,26 +411,16 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param executor 工具执行函数
    */
   registerLattice(key, config, executor) {
-    let toolExecutor = async (input, exe_config) => {
-      const result = await executor(input, exe_config);
-      return result;
-    };
+    let toolExecutor;
     if (config.needUserApprove) {
+      toolExecutor = createToolApproveWrapper(
+        config,
+        executor
+      );
+    } else {
       toolExecutor = async (input, exe_config) => {
-        const contents = [
-          "```confirm",
-          JSON.stringify({
-            message: "try to " + config.name + ",please confirm the action"
-          }),
-          "```"
-        ].join("\n");
-        const feedback = await interrupt(contents);
-        if (feedback.data.action === "yes") {
-          const result = await executor(input, exe_config);
-          return result;
-        } else {
-          return "user denied the action";
-        }
+        const result = await executor(input, exe_config);
+        return result;
       };
     }
     const toolLattice = {
@@ -512,7 +535,7 @@ var validateToolInput = (key, input) => toolLatticeManager.validateToolInput(key
 registerToolLattice(
   "get_current_date_time",
   {
-    name: "\u83B7\u53D6\u5F53\u524D\u65E5\u671F\u65F6\u95F4",
+    name: "get_current_date_time",
     description: "\u83B7\u53D6\u5F53\u524D\u65E5\u671F\u65F6\u95F4",
     schema: z.object({})
   },
@@ -965,11 +988,6 @@ Results are returned using cat -n format, with line numbers starting at 1
 You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.
 If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.`;
 
-// src/util/genUIMarkdown.ts
-var genUIMarkdown = (type, data) => {
-  return ["```" + type, JSON.stringify(data), "```"].join("\n");
-};
-
 // src/deep_agent/tools.ts
 var writeTodos = tool2(
   (input, config) => {
@@ -1150,7 +1168,8 @@ function createTaskTool(inputs) {
     subagents,
     tools = {},
     model = getModelLattice("default")?.client,
-    stateSchema
+    stateSchema,
+    postModelHook
   } = inputs;
   if (!model) {
     throw new Error("Model not found");
@@ -1178,7 +1197,9 @@ function createTaskTool(inputs) {
       tools: subagentTools,
       stateSchema,
       messageModifier: subagent.prompt,
-      checkpointer: false
+      // checkpointer: false,
+      checkpointer: getCheckpointSaver("default"),
+      postModelHook
     });
     agentsMap.set(subagent.name, reactAgent);
   }
@@ -1370,7 +1391,7 @@ var DeepAgentGraphBuilder = class {
 // src/createPlanExecuteAgent.ts
 import {
   Annotation,
-  END,
+  END as END2,
   GraphInterrupt as GraphInterrupt2,
   START,
   StateGraph,
@@ -1844,7 +1865,7 @@ Only add steps to the plan that still NEED to be done. Do not return previously
     return "continue";
   }
   const workflow = new StateGraph(PlanExecuteState).addNode("planner", planStep).addNode("executor", executeStep).addNode("replanner", replanStep).addEdge(START, "planner").addEdge("planner", "executor").addEdge("executor", "replanner").addConditionalEdges("replanner", shouldEnd, {
-    end: END,
+    end: END2,
     continue: "executor"
   });
   const compiledGraph = workflow.compile({
@@ -2171,17 +2192,333 @@ var getAllAgentConfigs = () => agentLatticeManager.getAllAgentConfigs();
 var validateAgentInput = (key, input) => agentLatticeManager.validateAgentInput(key, input);
 var getAgentClient = (key, options) => agentLatticeManager.initializeClient(key, options);
 
+// src/chunk_buffer_lattice/ChunkBuffer.ts
+var ChunkBuffer = class {
+};
+
+// src/chunk_buffer_lattice/types.ts
+var ThreadStatus = /* @__PURE__ */ ((ThreadStatus2) => {
+  ThreadStatus2["ACTIVE"] = "active";
+  ThreadStatus2["COMPLETED"] = "completed";
+  ThreadStatus2["ABORTED"] = "aborted";
+  return ThreadStatus2;
+})(ThreadStatus || {});
+
+// src/chunk_buffer_lattice/InMemoryChunkBuffer.ts
+var InMemoryChunkBuffer = class extends ChunkBuffer {
+  constructor(config) {
+    super();
+    this.buffers = /* @__PURE__ */ new Map();
+    this.config = {
+      ttl: config?.ttl ?? 60 * 60 * 1e3,
+      cleanupInterval: config?.cleanupInterval ?? 0
+    };
+    if (this.config.cleanupInterval > 0) {
+      this.startCleanupTimer();
+    }
+  }
+  /**
+   * Start automatic periodic cleanup timer
+   */
+  startCleanupTimer() {
+    if (this.config.cleanupInterval <= 0) return;
+    this.cleanupTimer = setInterval(() => {
+      this.cleanupExpiredThreads().catch(console.error);
+    }, this.config.cleanupInterval);
+    if (this.cleanupTimer.unref) {
+      this.cleanupTimer.unref();
+    }
+  }
+  /**
+   * Stop cleanup timer (for cleanup/shutdown)
+   */
+  stopCleanupTimer() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+  }
+  /**
+   * Check if a buffer is expired (lazy cleanup helper)
+   */
+  isExpired(buffer) {
+    return buffer.expiresAt <= Date.now();
+  }
+  /**
+   * Get buffer if valid, perform lazy cleanup if expired
+   */
+  getBufferIfValid(threadId) {
+    const buffer = this.buffers.get(threadId);
+    if (buffer && this.isExpired(buffer)) {
+      this.buffers.delete(threadId);
+      return void 0;
+    }
+    return buffer;
+  }
+  /**
+   * Create or get thread buffer
+   */
+  getOrCreateBuffer(threadId) {
+    let buffer = this.getBufferIfValid(threadId);
+    if (!buffer) {
+      const now = Date.now();
+      buffer = {
+        threadId,
+        chunks: [],
+        status: "active" /* ACTIVE */,
+        createdAt: now,
+        updatedAt: now,
+        expiresAt: now + this.config.ttl
+      };
+      this.buffers.set(threadId, buffer);
+    }
+    return buffer;
+  }
+  async addChunk(threadId, content) {
+    const buffer = this.getOrCreateBuffer(threadId);
+    const chunk = content;
+    buffer.chunks.push(chunk);
+    buffer.updatedAt = Date.now();
+    buffer.expiresAt = Date.now() + this.config.ttl;
+  }
+  async getChunks(threadId) {
+    const buffer = this.getBufferIfValid(threadId);
+    return buffer ? [...buffer.chunks] : [];
+  }
+  async getAccumulatedContent(threadId) {
+    const buffer = this.getBufferIfValid(threadId);
+    if (!buffer) return "";
+    return buffer.chunks.map((chunk) => chunk.data?.content).join("");
+  }
+  async getChunksByMessageId(threadId, messageId) {
+    const buffer = this.getBufferIfValid(threadId);
+    if (!buffer) return [];
+    return buffer.chunks.filter((chunk) => chunk.data?.id === messageId);
+  }
+  async completeThread(threadId) {
+    const buffer = this.getBufferIfValid(threadId);
+    if (buffer) {
+      buffer.status = "completed" /* COMPLETED */;
+      buffer.updatedAt = Date.now();
+    }
+  }
+  async abortThread(threadId) {
+    const buffer = this.getBufferIfValid(threadId);
+    if (buffer) {
+      buffer.status = "aborted" /* ABORTED */;
+      buffer.updatedAt = Date.now();
+    }
+  }
+  async isThreadActive(threadId) {
+    const buffer = this.getBufferIfValid(threadId);
+    return buffer?.status === "active" /* ACTIVE */;
+  }
+  async getThreadStatus(threadId) {
+    return this.getBufferIfValid(threadId)?.status;
+  }
+  async getThreadBuffer(threadId) {
+    const buffer = this.getBufferIfValid(threadId);
+    if (!buffer) return void 0;
+    return {
+      ...buffer,
+      chunks: [...buffer.chunks]
+    };
+  }
+  async clearThread(threadId) {
+    this.buffers.delete(threadId);
+  }
+  async getActiveThreads() {
+    const activeThreads = [];
+    for (const [threadId, buffer] of this.buffers.entries()) {
+      if (this.isExpired(buffer)) {
+        this.buffers.delete(threadId);
+        continue;
+      }
+      if (buffer.status === "active" /* ACTIVE */) {
+        activeThreads.push(threadId);
+      }
+    }
+    return activeThreads;
+  }
+  async getAllThreads() {
+    const validThreads = [];
+    for (const [threadId, buffer] of this.buffers.entries()) {
+      if (this.isExpired(buffer)) {
+        this.buffers.delete(threadId);
+      } else {
+        validThreads.push(threadId);
+      }
+    }
+    return validThreads;
+  }
+  async hasThread(threadId) {
+    return this.getBufferIfValid(threadId) !== void 0;
+  }
+  /**
+   * Cleanup expired threads based on TTL
+   * Returns number of threads cleaned up
+   */
+  async cleanupExpiredThreads() {
+    const now = Date.now();
+    let cleanedCount = 0;
+    for (const [threadId, buffer] of this.buffers.entries()) {
+      if (buffer.expiresAt <= now) {
+        this.buffers.delete(threadId);
+        cleanedCount++;
+      }
+    }
+    return cleanedCount;
+  }
+  /**
+   * Extend thread TTL
+   */
+  async extendThreadTTL(threadId, additionalMs) {
+    const buffer = this.getBufferIfValid(threadId);
+    if (buffer) {
+      const extension = additionalMs ?? this.config.ttl;
+      buffer.expiresAt = Date.now() + extension;
+      buffer.updatedAt = Date.now();
+    }
+  }
+  /**
+   * Get new chunks since known content
+   * Used for resuming streams from a known position
+   * Matches the known content and returns chunks after that position
+   * Continues to yield new chunks as they are added until thread completes/aborts
+   */
+  async *getNewChunksSinceContent(threadId, messageId, knownContent) {
+    let buffer = this.getBufferIfValid(threadId);
+    if (!buffer) return;
+    let lastYieldedIndex = -1;
+    let accumulatedContent = "";
+    for (let i = 0; i < buffer.chunks.length; i++) {
+      const chunk = buffer.chunks[i];
+      if (chunk.data?.id === messageId) {
+        accumulatedContent += chunk.data?.content || "";
+        if (accumulatedContent === knownContent) {
+          lastYieldedIndex = i;
+          break;
+        }
+        if (accumulatedContent.length > knownContent.length) {
+          if (accumulatedContent.startsWith(knownContent)) {
+            lastYieldedIndex = i;
+            break;
+          }
+        }
+      }
+    }
+    const pollingInterval = 100;
+    while (true) {
+      buffer = this.getBufferIfValid(threadId);
+      if (!buffer) break;
+      let hasNewChunks = false;
+      for (let i = lastYieldedIndex + 1; i < buffer.chunks.length; i++) {
+        const chunk = buffer.chunks[i];
+        if (chunk.data?.id === messageId) {
+          yield chunk;
+          lastYieldedIndex = i;
+          hasNewChunks = true;
+        }
+      }
+      if (buffer.status === "completed" /* COMPLETED */ || buffer.status === "aborted" /* ABORTED */) {
+        break;
+      }
+      if (!hasNewChunks) {
+        await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+      }
+    }
+  }
+  /**
+   * Get statistics about the buffer
+   */
+  getStats() {
+    let activeCount = 0;
+    let completedCount = 0;
+    let abortedCount = 0;
+    let totalChunks = 0;
+    const validBuffers = [];
+    for (const [threadId, buffer] of this.buffers.entries()) {
+      if (this.isExpired(buffer)) {
+        this.buffers.delete(threadId);
+      } else {
+        validBuffers.push(buffer);
+      }
+    }
+    for (const buffer of validBuffers) {
+      totalChunks += buffer.chunks.length;
+      switch (buffer.status) {
+        case "active" /* ACTIVE */:
+          activeCount++;
+          break;
+        case "completed" /* COMPLETED */:
+          completedCount++;
+          break;
+        case "aborted" /* ABORTED */:
+          abortedCount++;
+          break;
+      }
+    }
+    return {
+      totalThreads: validBuffers.length,
+      activeThreads: activeCount,
+      completedThreads: completedCount,
+      abortedThreads: abortedCount,
+      totalChunks,
+      config: this.config
+    };
+  }
+  /**
+   * Cleanup method for graceful shutdown
+   */
+  dispose() {
+    this.stopCleanupTimer();
+    this.buffers.clear();
+  }
+};
+
+// src/chunk_buffer_lattice/ChunkBufferLatticeManager.ts
+var ChunkBufferLatticeManager = class _ChunkBufferLatticeManager extends BaseLatticeManager {
+  /**
+   * Private constructor for singleton pattern
+   */
+  constructor() {
+    super();
+  }
+  /**
+   * Get singleton instance
+   */
+  static getInstance() {
+    if (!_ChunkBufferLatticeManager.instance) {
+      _ChunkBufferLatticeManager.instance = new _ChunkBufferLatticeManager();
+    }
+    return _ChunkBufferLatticeManager.instance;
+  }
+  /**
+   * Get Lattice type identifier
+   */
+  getLatticeType() {
+    return "chunk_buffer";
+  }
+};
+var getChunkBuffer = (key) => ChunkBufferLatticeManager.getInstance().get(key);
+var registerChunkBuffer = (key, buffer) => ChunkBufferLatticeManager.getInstance().register(key, buffer);
+var hasChunkBuffer = (key) => ChunkBufferLatticeManager.getInstance().has(key);
+
 // src/index.ts
 import * as Protocols from "@axiom-lattice/protocols";
 export {
   AgentConfig,
   AgentLatticeManager,
   AgentType,
+  ChunkBuffer,
+  ChunkBufferLatticeManager,
   GraphBuildOptions,
+  InMemoryChunkBuffer,
   MemoryLatticeManager,
   MemoryType,
   ModelLatticeManager,
   Protocols,
+  ThreadStatus,
   ToolLatticeManager,
   agentLatticeManager,
   getAgentClient,
@@ -2190,14 +2527,17 @@ export {
   getAllAgentConfigs,
   getAllToolDefinitions,
   getCheckpointSaver,
+  getChunkBuffer,
   getModelLattice,
   getToolClient,
   getToolDefinition,
   getToolLattice,
+  hasChunkBuffer,
   modelLatticeManager,
   registerAgentLattice,
   registerAgentLattices,
   registerCheckpointSaver,
+  registerChunkBuffer,
   registerModelLattice,
   registerToolLattice,
   toolLatticeManager,