@axiom-lattice/core 2.1.2 → 2.1.4

package/dist/index.js

@@ -30,20 +30,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AGENT_TASK_EVENT: () => AGENT_TASK_EVENT,
   AgentConfig: () => import_protocols.AgentConfig,
   AgentLatticeManager: () => AgentLatticeManager,
+  AgentManager: () => AgentManager,
   AgentType: () => import_protocols.AgentType,
   ChunkBuffer: () => ChunkBuffer,
   ChunkBufferLatticeManager: () => ChunkBufferLatticeManager,
   GraphBuildOptions: () => import_protocols.GraphBuildOptions,
   InMemoryChunkBuffer: () => InMemoryChunkBuffer,
   MemoryLatticeManager: () => MemoryLatticeManager,
+  MemoryQueueClient: () => MemoryQueueClient,
   MemoryType: () => import_protocols2.MemoryType,
   ModelLatticeManager: () => ModelLatticeManager,
   Protocols: () => Protocols,
+  QueueLatticeManager: () => QueueLatticeManager,
   ThreadStatus: () => ThreadStatus,
   ToolLatticeManager: () => ToolLatticeManager,
   agentLatticeManager: () => agentLatticeManager,
+  eventBus: () => eventBus,
+  eventBusDefault: () => event_bus_default,
   getAgentClient: () => getAgentClient,
   getAgentConfig: () => getAgentConfig,
   getAgentLattice: () => getAgentLattice,
