@axiom-lattice/core 1.0.45 → 1.0.50

package/dist/index.js

@@ -33,11 +33,15 @@ __export(index_exports, {
   AgentConfig: () => import_protocols.AgentConfig,
   AgentLatticeManager: () => AgentLatticeManager,
   AgentType: () => import_protocols.AgentType,
+  ChunkBuffer: () => ChunkBuffer,
+  ChunkBufferLatticeManager: () => ChunkBufferLatticeManager,
   GraphBuildOptions: () => import_protocols.GraphBuildOptions,
+  InMemoryChunkBuffer: () => InMemoryChunkBuffer,
   MemoryLatticeManager: () => MemoryLatticeManager,
   MemoryType: () => import_protocols2.MemoryType,
   ModelLatticeManager: () => ModelLatticeManager,
   Protocols: () => Protocols,
+  ThreadStatus: () => ThreadStatus,
   ToolLatticeManager: () => ToolLatticeManager,
   agentLatticeManager: () => agentLatticeManager,
   getAgentClient: () => getAgentClient,
@@ -46,14 +50,17 @@ __export(index_exports, {
   getAllAgentConfigs: () => getAllAgentConfigs,
   getAllToolDefinitions: () => getAllToolDefinitions,
   getCheckpointSaver: () => getCheckpointSaver,
+  getChunkBuffer: () => getChunkBuffer,
   getModelLattice: () => getModelLattice,
   getToolClient: () => getToolClient,
   getToolDefinition: () => getToolDefinition,
   getToolLattice: () => getToolLattice,
+  hasChunkBuffer: () => hasChunkBuffer,
   modelLatticeManager: () => modelLatticeManager,
   registerAgentLattice: () => registerAgentLattice,
   registerAgentLattices: () => registerAgentLattices,
   registerCheckpointSaver: () => registerCheckpointSaver,
+  registerChunkBuffer: () => registerChunkBuffer,
   registerModelLattice: () => registerModelLattice,
   registerToolLattice: () => registerToolLattice,
   toolLatticeManager: () => toolLatticeManager,
@@ -412,7 +419,42 @@ var import_zod = __toESM(require("zod"));
 
 // src/tool_lattice/ToolLatticeManager.ts
 var import_tools = require("@langchain/core/tools");
+
+// src/util/genUIMarkdown.ts
+var genUIMarkdown = (type, data) => {
+  return ["```" + type, JSON.stringify(data), "```"].join("\n");
+};
+
+// src/tool_lattice/createToolApproveWrapper.ts
 var import_langgraph = require("@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 (0, import_langgraph.interrupt)(md);
+    if (feedback.data.action === "yes") {
+      return await toolExecutor(input, exe_config);
+    } else {
+      return {
+        goto: import_langgraph.END
+      };
+    }
+  };
+}
+
+// src/tool_lattice/ToolLatticeManager.ts
 var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
   /**
    * 获取ToolLatticeManager单例实例
@@ -436,26 +478,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 (0, import_langgraph.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 = {
@@ -570,7 +602,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: import_zod.default.object({})
   },
@@ -1015,11 +1047,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 = (0, import_tools2.tool)(
   (input, config) => {
@@ -1200,7 +1227,8 @@ function createTaskTool(inputs) {
     subagents,
     tools = {},
     model = getModelLattice("default")?.client,
-    stateSchema
+    stateSchema,
+    postModelHook
   } = inputs;
   if (!model) {
     throw new Error("Model not found");
@@ -1228,7 +1256,9 @@ function createTaskTool(inputs) {
       tools: subagentTools,
       stateSchema,
       messageModifier: subagent.prompt,
-      checkpointer: false
+      // checkpointer: false,
+      checkpointer: getCheckpointSaver("default"),
+      postModelHook
     });
     agentsMap.set(subagent.name, reactAgent);
   }
@@ -2210,6 +2240,318 @@ 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
 var Protocols = __toESM(require("@axiom-lattice/protocols"));
 // Annotate the CommonJS export names for ESM import in node:
@@ -2217,11 +2559,15 @@ var Protocols = __toESM(require("@axiom-lattice/protocols"));
   AgentConfig,
   AgentLatticeManager,
   AgentType,
+  ChunkBuffer,
+  ChunkBufferLatticeManager,
   GraphBuildOptions,
+  InMemoryChunkBuffer,
   MemoryLatticeManager,
   MemoryType,
   ModelLatticeManager,
   Protocols,
+  ThreadStatus,
   ToolLatticeManager,
   agentLatticeManager,
   getAgentClient,
@@ -2230,14 +2576,17 @@ var Protocols = __toESM(require("@axiom-lattice/protocols"));
   getAllAgentConfigs,
   getAllToolDefinitions,
   getCheckpointSaver,
+  getChunkBuffer,
   getModelLattice,
   getToolClient,
   getToolDefinition,
   getToolLattice,
+  hasChunkBuffer,
   modelLatticeManager,
   registerAgentLattice,
   registerAgentLattices,
   registerCheckpointSaver,
+  registerChunkBuffer,
   registerModelLattice,
   registerToolLattice,
   toolLatticeManager,