@@ -52,16 +58,19 @@ __export(index_exports, {
   getCheckpointSaver: () => getCheckpointSaver,
   getChunkBuffer: () => getChunkBuffer,
   getModelLattice: () => getModelLattice,
+  getQueueLattice: () => getQueueLattice,
   getToolClient: () => getToolClient,
   getToolDefinition: () => getToolDefinition,
   getToolLattice: () => getToolLattice,
   hasChunkBuffer: () => hasChunkBuffer,
   modelLatticeManager: () => modelLatticeManager,
+  queueLatticeManager: () => queueLatticeManager,
   registerAgentLattice: () => registerAgentLattice,
   registerAgentLattices: () => registerAgentLattices,
   registerCheckpointSaver: () => registerCheckpointSaver,
   registerChunkBuffer: () => registerChunkBuffer,
   registerModelLattice: () => registerModelLattice,
+  registerQueueLattice: () => registerQueueLattice,
   registerToolLattice: () => registerToolLattice,
   toolLatticeManager: () => toolLatticeManager,
   validateAgentInput: () => validateAgentInput,
@@ -627,7 +636,7 @@ registerToolLattice(
   {
     name: "internet_search",
     description: "Run a web search",
-    needUserApprove: false,
+    needUserApprove: true,
     schema: import_zod2.default.object({
       query: import_zod2.default.string().describe("The search query"),
       maxResults: import_zod2.default.number().optional().default(5).describe("Maximum number of results to return"),
@@ -1519,8 +1528,402 @@ ${systemPrompt}` : systemPrompt;
 // src/deep_agent_new/middleware/subagents.ts
 var import_v32 = require("zod/v3");
 var import_langchain3 = require("langchain");
-var import_langgraph5 = require("@langchain/langgraph");
+var import_langgraph6 = require("@langchain/langgraph");
 var import_messages = require("@langchain/core/messages");
+
+// src/agent_worker/agent_worker_graph.ts
+var import_langgraph5 = require("@langchain/langgraph");
+
+// src/constants/agent_task_types.ts
+var AGENT_TASK_EVENT = "agent:execute";
+
+// src/services/event_bus.ts
+var import_events = require("events");
+
+// src/queue_lattice/QueueLatticeManager.ts
+var import_protocols3 = require("@axiom-lattice/protocols");
+
+// src/queue_lattice/MemoryQueueClient.ts
+var queues = /* @__PURE__ */ new Map();
+var ensureQueue = (queueName) => {
+  if (!queues.has(queueName)) {
+    queues.set(queueName, []);
+  }
+};
+var MemoryQueueClient = class {
+  constructor(queueName = "tasks") {
+    this.queueName = queueName;
+    ensureQueue(this.queueName);
+  }
+  /**
+   * Enqueue message (equivalent to lPush - push to left/beginning)
+   */
+  async push(item) {
+    try {
+      ensureQueue(this.queueName);
+      const queue = queues.get(this.queueName);
+      queue.unshift(item);
+      const result = queue.length;
+      console.log("lPush (memory)", result);
+      return { data: result, error: null };
+    } catch (error) {
+      console.error(error);
+      return { data: null, error };
+    }
+  }
+  /**
+   * Dequeue message (equivalent to rPop - pop from right/end)
+   */
+  async pop() {
+    try {
+      ensureQueue(this.queueName);
+      const queue = queues.get(this.queueName);
+      const message = queue.pop();
+      if (message) {
+        return { data: message, error: null };
+      }
+      return { data: null, error: null };
+    } catch (error) {
+      console.error(error);
+      return { data: null, error };
+    }
+  }
+  /**
+   * Create queue (initialize in memory)
+   */
+  async createQueue() {
+    try {
+      ensureQueue(this.queueName);
+      const queue = queues.get(this.queueName);
+      const exists = queue !== void 0;
+      return { success: true, queue_name: this.queueName };
+    } catch (error) {
+      console.error(error);
+      return { success: false, error };
+    }
+  }
+};
+
+// src/queue_lattice/QueueLatticeManager.ts
+var QueueLatticeManager = class _QueueLatticeManager extends BaseLatticeManager {
+  /**
+   * Get QueueLatticeManager singleton instance
+   */
+  static getInstance() {
+    if (!_QueueLatticeManager._instance) {
+      _QueueLatticeManager._instance = new _QueueLatticeManager();
+    }
+    return _QueueLatticeManager._instance;
+  }
+  /**
+   * Get Lattice type prefix
+   */
+  getLatticeType() {
+    return "queues";
+  }
+  /**
+   * Register queue Lattice
+   * @param key Lattice key name
+   * @param config Queue configuration
+   * @param client Optional queue client. If not provided, will create based on config type.
+   *               For REDIS type, client must be provided (use @axiom-lattice/queue-redis).
+   */
+  registerLattice(key, config, client) {
+    let queueClient;
+    if (client) {
+      queueClient = client;
+    } else {
+      const queueName = config.queueName || process.env.QUEUE_NAME || "tasks";
+      if (config.type === import_protocols3.QueueType.REDIS) {
+        throw new Error(
+          `Redis queue client must be provided. Please install @axiom-lattice/queue-redis and pass the client to registerLattice. Example: registerLattice(key, config, new RedisQueueClient(queueName, options))`
+        );
+      } else {
+        queueClient = new MemoryQueueClient(queueName);
+      }
+    }
+    const queueLattice = {
+      key,
+      config,
+      client: queueClient,
+      push: async (item) => {
+        return queueClient.push(item);
+      },
+      pop: async () => {
+        return queueClient.pop();
+      },
+      createQueue: queueClient.createQueue ? async () => {
+        return queueClient.createQueue();
+      } : void 0
+    };
+    this.register(key, queueLattice);
+  }
+  /**
+   * Get QueueLattice
+   * @param key Lattice key name
+   */
+  getQueueLattice(key) {
+    const queueLattice = this.get(key);
+    if (!queueLattice) {
+      throw new Error(`QueueLattice ${key} not found`);
+    }
+    return queueLattice;
+  }
+  /**
+   * Get all Lattices
+   */
+  getAllLattices() {
+    return this.getAll();
+  }
+  /**
+   * Check if Lattice exists
+   * @param key Lattice key name
+   */
+  hasLattice(key) {
+    return this.has(key);
+  }
+  /**
+   * Remove Lattice
+   * @param key Lattice key name
+   */
+  removeLattice(key) {
+    return this.remove(key);
+  }
+  /**
+   * Clear all Lattices
+   */
+  clearLattices() {
+    this.clear();
+  }
+  /**
+   * Get Lattice count
+   */
+  getLatticeCount() {
+    return this.count();
+  }
+  /**
+   * Get Lattice key list
+   */
+  getLatticeKeys() {
+    return this.keys();
+  }
+};
+var queueLatticeManager = QueueLatticeManager.getInstance();
+var registerQueueLattice = (key, config, client) => queueLatticeManager.registerLattice(key, config, client);
+var getQueueLattice = (key) => queueLatticeManager.getQueueLattice(key);
+
+// src/services/event_bus.ts
+var EventBus = class {
+  constructor() {
+    this.defaultQueueKey = "default";
+    this.emitter = new import_events.EventEmitter();
+    this.emitter.setMaxListeners(100);
+  }
+  /**
+   * Set the default queue key for queue operations
+   * @param queueKey Queue key name
+   */
+  setDefaultQueueKey(queueKey) {
+    this.defaultQueueKey = queueKey;
+  }
+  /**
+   * Publish event
+   * @param eventName Event name
+   * @param data Event data
+   * @param useQueue Whether to use queue for publishing
+   */
+  publish(eventName, data, useQueue = false) {
+    if (useQueue) {
+      if (queueLatticeManager.hasLattice(this.defaultQueueKey)) {
+        const queue = queueLatticeManager.getQueueLattice(this.defaultQueueKey);
+        queue.push(data).catch((error) => {
+          console.error("Failed to push event to queue:", error);
+        });
+      } else {
+        console.warn(
+          `Queue "${this.defaultQueueKey}" not found. Event will not be queued.`
+        );
+      }
+    } else {
+      this.emitter.emit(eventName, data);
+    }
+  }
+  /**
+   * Subscribe to event
+   * @param eventName Event name
+   * @param callback Callback function
+   */
+  subscribe(eventName, callback) {
+    this.emitter.on(eventName, callback);
+  }
+  /**
+   * Unsubscribe from event
+   * @param eventName Event name
+   * @param callback Callback function
+   */
+  unsubscribe(eventName, callback) {
+    this.emitter.off(eventName, callback);
+  }
+  /**
+   * Subscribe to event once
+   * @param eventName Event name
+   * @param callback Callback function
+   */
+  subscribeOnce(eventName, callback) {
+    this.emitter.once(eventName, callback);
+  }
+};
+var eventBus = new EventBus();
+var event_bus_default = eventBus;
+
+// src/services/AgentManager.ts
+var AgentManager = class _AgentManager {
+  constructor() {
+    this.agents = [];
+  }
+  static getInstance() {
+    if (!_AgentManager.instance) {
+      _AgentManager.instance = new _AgentManager();
+    }
+    return _AgentManager.instance;
+  }
+  callAgentInQueue(queue, return_agent_state) {
+    return new Promise((resolve, reject) => {
+      const callback_event = `${queue.assistant_id}::${queue.thread_id}`;
+      if (return_agent_state) {
+        event_bus_default.subscribeOnce(callback_event, (data) => {
+          if (data.success) {
+            console.log("AgentManager callAgentInQueue success", data);
+            resolve(data.state);
+          } else {
+            console.log("AgentManager callAgentInQueue error", data);
+            reject(data.error);
+          }
+        });
+      }
+      try {
+        event_bus_default.publish(
+          AGENT_TASK_EVENT,
+          {
+            ...queue,
+            callback_event
+          },
+          true
+        );
+        !return_agent_state && resolve({ callback_event_id: callback_event, success: true });
+      } catch (error) {
+        !return_agent_state && reject({
+          callback_event_id: callback_event,
+          success: false,
+          error
+        });
+      }
+    });
+  }
+};
+
+// src/agent_worker/agent_worker_graph.ts
+var AgentWorkerState = import_langgraph5.Annotation.Root({
+  // Input parameters
+  assistant_id: (0, import_langgraph5.Annotation)({
+    reducer: (x, y) => y ?? x,
+    default: () => ""
+  }),
+  thread_id: (0, import_langgraph5.Annotation)({
+    reducer: (x, y) => y ?? x,
+    default: () => ""
+  }),
+  input: (0, import_langgraph5.Annotation)({
+    reducer: (x, y) => y ?? x,
+    default: () => ({})
+  }),
+  command2: (0, import_langgraph5.Annotation)({
+    reducer: (x, y) => y ?? x,
+    default: () => void 0
+  }),
+  // Execution result
+  result: (0, import_langgraph5.Annotation)({
+    reducer: (x, y) => y ?? x,
+    default: () => void 0
+  }),
+  // Interrupt data
+  interruptValue: (0, import_langgraph5.Annotation)({
+    reducer: (x, y) => y ?? x,
+    default: () => void 0
+  }),
+  // Final state to return
+  finalState: (0, import_langgraph5.Annotation)({
+    reducer: (x, y) => y ?? x,
+    default: () => void 0
+  })
+});
+async function executeNode(state) {
+  const { assistant_id, thread_id, input, command2 } = state;
+  const callParams = {
+    assistant_id,
+    thread_id,
+    input,
+    command: command2
+  };
+  const result = await AgentManager.getInstance().callAgentInQueue(
+    callParams,
+    true
+  );
+  return {
+    result
+  };
+}
+async function interruptNode(state) {
+  const { result } = state;
+  const interruptValue = result?.tasks?.[0]?.interrupts?.[0]?.value;
+  if (!interruptValue) {
+    throw new Error(
+      "Interrupt node called but no interrupt value found in result"
+    );
+  }
+  const response = await (0, import_langgraph5.interrupt)(interruptValue);
+  return {
+    command2: {
+      resume: response
+    }
+  };
+}
+function shouldInterrupt(state) {
+  const { result } = state;
+  if (result?.tasks && Array.isArray(result.tasks) && result.tasks.length > 0) {
+    if (result.tasks[0]?.interrupts && result.tasks[0].interrupts.length > 0) {
+      return "interrupt";
+    }
+  }
+  return "end";
+}
+function endNode(state) {
+  const finalState = state.result;
+  return {
+    finalState,
+    // Clear intermediate states
+    result: void 0,
+    interruptValue: void 0,
+    command2: void 0
+  };
+}
+function createAgentWorkerGraph() {
+  const workflow = new import_langgraph5.StateGraph(AgentWorkerState);
+  workflow.addNode("execute", executeNode);
+  workflow.addNode("interrupt", interruptNode);
+  workflow.addNode("end", endNode);
+  workflow.setEntryPoint("execute");
+  workflow.addConditionalEdges("execute", shouldInterrupt, {
+    interrupt: "interrupt",
+    end: "end"
+  });
+  workflow.addEdge("interrupt", "execute");
+  workflow.addEdge("end", import_langgraph5.END);
+  return workflow.compile();
+}
+var agentWorkerGraph = createAgentWorkerGraph();
+
+// src/deep_agent_new/middleware/subagents.ts
 var DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools.";
 var EXCLUDED_STATE_KEYS = ["messages", "todos", "jumpTo"];
 var DEFAULT_GENERAL_PURPOSE_DESCRIPTION = "General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. This agent has access to all tools as the main agent.";
@@ -1677,7 +2080,7 @@ function returnCommandWithStateUpdate(result, toolCallId) {
   const stateUpdate = filterStateForSubagent(result);
   const messages = result.messages;
   const lastMessage = messages?.[messages.length - 1];
-  return new import_langgraph5.Command({
+  return new import_langgraph6.Command({
     update: {
       ...stateUpdate,
       messages: [
@@ -1770,10 +2173,18 @@ function createTaskTool(options) {
         );
       }
       const subagent = subagentGraphs[subagent_type];
-      const currentState = (0, import_langgraph5.getCurrentTaskInput)();
+      const currentState = (0, import_langgraph6.getCurrentTaskInput)();
       const subagentState = filterStateForSubagent(currentState);
       subagentState.messages = [new import_messages.HumanMessage({ content: description })];
-      const result = await subagent.invoke(subagentState, config);
+      const subagent_thread_id = config.configurable?.thread_id + "_" + subagent_type + "_" + config.toolCall.id;
+      console.log(subagent_thread_id);
+      const workerResult = await agentWorkerGraph.invoke({
+        assistant_id: subagent_type,
+        thread_id: subagent_thread_id,
+        input: { ...subagentState, message: description }
+      });
+      const result = workerResult.finalState?.values;
+      console.log("workerResult", workerResult);
       if (!config.toolCall?.id) {
         throw new Error("Tool call ID is required for subagent invocation");
       }
@@ -1835,7 +2246,7 @@ ${systemPrompt}` : systemPrompt;
 // src/deep_agent_new/middleware/patch_tool_calls.ts
 var import_langchain4 = require("langchain");
 var import_messages2 = require("@langchain/core/messages");
-var import_langgraph6 = require("@langchain/langgraph");
+var import_langgraph7 = require("@langchain/langgraph");
 function createPatchToolCallsMiddleware() {
   return (0, import_langchain4.createMiddleware)({
     name: "patchToolCallsMiddleware",
@@ -1868,7 +2279,7 @@ function createPatchToolCallsMiddleware() {
       }
       return {
         messages: [
-          new import_messages2.RemoveMessage({ id: import_langgraph6.REMOVE_ALL_MESSAGES }),
+          new import_messages2.RemoveMessage({ id: import_langgraph7.REMOVE_ALL_MESSAGES }),
           ...patchedMessages
         ]
       };
@@ -1883,7 +2294,7 @@ var import_micromatch2 = __toESM(require("micromatch"));
 var SUPPORTS_NOFOLLOW = fsSync.constants.O_NOFOLLOW !== void 0;
 
 // src/deep_agent_new/middleware/todos.ts
-var import_langgraph7 = require("@langchain/langgraph");
+var import_langgraph8 = require("@langchain/langgraph");
 var import_zod5 = require("zod");
 var import_langchain5 = require("langchain");
 var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
@@ -2121,7 +2532,7 @@ var stateSchema = import_zod5.z.object({ todos: import_zod5.z.array(TodoSchema).
 function todoListMiddleware(options) {
   const writeTodos = (0, import_langchain5.tool)(
     ({ todos }, config) => {
-      return new import_langgraph7.Command({
+      return new import_langgraph8.Command({
         update: {
           todos,
           messages: [
@@ -2329,7 +2740,7 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
 };
 
 // src/agent_lattice/builders/AgentParamsBuilder.ts
-var import_protocols3 = require("@axiom-lattice/protocols");
+var import_protocols4 = require("@axiom-lattice/protocols");
 var AgentParamsBuilder = class {
   /**
    * constructor
@@ -2347,7 +2758,7 @@ var AgentParamsBuilder = class {
    * @returns Agent build parameters
    */
   buildParams(agentLattice, options) {
-    const toolKeys = options?.overrideTools || (0, import_protocols3.getToolsFromConfig)(agentLattice.config);
+    const toolKeys = options?.overrideTools || (0, import_protocols4.getToolsFromConfig)(agentLattice.config);
     const tools = toolKeys.map((toolKey) => {
       const toolLattice = toolLatticeManager.getToolLattice(toolKey);
       if (!toolLattice) {
@@ -2364,7 +2775,7 @@ var AgentParamsBuilder = class {
     if (!model) {
       throw new Error(`Model "${modelKey}" does not exist`);
     }
-    const subAgentKeys = (0, import_protocols3.getSubAgentsFromConfig)(agentLattice.config);
+    const subAgentKeys = (0, import_protocols4.getSubAgentsFromConfig)(agentLattice.config);
     const subAgents = subAgentKeys.map((agentKey) => {
       const subAgentLattice = this.getAgentLatticeFunc(agentKey);
       if (!subAgentLattice) {
@@ -2377,7 +2788,7 @@ var AgentParamsBuilder = class {
       };
     });
     let internalSubAgents = [];
-    if ((0, import_protocols3.isDeepAgentConfig)(agentLattice.config)) {
+    if ((0, import_protocols4.isDeepAgentConfig)(agentLattice.config)) {
       internalSubAgents = agentLattice.config.internalSubAgents?.map((i) => ({
         key: i.key,
         config: i
@@ -2872,20 +3283,26 @@ var hasChunkBuffer = (key) => ChunkBufferLatticeManager.getInstance().has(key);
 var Protocols = __toESM(require("@axiom-lattice/protocols"));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AGENT_TASK_EVENT,
   AgentConfig,
   AgentLatticeManager,
+  AgentManager,
   AgentType,
   ChunkBuffer,
   ChunkBufferLatticeManager,
   GraphBuildOptions,
   InMemoryChunkBuffer,
   MemoryLatticeManager,
+  MemoryQueueClient,
   MemoryType,
   ModelLatticeManager,
   Protocols,
+  QueueLatticeManager,
   ThreadStatus,
   ToolLatticeManager,
   agentLatticeManager,
+  eventBus,
+  eventBusDefault,
   getAgentClient,
   getAgentConfig,
   getAgentLattice,
@@ -2894,16 +3311,19 @@ var Protocols = __toESM(require("@axiom-lattice/protocols"));
   getCheckpointSaver,
   getChunkBuffer,
   getModelLattice,
+  getQueueLattice,
   getToolClient,
   getToolDefinition,
   getToolLattice,
   hasChunkBuffer,
   modelLatticeManager,
+  queueLatticeManager,
   registerAgentLattice,
   registerAgentLattices,
   registerCheckpointSaver,
   registerChunkBuffer,
   registerModelLattice,
+  registerQueueLattice,
   registerToolLattice,
   toolLatticeManager,
   validateAgentInput,