@axiom-lattice/core 2.1.57 → 2.1.59

package/dist/index.mjs

@@ -648,11 +648,11 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key Lattice键名
    * @param tool 已有的StructuredTool实例
    */
-  registerExistingTool(key, tool50) {
+  registerExistingTool(key, tool51) {
     const config = {
-      name: tool50.name,
-      description: tool50.description,
-      schema: tool50.schema,
+      name: tool51.name,
+      description: tool51.description,
+      schema: tool51.schema,
       // StructuredTool的schema已经是Zod兼容的
       needUserApprove: false
       // MCP工具默认不需要用户批准
@@ -660,7 +660,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key,
       config,
-      client: tool50
+      client: tool51
     };
     this.register(key, toolLattice);
   }
@@ -686,7 +686,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
 };
 var toolLatticeManager = ToolLatticeManager.getInstance();
 var registerToolLattice = (key, config, executor) => toolLatticeManager.registerLattice(key, config, executor);
-var registerExistingTool = (key, tool50) => toolLatticeManager.registerExistingTool(key, tool50);
+var registerExistingTool = (key, tool51) => toolLatticeManager.registerExistingTool(key, tool51);
 var getToolLattice = (key) => toolLatticeManager.getToolLattice(key);
 var getToolDefinition = (key) => toolLatticeManager.getToolDefinition(key);
 var getToolClient = (key) => toolLatticeManager.getToolClient(key);
@@ -1120,14 +1120,14 @@ import z3 from "zod";
 import { tool as tool2 } from "langchain";
 
 // src/tool_lattice/sql/utils.ts
-function getTenantIdFromConfig(exeConfig, getTenantId) {
+function getTenantIdFromConfig(exeConfig, getTenantId2) {
   const runConfig = exeConfig?.configurable?.runConfig || {};
-  return runConfig.tenantId || (getTenantId ? getTenantId() : "default");
+  return runConfig.tenantId || (getTenantId2 ? getTenantId2() : "default");
 }
 
 // src/tool_lattice/sql/list_tables_sql.ts
 var LIST_TABLES_SQL_DESCRIPTION = `List all tables in the connected SQL database. Returns a comma-separated list of table names. Use this tool first to understand what tables are available before querying the database.`;
-var createListTablesSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
+var createListTablesSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId: getTenantId2 }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -1137,7 +1137,7 @@ ${databaseKeys.map(
   return tool2(
     async ({ databaseKey }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId2);
         if (!databaseKey) {
           return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
         }
@@ -1171,7 +1171,7 @@ ${databaseKeys.map(
 import z4 from "zod";
 import { tool as tool3 } from "langchain";
 var INFO_SQL_DESCRIPTION = `Get detailed schema information for specified tables, including column names, types, constraints (primary keys, foreign keys), and sample rows. Input should be a comma-separated list of table names.`;
-var createInfoSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
+var createInfoSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId: getTenantId2 }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -1184,7 +1184,7 @@ ${databaseKeys.map(
       databaseKey
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId2);
         if (!databaseKey) {
           return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
         }
@@ -1303,7 +1303,7 @@ function checkDangerousOperations(query) {
   }
   return warnings;
 }
-var createQueryCheckerSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
+var createQueryCheckerSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId: getTenantId2 }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -1316,7 +1316,7 @@ ${databaseKeys.map(
       databaseKey
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId2);
         const trimmedQuery = query.trim();
         if (!trimmedQuery) {
           return "Error: Empty query provided. Please provide a SQL query to check.";
@@ -1425,7 +1425,7 @@ function formatQueryResult(rows, fields) {
 Total rows: ${rows.length}`);
   return lines.join("\n");
 }
-var createQuerySqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
+var createQuerySqlTool = ({ databaseKeys, databaseDescriptions, getTenantId: getTenantId2 }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -1438,7 +1438,7 @@ ${databaseKeys.map(
       databaseKey
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId2);
         if (!databaseKey) {
           return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
         }
@@ -1470,9 +1470,9 @@ ${databaseKeys.map(
 };
 
 // src/tool_lattice/metrics/utils.ts
-function getTenantIdFromConfig2(exeConfig, getTenantId) {
+function getTenantIdFromConfig2(exeConfig, getTenantId2) {
   const runConfig = exeConfig?.configurable?.runConfig || {};
-  return runConfig.tenantId || (getTenantId ? getTenantId() : "default");
+  return runConfig.tenantId || (getTenantId2 ? getTenantId2() : "default");
 }
 function filterServerKeysByTenant(serverKeys, tenantId, manager = metricsServerManager) {
   return serverKeys.filter((key) => {
@@ -2324,7 +2324,7 @@ var metricsServerManager = MetricsServerManager.getInstance();
 import z7 from "zod";
 import { tool as tool6 } from "langchain";
 var LIST_METRICS_SERVERS_DESCRIPTION = `List all registered metrics servers. Returns a list of available metrics servers with their keys and types. Use this tool first to understand what metrics servers are available.`;
-var createListMetricsServersTool = ({ serverKeys, serverDescriptions, getTenantId }) => {
+var createListMetricsServersTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2 }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2334,7 +2334,7 @@ ${serverKeys.map(
   return tool6(
     async (_input, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         const servers = metricsServerManager.getServerKeys(tenantId);
         if (servers.length === 0) {
           return "No metrics servers registered.";
@@ -2361,7 +2361,7 @@ ${lines.join("\n")}`;
 import z8 from "zod";
 import { tool as tool7 } from "langchain";
 var LIST_METRICS_DATASOURCES_DESCRIPTION = `List all available datasources from all configured metrics servers. Returns a table with Server Key, DataSource ID, and DataSource Name. Use this tool first to discover what datasources are available before querying metrics.`;
-var createListMetricsDataSourcesTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createListMetricsDataSourcesTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Configured metrics servers:
@@ -2371,7 +2371,7 @@ ${serverKeys.map(
   return tool7(
     async (_input, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -2477,7 +2477,7 @@ Response Fields Reference
 
 Next Step
 After finding relevant metrics, call query_metric_definition with the metricName to get detailed metadata including time dimensions and supported filters.`;
-var createQueryMetricsListTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createQueryMetricsListTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2490,7 +2490,7 @@ ${serverKeys.map(
       datasourceIds
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -2634,7 +2634,7 @@ Rules
 
 Next Step
 Call query_semantic_metric_data with parameters derived from this definition.`;
-var createQueryMetricDefinitionTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createQueryMetricDefinitionTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2648,7 +2648,7 @@ ${serverKeys.map(
       datasourceId: inputDatasourceId
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -2867,7 +2867,7 @@ Semantic Model: ${semanticModel}`;
 `);
   return lines.join("\n");
 }
-var createQuerySemanticMetricDataTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createQuerySemanticMetricDataTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2884,7 +2884,7 @@ ${serverKeys.map(
       limit
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -2952,7 +2952,7 @@ ${serverKeys.map(
 import z12 from "zod";
 import { tool as tool11 } from "langchain";
 var QUERY_TABLES_LIST_DESCRIPTION = `Query available tables from a semantic metrics server. Returns a list of data tables with their schemas and descriptions. Use this tool to discover what tables are available in the data source.`;
-var createQueryTablesListTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createQueryTablesListTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2965,7 +2965,7 @@ ${serverKeys.map(
       datasourceIds
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -3056,7 +3056,7 @@ ${serverKeys.map(
 import z13 from "zod";
 import { tool as tool12 } from "langchain";
 var QUERY_TABLE_DEFINITION_DESCRIPTION = `Get detailed definition and schema for a specific table from a semantic metrics server. Returns comprehensive information including column definitions, SQL query, and table relationships.`;
-var createQueryTableDefinitionTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createQueryTableDefinitionTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -3070,7 +3070,7 @@ ${serverKeys.map(
       datasourceId: inputDatasourceId
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -3194,7 +3194,7 @@ Example:
   },
   "limit": 100
 }`;
-var createExecuteSqlQueryTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createExecuteSqlQueryTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -3210,7 +3210,7 @@ ${serverKeys.map(
       limit
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -4528,6 +4528,7 @@ import {
   AgentType,
   hasTools,
   isDeepAgentConfig,
+  isProcessingAgentConfig,
   isTeamAgentConfig,
   getToolsFromConfig,
   getSubAgentsFromConfig
@@ -10829,6 +10830,125 @@ var InMemoryThreadMessageQueueStore = class {
   }
 };
 
+// src/store_lattice/InMemoryWorkflowTrackingStore.ts
+var InMemoryWorkflowTrackingStore = class {
+  constructor() {
+    this.runs = /* @__PURE__ */ new Map();
+    this.steps = /* @__PURE__ */ new Map();
+  }
+  async createWorkflowRun(request) {
+    const now = /* @__PURE__ */ new Date();
+    const run = {
+      id: `${request.threadId}_${Date.now()}`,
+      tenantId: request.tenantId,
+      assistantId: request.assistantId,
+      threadId: request.threadId,
+      status: "running",
+      topologyEdges: request.topologyEdges,
+      totalEdges: request.topologyEdges.length,
+      completedEdges: 0,
+      metadata: request.metadata || {},
+      startedAt: now,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.runs.set(run.id, run);
+    this.steps.set(run.id, []);
+    return run;
+  }
+  async getWorkflowRun(runId) {
+    return this.runs.get(runId) || null;
+  }
+  async updateWorkflowRun(runId, updates) {
+    const run = this.runs.get(runId);
+    if (!run) return null;
+    const updated = {
+      ...run,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.runs.set(runId, updated);
+    return updated;
+  }
+  async getWorkflowRunsByThreadId(tenantId, threadId) {
+    const results = [];
+    for (const run of this.runs.values()) {
+      if (run.tenantId === tenantId && run.threadId === threadId) {
+        results.push(run);
+      }
+    }
+    return results;
+  }
+  async getWorkflowRunsByAssistantId(tenantId, assistantId) {
+    const results = [];
+    for (const run of this.runs.values()) {
+      if (run.tenantId === tenantId && run.assistantId === assistantId) {
+        results.push(run);
+      }
+    }
+    return results;
+  }
+  async getWorkflowRunsByTenantId(tenantId) {
+    const results = [];
+    for (const run of this.runs.values()) {
+      if (run.tenantId === tenantId) {
+        results.push(run);
+      }
+    }
+    return results;
+  }
+  async createRunStep(request) {
+    const now = /* @__PURE__ */ new Date();
+    const step = {
+      id: `step_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      runId: request.runId,
+      tenantId: request.tenantId,
+      stepType: request.stepType,
+      stepName: request.stepName,
+      edgeFrom: request.edgeFrom,
+      edgeTo: request.edgeTo,
+      edgePurpose: request.edgePurpose,
+      input: request.input,
+      status: "running",
+      startedAt: now,
+      createdAt: now,
+      updatedAt: now
+    };
+    const runSteps = this.steps.get(request.runId) || [];
+    runSteps.push(step);
+    this.steps.set(request.runId, runSteps);
+    return step;
+  }
+  async updateRunStep(runId, stepId, updates) {
+    const runSteps = this.steps.get(runId);
+    if (!runSteps) return null;
+    const idx = runSteps.findIndex((s) => s.id === stepId);
+    if (idx === -1) return null;
+    const now = /* @__PURE__ */ new Date();
+    runSteps[idx] = {
+      ...runSteps[idx],
+      ...updates,
+      updatedAt: now
+    };
+    return runSteps[idx];
+  }
+  async getRunSteps(runId) {
+    return this.steps.get(runId) || [];
+  }
+  async getRunStepsByType(runId, stepType) {
+    const runSteps = this.steps.get(runId) || [];
+    return runSteps.filter((s) => s.stepType === stepType);
+  }
+  async getInterruptedSteps(runId) {
+    const runSteps = this.steps.get(runId) || [];
+    return runSteps.filter((s) => s.status === "interrupted");
+  }
+  clear() {
+    this.runs.clear();
+    this.steps.clear();
+  }
+};
+
 // src/store_lattice/StoreLatticeManager.ts
 var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager {
   /**
@@ -10985,6 +11105,12 @@ storeLatticeManager.registerLattice(
   "threadMessageQueue",
   defaultThreadMessageQueueStore
 );
+var defaultWorkflowTrackingStore = new InMemoryWorkflowTrackingStore();
+storeLatticeManager.registerLattice(
+  "default",
+  "workflowTracking",
+  defaultWorkflowTrackingStore
+);
 
 // src/services/Agent.ts
 import { Command as Command2 } from "@langchain/langgraph";
@@ -11327,6 +11453,7 @@ var Agent = class {
     this.abortController = null;
     this.queueMode = this.getDefaultQueueConfig();
     this.isWaitingForQueueEnd = false;
+    this.asyncTasks = [];
     this.agentExecutor = async ({ input, command, custom_run_config }, signal) => {
       const { runnable_agent, runConfig } = await this.getLatticeClientAndRuntimeConfig(custom_run_config);
       const { messages, ...rest } = input;
@@ -12105,6 +12232,23 @@ var Agent = class {
     console.log(namespacedEvent);
     event_bus_default.publish(namespacedEvent, data);
   }
+  addAsyncTask(task) {
+    this.asyncTasks.push(task);
+  }
+  getAsyncTasks() {
+    return this.asyncTasks;
+  }
+  getAsyncTask(taskId) {
+    return this.asyncTasks.find((t) => t.taskId === taskId);
+  }
+  updateAsyncTaskStatus(taskId, status) {
+    const task = this.getAsyncTask(taskId);
+    if (!task) return;
+    task.status = status;
+    if (status === "completed" || status === "failed" || status === "cancelled") {
+      task.completedAt = Date.now();
+    }
+  }
 };
 
 // src/services/AgentInstanceManager.ts
@@ -12730,9 +12874,9 @@ var ReActAgentGraphBuilder = class {
    */
   async build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool50 = getToolClient(t.key);
-      return tool50;
-    }).filter((tool50) => tool50 !== void 0);
+      const tool51 = getToolClient(t.key);
+      return tool51;
+    }).filter((tool51) => tool51 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
@@ -13156,6 +13300,25 @@ function getSubagents(options) {
   }
   return { agents, descriptions: subagentDescriptions };
 }
+function getAsyncPromptText() {
+  return `
+
+## Async Task Usage
+
+When tasks are independent and can run in parallel, use \`async: true\` to launch
+background tasks. The task returns immediately with a task ID.
+
+CRITICAL: After launching with \`async: true\`, move on immediately.
+- NEVER call check_async_task or list_async_tasks right after starting a task.
+- NEVER poll for task completion. The result will arrive as a notification.
+- Only check task status when the USER explicitly asks for an update.
+- If you receive an [Async task completed] notification, read it and incorporate
+  the result into your next response. Do not then call check_async_task repeatedly.
+- Task statuses in conversation history are stale \u2014 always use fresh tool calls
+  when the user asks.
+- Use cancel_async_task if the user wants to stop a running task.
+- Keep the full task_id: never truncate or abbreviate it.`;
+}
 function createTaskTool(options) {
   const {
     defaultModel,
@@ -13164,7 +13327,8 @@ function createTaskTool(options) {
     defaultInterruptOn,
     subagents,
     generalPurposeAgent,
-    taskDescription
+    taskDescription,
+    allowAsync
   } = options;
   const { agents: subagentGraphs, descriptions: subagentDescriptions } = getSubagents({
     defaultModel,
@@ -13177,7 +13341,7 @@ function createTaskTool(options) {
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
   return tool46(
     async (input, config) => {
-      const { description, subagent_type } = input;
+      const { description, subagent_type, async } = input;
       let assistant_id = subagent_type;
       if (subagent_type === "general-purpose") {
         assistant_id = config.configurable?.runConfig?.assistant_id + "-general-purpose";
@@ -13207,6 +13371,57 @@ function createTaskTool(options) {
         const subagentState = filterStateForSubagent(currentState);
         subagentState.messages = [new HumanMessage2({ content: description })];
         const subagent_thread_id = config.configurable?.thread_id + "____" + assistant_id + "_" + config.toolCall.id;
+        if (async) {
+          const tenantId = config.configurable?.runConfig?.tenantId;
+          const mainAssistantId = config.configurable?.runConfig?.assistant_id;
+          const mainThreadId = config.configurable?.runConfig?.thread_id;
+          const mainRuntimeAgent = agentInstanceManager.getAgent({
+            assistant_id: mainAssistantId,
+            thread_id: mainThreadId,
+            tenant_id: tenantId
+          });
+          if (mainRuntimeAgent) {
+            mainRuntimeAgent.addAsyncTask({
+              taskId: subagent_thread_id,
+              assistantId: assistant_id,
+              description: description.substring(0, 200),
+              status: "running",
+              createdAt: Date.now()
+            });
+          }
+          AgentManager.getInstance().callAgentInQueue({
+            assistant_id,
+            thread_id: subagent_thread_id,
+            input: { ...subagentState, message: description },
+            "x-tenant-id": tenantId,
+            runConfig: {
+              ...config.configurable?.runConfig,
+              assistant_id,
+              thread_id: subagent_thread_id
+            },
+            main_thread_id: mainThreadId,
+            main_tenant_id: tenantId,
+            main_assistant_id: mainAssistantId
+          }, false).catch((err) => {
+            console.error(`Failed to start async subagent ${subagent_thread_id}:`, err);
+          });
+          if (!config.toolCall?.id) {
+            throw new Error("Tool call ID is required for subagent invocation");
+          }
+          return new Command3({
+            update: {
+              messages: [
+                new ToolMessage4({
+                  content: `Async task started: ${subagent_thread_id}
+${description}
+The result will be delivered as a notification when complete. Do not poll.`,
+                  tool_call_id: config.toolCall.id,
+                  name: "task"
+                })
+              ]
+            }
+          });
+        }
         const workerResult = await agentWorkerGraph.invoke({
           assistant_id,
           thread_id: subagent_thread_id,
@@ -13248,7 +13463,186 @@ function createTaskTool(options) {
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
-        )
+        ),
+        ...allowAsync ? {
+          async: z48.boolean().default(false).describe(
+            "When true, runs the task in the background and returns immediately. Use for independent tasks that can run in parallel. The result is delivered as a notification when complete. Use check_async_task or list_async_tasks to monitor progress."
+          )
+        } : {}
+      })
+    }
+  );
+}
+function getMainAgentFromConfig(config) {
+  const tenantId = config.configurable?.runConfig?.tenantId;
+  const mainAssistantId = config.configurable?.runConfig?.assistant_id;
+  const mainThreadId = config.configurable?.runConfig?.thread_id;
+  return agentInstanceManager.getAgent({
+    assistant_id: mainAssistantId,
+    thread_id: mainThreadId,
+    tenant_id: tenantId
+  });
+}
+function createCheckAsyncTaskTool() {
+  return tool46(
+    async (input, config) => {
+      const { task_id } = input;
+      const mainAgent = getMainAgentFromConfig(config);
+      if (!mainAgent) {
+        return "Cannot access main agent state.";
+      }
+      const cached = mainAgent.getAsyncTask(task_id);
+      if (!cached) {
+        return `Task ${task_id} not found. Use list_async_tasks to see all tasks.`;
+      }
+      try {
+        if (!agentInstanceManager.hasAgent({
+          assistant_id: cached.assistantId,
+          thread_id: task_id,
+          tenant_id: mainAgent.tenant_id
+        })) {
+          return `Task ${task_id}: not found (may have been cleaned up). Status was: ${cached.status}`;
+        }
+        const subAgent = agentInstanceManager.getAgent({
+          assistant_id: cached.assistantId,
+          thread_id: task_id,
+          tenant_id: mainAgent.tenant_id
+        });
+        const status = await subAgent.getRunStatus();
+        if (status === "busy") {
+          return `Task ${task_id}: still running.
+Description: ${cached.description}`;
+        }
+        if (status === "idle") {
+          const state = await subAgent.getCurrentState();
+          const messages = state.values.messages || [];
+          const lastAI = [...messages].reverse().find(
+            (m) => m.type === "ai" || m.getType?.() === "ai"
+          );
+          mainAgent.updateAsyncTaskStatus(task_id, "completed");
+          const result = lastAI?.content ?? "(completed, no output)";
+          return `Task ${task_id}: COMPLETED.
+Description: ${cached.description}
+Result:
+${result}`;
+        }
+        if (status === "error") {
+          mainAgent.updateAsyncTaskStatus(task_id, "failed");
+          return `Task ${task_id}: failed.
+Description: ${cached.description}`;
+        }
+        if (status === "interrupted") {
+          return `Task ${task_id}: interrupted (waiting for input).
+Description: ${cached.description}`;
+        }
+        return `Task ${task_id}: ${status}.
+Description: ${cached.description}`;
+      } catch (err) {
+        return `Task ${task_id}: error checking status: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    },
+    {
+      name: "check_async_task",
+      description: "Get the current status and result of an async background task. Use this to check if a previously launched async task has completed.",
+      schema: z48.object({
+        task_id: z48.string().describe("The task ID returned when the async task was started")
+      })
+    }
+  );
+}
+function createListAsyncTasksTool() {
+  return tool46(
+    async (_input, config) => {
+      const mainAgent = getMainAgentFromConfig(config);
+      if (!mainAgent) {
+        return "Cannot access main agent state.";
+      }
+      const tasks = mainAgent.getAsyncTasks();
+      if (tasks.length === 0) {
+        return "No async tasks have been launched.";
+      }
+      for (const task of tasks) {
+        if (task.status === "completed" || task.status === "failed" || task.status === "cancelled") continue;
+        try {
+          if (!agentInstanceManager.hasAgent({
+            assistant_id: task.assistantId,
+            thread_id: task.taskId,
+            tenant_id: mainAgent.tenant_id
+          })) continue;
+          const subAgent = agentInstanceManager.getAgent({
+            assistant_id: task.assistantId,
+            thread_id: task.taskId,
+            tenant_id: mainAgent.tenant_id
+          });
+          const status = await subAgent.getRunStatus();
+          if (status === "idle") {
+            mainAgent.updateAsyncTaskStatus(task.taskId, "completed");
+          } else if (status === "error") {
+            mainAgent.updateAsyncTaskStatus(task.taskId, "failed");
+          }
+        } catch {
+        }
+      }
+      const lines = tasks.map((t) => {
+        const age = Math.floor((Date.now() - t.createdAt) / 1e3);
+        const ageStr = age < 60 ? `${age}s ago` : `${Math.floor(age / 60)}m ago`;
+        return `| ${t.taskId} | ${t.status} | ${ageStr} | ${t.description.substring(0, 80)} |`;
+      });
+      return [
+        "| task_id | status | age | description |",
+        "|---------|--------|-----|-------------|",
+        ...lines
+      ].join("\n");
+    },
+    {
+      name: "list_async_tasks",
+      description: "List all async background tasks with their current status. Use this before reporting task status to the user. Statuses in conversation history may be stale.",
+      schema: z48.object({})
+    }
+  );
+}
+function createCancelAsyncTaskTool() {
+  return tool46(
+    async (input, config) => {
+      const { task_id } = input;
+      const mainAgent = getMainAgentFromConfig(config);
+      if (!mainAgent) {
+        return "Cannot access main agent state.";
+      }
+      const cached = mainAgent.getAsyncTask(task_id);
+      if (!cached) {
+        return `Task ${task_id} not found.`;
+      }
+      try {
+        const subAgentExists = agentInstanceManager.hasAgent({
+          assistant_id: cached.assistantId,
+          thread_id: task_id,
+          tenant_id: mainAgent.tenant_id
+        });
+        if (subAgentExists) {
+          const subAgent = agentInstanceManager.getAgent({
+            assistant_id: cached.assistantId,
+            thread_id: task_id,
+            tenant_id: mainAgent.tenant_id
+          });
+          await subAgent.abort();
+          agentInstanceManager.removeAgent({
+            assistant_id: cached.assistantId,
+            thread_id: task_id,
+            tenant_id: mainAgent.tenant_id
+          });
+        }
+      } catch (err) {
+        return `Failed to cancel task ${task_id}: ${err instanceof Error ? err.message : String(err)}`;
+      }
+      mainAgent.updateAsyncTaskStatus(task_id, "cancelled");
+      return `Task ${task_id} cancelled.`;
+    },
+    {
+      name: "cancel_async_task",
+      description: "Cancel a running async background task.",
+      schema: z48.object({
+        task_id: z48.string().describe("The task ID to cancel")
       })
     }
   );
@@ -13262,7 +13656,8 @@ function createSubAgentMiddleware(options) {
     subagents = [],
     systemPrompt = TASK_SYSTEM_PROMPT,
     generalPurposeAgent = true,
-    taskDescription = null
+    taskDescription = null,
+    allowAsync = true
   } = options;
   const taskTool = createTaskTool({
     defaultModel,
@@ -13271,17 +13666,27 @@ function createSubAgentMiddleware(options) {
     defaultInterruptOn,
     subagents,
     generalPurposeAgent,
-    taskDescription
+    taskDescription,
+    allowAsync
   });
+  const allTools = [taskTool];
+  if (allowAsync) {
+    allTools.push(
+      createCheckAsyncTaskTool(),
+      createListAsyncTasksTool(),
+      createCancelAsyncTaskTool()
+    );
+  }
+  const effectiveSystemPrompt = allowAsync ? systemPrompt + getAsyncPromptText() : systemPrompt;
   return createMiddleware14({
     name: "subAgentMiddleware",
-    tools: [taskTool],
+    tools: allTools,
     wrapModelCall: async (request, handler) => {
-      if (systemPrompt !== null) {
+      if (effectiveSystemPrompt !== null) {
         const currentPrompt = request.systemPrompt || "";
         const newPrompt = currentPrompt ? `${currentPrompt}
 
-${systemPrompt}` : systemPrompt;
+${effectiveSystemPrompt}` : effectiveSystemPrompt;
         return handler({
           ...request,
           systemPrompt: newPrompt
@@ -14816,7 +15221,7 @@ var DeepAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool50) => tool50 !== void 0);
+    }).filter((tool51) => tool51 !== void 0);
     const subagents = await Promise.all(params.subAgents.map(async (sa) => {
       if (sa.client) {
         return {
@@ -16441,7 +16846,7 @@ var TeamAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool50) => tool50 !== void 0);
+    }).filter((tool51) => tool51 !== void 0);
     const teammates = params.subAgents.map((sa) => {
       const baseConfig = sa.config;
       return {
@@ -16478,129 +16883,558 @@ var TeamAgentGraphBuilder = class {
   }
 };
 
-// src/agent_lattice/builders/AgentGraphBuilderFactory.ts
-var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
-  constructor() {
-    this.builders = /* @__PURE__ */ new Map();
-    this.registerDefaultBuilders();
-  }
-  /**
-   * 获取单例实例
-   */
-  static getInstance() {
-    if (!_AgentGraphBuilderFactory.instance) {
-      _AgentGraphBuilderFactory.instance = new _AgentGraphBuilderFactory();
-    }
-    return _AgentGraphBuilderFactory.instance;
-  }
-  /**
-   * 注册默认的Builder
-   */
-  registerDefaultBuilders() {
-    this.builders.set(AgentType.REACT, new ReActAgentGraphBuilder());
-    this.builders.set(AgentType.DEEP_AGENT, new DeepAgentGraphBuilder());
-    this.builders.set(AgentType.TEAM, new TeamAgentGraphBuilder());
-  }
-  /**
-   * 注册自定义Builder
-   *
-   * @param type Agent类型
-   * @param builder Builder实例
-   */
-  registerBuilder(type, builder) {
-    this.builders.set(type, builder);
-  }
-  /**
-   * 获取Builder
-   *
-   * @param type Agent类型
-   * @returns 返回对应的Builder
-   */
-  getBuilder(type) {
-    const builder = this.builders.get(type);
-    if (!builder) {
-      throw new Error(`\u4E0D\u652F\u6301\u7684Agent\u7C7B\u578B: ${type}`);
-    }
-    return builder;
-  }
-};
-
-// src/agent_lattice/builders/AgentParamsBuilder.ts
+// src/deep_agent_new/processing_agent.ts
 import {
-  getToolsFromConfig as getToolsFromConfig2,
-  getSubAgentsFromConfig as getSubAgentsFromConfig2,
-  isDeepAgentConfig as isDeepAgentConfig2
-} from "@axiom-lattice/protocols";
-var AgentParamsBuilder = class {
-  /**
-   * constructor
-   *
-   * @param getAgentLatticeFunc get Agent Lattice function
-   */
-  constructor(getAgentLatticeFunc) {
-    this.getAgentLatticeFunc = getAgentLatticeFunc;
-  }
-  /**
-   * build Agent parameters
-   *
-   * @param agentLattice Agent Lattice object
-   * @param options build options
-   * @returns Agent build parameters
-   */
-  async buildParams(agentLattice, options) {
-    const skills = isDeepAgentConfig2(agentLattice.config) ? agentLattice.config.skillCategories : void 0;
-    const toolKeys = options?.overrideTools || getToolsFromConfig2(agentLattice.config);
-    const tools = toolKeys.map((toolKey) => {
-      const toolLattice = toolLatticeManager.getToolLattice(toolKey);
-      if (!toolLattice) {
-        throw new Error(`Tool "${toolKey}" does not exist`);
+  createAgent as createAgent6,
+  humanInTheLoopMiddleware as humanInTheLoopMiddleware3,
+  anthropicPromptCachingMiddleware as anthropicPromptCachingMiddleware2,
+  summarizationMiddleware as summarizationMiddleware2
+} from "langchain";
+
+// src/middlewares/topologyMiddleware.ts
+import { createMiddleware as createMiddleware18 } from "langchain";
+import { AIMessage as AIMessage3, ToolMessage as ToolMessage9 } from "@langchain/core/messages";
+import { tool as tool50 } from "langchain";
+import { z as z53 } from "zod";
+import { GraphInterrupt as GraphInterrupt4 } from "@langchain/langgraph";
+var CompletedEdgeSchema = z53.object({
+  to: z53.string(),
+  purpose: z53.string()
+});
+function deriveCompletedEdges(messages, edges) {
+  const completedToolCallIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (msg.name === "task" && msg.tool_call_id && msg.status !== "error") {
+      completedToolCallIds.add(msg.tool_call_id);
+    }
+  }
+  const completed = [];
+  for (const msg of messages) {
+    if (!msg.tool_calls) continue;
+    for (const tc of msg.tool_calls) {
+      if (tc.name !== "task" || !completedToolCallIds.has(tc.id)) continue;
+      const targetAgent = tc.args?.subagent_type;
+      const edge = edges.find(
+        (e) => e.to === targetAgent
+      );
+      if (edge && !completed.some((e) => e.to === edge.to)) {
+        completed.push({ to: edge.to, purpose: edge.purpose });
       }
-      return {
-        key: toolKey,
-        definition: toolLattice.config,
-        executor: toolLattice.client
-      };
-    });
-    const modelKey = options?.overrideModel || agentLattice.config.modelKey;
-    const model = modelKey ? modelLatticeManager.getModelLattice(modelKey).client : modelLatticeManager.getModelLattice("default").client;
-    if (!model) {
-      throw new Error(`Model "${modelKey}" does not exist`);
     }
-    const subAgentKeys = getSubAgentsFromConfig2(agentLattice.config);
-    const subAgents = await Promise.all(subAgentKeys.map(async (agentKey) => {
-      const subAgentLattice = await this.getAgentLatticeFunc(agentKey);
-      if (!subAgentLattice) {
-        throw new Error(`SubAgent "${agentKey}" does not exist`);
+  }
+  return completed;
+}
+function createTopologyMiddleware(options) {
+  const { edges, trackingStore } = options;
+  return createMiddleware18({
+    name: "TopologyMiddleware",
+    contextSchema: z53.object({
+      runConfig: z53.any()
+    }),
+    stateSchema: z53.object({
+      currentAgentId: z53.string().default(""),
+      completedEdges: z53.array(CompletedEdgeSchema).default([]),
+      runId: z53.string().default(""),
+      stepIdMap: z53.record(z53.string()).default({})
+    }),
+    beforeAgent: async (state, runtime) => {
+      const runConfig = runtime.context?.runConfig ?? {};
+      const startingNode = edges[0]?.from ?? runConfig.assistant_id ?? "";
+      let runId = "";
+      if (trackingStore) {
+        try {
+          const run = await trackingStore.createWorkflowRun({
+            tenantId: runConfig.tenantId || "default",
+            assistantId: runConfig.assistant_id ?? "",
+            threadId: runConfig.thread_id ?? "",
+            topologyEdges: edges
+          });
+          runId = run.id;
+        } catch (err) {
+          console.error("[topologyMiddleware] Failed to create WorkflowRun:", err);
+        }
       }
       return {
-        key: agentKey,
-        config: subAgentLattice.config,
-        client: subAgentLattice.client
+        currentAgentId: startingNode,
+        completedEdges: [],
+        runId,
+        stepIdMap: {}
       };
-    }));
-    let internalSubAgents = [];
-    if (isDeepAgentConfig2(agentLattice.config)) {
-      internalSubAgents = agentLattice.config.internalSubAgents?.map((i) => ({
-        key: i.key,
-        config: i
-      })) || [];
-    }
-    return {
-      tools,
-      model,
-      subAgents: [...subAgents, ...internalSubAgents],
-      prompt: agentLattice.config.prompt,
-      stateSchema: agentLattice.config.schema,
-      skillCategories: skills,
-      middleware: agentLattice.config.middleware,
-      tenantId: agentLattice.config.tenantId
-    };
-  }
-};
+    },
+    wrapModelCall: async (request, handler) => {
+      const steps = edges.map((e, i) => `${i + 1}. \`${e.from}\` \u2192 \`${e.to}\` \u2014 ${e.purpose}`).join("\n");
+      const topologyPrompt = `## Workflow Execution Plan
 
-// src/agent_lattice/utils/mergeAgentConfig.ts
-var NON_INHERITABLE_FIELDS = /* @__PURE__ */ new Set([
-  "key",
+Your job is to execute this workflow by delegating each step to the specialized agent
+shown below. This is your core execution process \u2014 it is not optional.
+
+${steps || "(no workflow steps defined)"}
+
+Use the \`task\` tool to delegate work to each agent. Call \`read_topo_progress\` to
+see which steps are done and which are still pending.
+
+Do NOT delegate to any agent outside the current node's allowed paths \u2014 such attempts
+will be blocked.`;
+      const newSystemPrompt = request.systemPrompt ? `${topologyPrompt}
+
+---
+
+${request.systemPrompt}` : topologyPrompt;
+      return handler({ ...request, systemPrompt: newSystemPrompt });
+    },
+    tools: [
+      tool50(
+        async (_input) => {
+          return "placeholder";
+        },
+        {
+          name: "read_topo_progress",
+          description: "Check the current progress of the workflow execution plan. Returns which steps have been completed and which are still pending.",
+          schema: z53.object({})
+        }
+      )
+    ],
+    wrapToolCall: async (request, handler) => {
+      if (request.toolCall?.name === "read_topo_progress") {
+        const currentAgentId = request.state?.currentAgentId || "";
+        const completedEdges = request.state?.completedEdges || [];
+        const doneSet = new Set(completedEdges.map((e) => e.to));
+        const progress = edges.map((e) => ({
+          agent: e.to,
+          purpose: e.purpose,
+          status: doneSet.has(e.to) ? "done" : "pending"
+        }));
+        const doneCount = completedEdges.length;
+        return new ToolMessage9({
+          content: JSON.stringify(
+            {
+              currentAgentId,
+              progress: `${doneCount}/${edges.length} edges completed`,
+              steps: progress,
+              nextPending: progress.filter((s) => s.status === "pending").map((s) => s.agent)
+            },
+            null,
+            2
+          ),
+          name: "read_topo_progress",
+          tool_call_id: request.toolCall.id
+        });
+      }
+      try {
+        return await handler(request);
+      } catch (error) {
+        if (error instanceof GraphInterrupt4) {
+          throw error;
+        }
+        throw error;
+      }
+    },
+    afterModel: {
+      canJumpTo: ["model"],
+      hook: async (state, runtime) => {
+        const { messages, runId, stepIdMap: prevStepIdMap } = state;
+        let { currentAgentId } = state;
+        const runConfig = runtime.context?.runConfig ?? {};
+        const stepIdMap = { ...prevStepIdMap };
+        if (!messages || messages.length === 0) return;
+        const lastMessage = messages[messages.length - 1];
+        if ("tool_calls" in lastMessage) {
+          for (const tc of lastMessage.tool_calls) {
+            if (tc.name !== "task") continue;
+            const targetAgent = tc.args?.subagent_type;
+            const edge = edges.find(
+              (e) => e.from === currentAgentId && e.to === targetAgent
+            );
+            if (!edge) {
+              const myEdges = edges.filter(
+                (e) => e.from === currentAgentId
+              );
+              console.warn(
+                JSON.stringify({
+                  event: "topology_violation",
+                  currentAgentId,
+                  targetAgent,
+                  description: tc.args?.description,
+                  allowedTargets: myEdges.map((e) => e.to),
+                  threadId: runtime.configurable?.thread_id,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                })
+              );
+              const allowedList = myEdges.length > 0 ? [
+                `Agent \`${currentAgentId}\` may only delegate to:`,
+                ...myEdges.map(
+                  (e) => `- \`${e.to}\` \u2014 ${e.purpose}`
+                )
+              ] : [
+                `Agent \`${currentAgentId}\` has no outgoing delegation edges configured.`
+              ];
+              return {
+                messages: [
+                  new AIMessage3({
+                    content: [
+                      `Task rejected: topology violation.`,
+                      `Agent "${currentAgentId}" is not allowed to delegate to "${targetAgent}".`,
+                      ...allowedList,
+                      `Please delegate to one of the allowed agents above or handle the task yourself.`
+                    ].join("\n")
+                  })
+                ],
+                jumpTo: "model"
+              };
+            }
+            currentAgentId = edge.to;
+            if (trackingStore && runId) {
+              try {
+                const step = await trackingStore.createRunStep({
+                  runId,
+                  tenantId: runConfig.tenantId || "default",
+                  stepType: "task_delegation",
+                  stepName: targetAgent,
+                  edgeFrom: edge.from,
+                  edgeTo: edge.to,
+                  edgePurpose: edge.purpose,
+                  input: { description: tc.args?.description }
+                });
+                stepIdMap[edge.to] = step.id;
+              } catch (err) {
+                console.error("[topologyMiddleware] Failed to create RunStep:", err);
+              }
+            }
+          }
+        }
+        const completedEdges = deriveCompletedEdges(
+          messages,
+          edges
+        );
+        if (trackingStore && runId) {
+          for (const ce of completedEdges) {
+            const stepId = stepIdMap[ce.to];
+            if (!stepId) continue;
+            let output;
+            for (const msg of messages) {
+              if (msg.name === "task" && msg.tool_call_id) {
+                for (const tc of messages.find(
+                  (m) => m.tool_calls?.some((c) => c.id === msg.tool_call_id)
+                )?.tool_calls || []) {
+                  if (tc.id === msg.tool_call_id && tc.args?.subagent_type === ce.to) {
+                    output = msg.content;
+                    break;
+                  }
+                }
+                if (output) break;
+              }
+            }
+            if (output) {
+              try {
+                await trackingStore.updateRunStep(runId, stepId, {
+                  status: "completed",
+                  output: { result: output },
+                  completedAt: /* @__PURE__ */ new Date()
+                });
+              } catch (err) {
+                console.error("[topologyMiddleware] Failed to update RunStep output:", err);
+              }
+            }
+          }
+        }
+        if (trackingStore && runId) {
+          try {
+            await trackingStore.updateWorkflowRun(runId, {
+              completedEdges: completedEdges.length
+            });
+          } catch (err) {
+            console.error("[topologyMiddleware] Failed to update WorkflowRun completedEdges:", err);
+          }
+        }
+        return { currentAgentId, completedEdges, stepIdMap };
+      }
+    },
+    afterAgent: async (state, runtime) => {
+      const { runId, completedEdges } = state;
+      if (!trackingStore || !runId) return;
+      const allDone = completedEdges && completedEdges.length >= edges.length;
+      if (!allDone) return;
+      try {
+        await trackingStore.updateWorkflowRun(runId, {
+          status: "completed",
+          completedAt: /* @__PURE__ */ new Date()
+        });
+      } catch (err) {
+        console.error("[topologyMiddleware] Failed to finalize WorkflowRun:", err);
+      }
+    }
+  });
+}
+
+// src/deep_agent_new/processing_agent.ts
+var BASE_PROMPT2 = `In order to complete the objective that the user asks of you, you have access to a number of standard tools.`;
+function createProcessingAgent(params) {
+  const {
+    model = "claude-sonnet-4-5-20250929",
+    tools = [],
+    systemPrompt,
+    middleware: customMiddleware = [],
+    subagents = [],
+    responseFormat,
+    contextSchema: contextSchema2,
+    checkpointer,
+    store,
+    backend,
+    interruptOn,
+    name,
+    skills,
+    topologyEdges
+  } = params;
+  const finalSystemPrompt = systemPrompt ? `${systemPrompt}
+
+${BASE_PROMPT2}` : BASE_PROMPT2;
+  const filesystemBackend = backend ? backend : async (config) => new StateBackend(config);
+  let trackingStore;
+  try {
+    const storeLattice = getStoreLattice("default", "workflowTracking");
+    trackingStore = storeLattice.store;
+  } catch {
+  }
+  const middleware = [
+    // Workflow topology enforcement — replaces todoListMiddleware
+    createTopologyMiddleware({ edges: topologyEdges, trackingStore }),
+    // Enables filesystem operations and optional long-term memory storage
+    createFilesystemMiddleware({ backend: filesystemBackend }),
+    // Enables delegation to specialized subagents for complex tasks
+    createSubAgentMiddleware({
+      defaultModel: model,
+      defaultTools: tools,
+      defaultMiddleware: [
+        // Subagent middleware: Todo list management (subagents get todo, not topology)
+        todoListMiddleware(),
+        // Subagent middleware: Filesystem operations
+        createFilesystemMiddleware({
+          backend: filesystemBackend
+        }),
+        // Subagent middleware: Automatic conversation summarization
+        summarizationMiddleware2({
+          model,
+          trigger: { tokens: 17e4 },
+          keep: { messages: 6 }
+        }),
+        // Subagent middleware: Anthropic prompt caching
+        anthropicPromptCachingMiddleware2({
+          unsupportedModelBehavior: "ignore"
+        }),
+        // Subagent middleware: Patches tool calls
+        createPatchToolCallsMiddleware(),
+        ...customMiddleware
+      ],
+      defaultInterruptOn: interruptOn,
+      subagents,
+      generalPurposeAgent: true,
+      allowAsync: false
+    }),
+    // Automatically summarizes conversation history
+    summarizationMiddleware2({
+      model,
+      trigger: { tokens: 17e4 },
+      keep: { messages: 6 }
+    }),
+    // Enables Anthropic prompt caching
+    anthropicPromptCachingMiddleware2({
+      unsupportedModelBehavior: "ignore"
+    }),
+    // Patches tool calls
+    createPatchToolCallsMiddleware()
+  ];
+  if (interruptOn) {
+    middleware.push(humanInTheLoopMiddleware3({ interruptOn }));
+  }
+  middleware.push(...customMiddleware);
+  return createAgent6({
+    model,
+    systemPrompt: finalSystemPrompt,
+    tools,
+    middleware,
+    responseFormat,
+    contextSchema: contextSchema2,
+    checkpointer,
+    store,
+    name
+  });
+}
+
+// src/agent_lattice/builders/ProcessingAgentGraphBuilder.ts
+var ProcessingAgentGraphBuilder = class {
+  async build(agentLattice, params) {
+    const tools = params.tools.map((t) => {
+      const toolClient = getToolClient(t.key);
+      return toolClient;
+    }).filter((tool51) => tool51 !== void 0);
+    const subagents = await Promise.all(params.subAgents.map(async (sa) => {
+      if (sa.client) {
+        return {
+          key: sa.config.key,
+          name: sa.config.name,
+          description: sa.config.description,
+          runnable: sa.client
+        };
+      } else {
+        const subagentClient = await createAgentClientFromAgentLattice({
+          config: sa.config
+        });
+        return {
+          key: sa.config.key,
+          name: sa.config.name,
+          description: sa.config.description,
+          runnable: subagentClient
+        };
+      }
+    }));
+    const middlewareConfigs = params.middleware || [];
+    const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, true);
+    const topologyConfig = middlewareConfigs.find(
+      (m) => m.type === "topology" && m.enabled
+    );
+    const topologyEdges = topologyConfig?.config?.edges || [];
+    const processingAgent = createProcessingAgent({
+      tools,
+      model: params.model,
+      contextSchema: params.stateSchema,
+      systemPrompt: params.prompt,
+      subagents,
+      checkpointer: getCheckpointSaver("default"),
+      skills: params.skillCategories,
+      backend: filesystemBackend,
+      middleware: middlewares,
+      topologyEdges
+    });
+    return processingAgent;
+  }
+};
+
+// src/agent_lattice/builders/AgentGraphBuilderFactory.ts
+var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
+  constructor() {
+    this.builders = /* @__PURE__ */ new Map();
+    this.registerDefaultBuilders();
+  }
+  /**
+   * 获取单例实例
+   */
+  static getInstance() {
+    if (!_AgentGraphBuilderFactory.instance) {
+      _AgentGraphBuilderFactory.instance = new _AgentGraphBuilderFactory();
+    }
+    return _AgentGraphBuilderFactory.instance;
+  }
+  /**
+   * 注册默认的Builder
+   */
+  registerDefaultBuilders() {
+    this.builders.set(AgentType.REACT, new ReActAgentGraphBuilder());
+    this.builders.set(AgentType.DEEP_AGENT, new DeepAgentGraphBuilder());
+    this.builders.set(AgentType.TEAM, new TeamAgentGraphBuilder());
+    this.builders.set(AgentType.PROCESSING, new ProcessingAgentGraphBuilder());
+  }
+  /**
+   * 注册自定义Builder
+   *
+   * @param type Agent类型
+   * @param builder Builder实例
+   */
+  registerBuilder(type, builder) {
+    this.builders.set(type, builder);
+  }
+  /**
+   * 获取Builder
+   *
+   * @param type Agent类型
+   * @returns 返回对应的Builder
+   */
+  getBuilder(type) {
+    const builder = this.builders.get(type);
+    if (!builder) {
+      throw new Error(`\u4E0D\u652F\u6301\u7684Agent\u7C7B\u578B: ${type}`);
+    }
+    return builder;
+  }
+};
+
+// src/agent_lattice/builders/AgentParamsBuilder.ts
+import {
+  getToolsFromConfig as getToolsFromConfig2,
+  getSubAgentsFromConfig as getSubAgentsFromConfig2,
+  isDeepAgentConfig as isDeepAgentConfig2,
+  isProcessingAgentConfig as isProcessingAgentConfig2
+} from "@axiom-lattice/protocols";
+var AgentParamsBuilder = class {
+  /**
+   * constructor
+   *
+   * @param getAgentLatticeFunc get Agent Lattice function
+   */
+  constructor(getAgentLatticeFunc) {
+    this.getAgentLatticeFunc = getAgentLatticeFunc;
+  }
+  /**
+   * build Agent parameters
+   *
+   * @param agentLattice Agent Lattice object
+   * @param options build options
+   * @returns Agent build parameters
+   */
+  async buildParams(agentLattice, options) {
+    const skills = isDeepAgentConfig2(agentLattice.config) || isProcessingAgentConfig2(agentLattice.config) ? agentLattice.config.skillCategories : void 0;
+    const toolKeys = options?.overrideTools || getToolsFromConfig2(agentLattice.config);
+    const tools = toolKeys.map((toolKey) => {
+      const toolLattice = toolLatticeManager.getToolLattice(toolKey);
+      if (!toolLattice) {
+        throw new Error(`Tool "${toolKey}" does not exist`);
+      }
+      return {
+        key: toolKey,
+        definition: toolLattice.config,
+        executor: toolLattice.client
+      };
+    });
+    const modelKey = options?.overrideModel || agentLattice.config.modelKey;
+    const model = modelKey ? modelLatticeManager.getModelLattice(modelKey).client : modelLatticeManager.getModelLattice("default").client;
+    if (!model) {
+      throw new Error(`Model "${modelKey}" does not exist`);
+    }
+    const subAgentKeys = getSubAgentsFromConfig2(agentLattice.config);
+    const subAgents = await Promise.all(subAgentKeys.map(async (agentKey) => {
+      const subAgentLattice = await this.getAgentLatticeFunc(agentKey);
+      if (!subAgentLattice) {
+        throw new Error(`SubAgent "${agentKey}" does not exist`);
+      }
+      return {
+        key: agentKey,
+        config: subAgentLattice.config,
+        client: subAgentLattice.client
+      };
+    }));
+    let internalSubAgents = [];
+    if (isDeepAgentConfig2(agentLattice.config) || isProcessingAgentConfig2(agentLattice.config)) {
+      internalSubAgents = agentLattice.config.internalSubAgents?.map((i) => ({
+        key: i.key,
+        config: i
+      })) || [];
+    }
+    return {
+      tools,
+      model,
+      subAgents: [...subAgents, ...internalSubAgents],
+      prompt: agentLattice.config.prompt,
+      stateSchema: agentLattice.config.schema,
+      skillCategories: skills,
+      middleware: agentLattice.config.middleware,
+      tenantId: agentLattice.config.tenantId
+    };
+  }
+};
+
+// src/agent_lattice/utils/mergeAgentConfig.ts
+var NON_INHERITABLE_FIELDS = /* @__PURE__ */ new Set([
+  "key",
   "extendsAgent"
 ]);
 function mergeAgentConfig(parent, child) {
@@ -17018,98 +17852,1105 @@ ${body}` : `${frontmatter}
           subSkills: updates.subSkills !== void 0 ? updates.subSkills : skill.subSkills,
           updatedAt: /* @__PURE__ */ new Date()
         };
-        await this.writeSkillFile(newSkill, context);
-        await this.deleteSkill(tenantId, id, context);
-        return newSkill;
+        await this.writeSkillFile(newSkill, context);
+        await this.deleteSkill(tenantId, id, context);
+        return newSkill;
+      }
+    }
+    const updatedSkill = {
+      ...skill,
+      name: updates.name ?? skill.name,
+      description: updates.description ?? skill.description,
+      license: updates.license ?? skill.license,
+      compatibility: updates.compatibility ?? skill.compatibility,
+      metadata: updates.metadata ?? skill.metadata,
+      content: updates.content !== void 0 ? updates.content : skill.content,
+      subSkills: updates.subSkills !== void 0 ? updates.subSkills : skill.subSkills,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    await this.writeSkillFile(updatedSkill, context);
+    return updatedSkill;
+  }
+  /**
+    * Delete a skill by ID
+    */
+  async deleteSkill(tenantId, id, context) {
+    if (isBuiltInSkill(id)) {
+      throw new Error(
+        `Skill "${id}" is a built-in skill and cannot be deleted`
+      );
+    }
+    try {
+      const sandbox = await this.getSandbox(tenantId, context);
+      const dirPath = this.getSkillDirectoryPath(tenantId, id);
+      const deleteResult = await sandbox.shell.execCommand({
+        command: `rm -rf ${dirPath}`
+      });
+      if (deleteResult.exit_code !== 0) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error(`Error deleting skill ${id}:`, error);
+      return false;
+    }
+  }
+  /**
+    * Check if skill exists
+    */
+  async hasSkill(tenantId, id, context) {
+    if (isBuiltInSkill(id)) return true;
+    const skill = await this.getSkillById(tenantId, id, context);
+    return skill !== null;
+  }
+  /**
+    * Search skills by metadata within a tenant
+    */
+  async searchByMetadata(tenantId, metadataKey, metadataValue, context) {
+    const allSkills = await this.getAllSkills(tenantId, context);
+    return allSkills.filter(
+      (skill) => skill.metadata && skill.metadata[metadataKey] === metadataValue
+    );
+  }
+  /**
+    * Filter skills by compatibility within a tenant
+    */
+  async filterByCompatibility(tenantId, compatibility, context) {
+    const allSkills = await this.getAllSkills(tenantId, context);
+    return allSkills.filter((skill) => skill.compatibility === compatibility);
+  }
+  /**
+    * Filter skills by license within a tenant
+    */
+  async filterByLicense(tenantId, license, context) {
+    const allSkills = await this.getAllSkills(tenantId, context);
+    return allSkills.filter((skill) => skill.license === license);
+  }
+  /**
+    * Get sub-skills of a parent skill within a tenant
+    */
+  async getSubSkills(tenantId, parentSkillName, context) {
+    const parentSkill = await this.getSkillById(tenantId, parentSkillName, context);
+    if (!parentSkill || !parentSkill.subSkills || parentSkill.subSkills.length === 0) {
+      return [];
+    }
+    const subSkills = [];
+    for (const subSkillName of parentSkill.subSkills) {
+      const subSkill = await this.getSkillById(tenantId, subSkillName, context);
+      if (subSkill) {
+        subSkills.push(subSkill);
+      }
+    }
+    return subSkills;
+  }
+};
+
+// src/agent_lattice/agentArchitectTools.ts
+import z54 from "zod";
+import { v4 as v42 } from "uuid";
+import { AgentType as AgentType2 } from "@axiom-lattice/protocols";
+function getTenantId(exeConfig) {
+  const runConfig = exeConfig?.configurable?.runConfig || {};
+  return runConfig.tenantId || "default";
+}
+function getAssistStore() {
+  return getStoreLattice("default", "assistant").store;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-") || "agent";
+}
+async function generateAgentId(tenantId, name) {
+  const store = getAssistStore();
+  const base = slugify(name);
+  let id = base;
+  let counter = 2;
+  while (true) {
+    const existing = await store.getAssistantById(tenantId, id);
+    if (!existing) return id;
+    id = `${base}-${counter}`;
+    counter++;
+  }
+}
+registerToolLattice(
+  "list_agents",
+  {
+    name: "list_agents",
+    description: "List all agents for the current workspace. Returns a summary with id, name, description, and type for each agent.",
+    schema: z54.object({})
+  },
+  async (_input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const agents = await store.getAllAssistants(tenantId);
+      return JSON.stringify({
+        agents: agents.map((a) => ({
+          id: a.id,
+          name: a.name,
+          description: a.description || "",
+          type: a.graphDefinition?.type || "react",
+          createdAt: a.createdAt,
+          updatedAt: a.updatedAt
+        }))
+      });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to list agents: ${error.message}` });
+    }
+  }
+);
+registerToolLattice(
+  "get_agent",
+  {
+    name: "get_agent",
+    description: "Get the full configuration of a specific agent by its ID. Returns the complete AgentConfig including prompt, middleware, tools, and sub-agents.",
+    schema: z54.object({
+      id: z54.string().describe("The agent ID to retrieve")
+    })
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const agent = await store.getAssistantById(tenantId, input.id);
+      if (!agent) {
+        return JSON.stringify({ error: `Agent '${input.id}' not found` });
+      }
+      return JSON.stringify(agent.graphDefinition);
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to get agent: ${error.message}` });
+    }
+  }
+);
+var middlewareConfigSchema = z54.object({
+  id: z54.string(),
+  type: z54.string(),
+  name: z54.string(),
+  description: z54.string(),
+  enabled: z54.boolean(),
+  config: z54.record(z54.any()).optional()
+});
+var createAgentSchema = z54.object({
+  name: z54.string().describe("Human-friendly display name for the agent. The machine ID (used in other tools) is auto-generated as a slug from this name (e.g. 'My Cool Agent' \u2192 'my-cool-agent')."),
+  description: z54.string().optional().describe("Short description"),
+  type: z54.enum(["react", "deep_agent"]).describe("Agent type. Use 'react' for simple single-responsibility agents, 'deep_agent' for complex open-ended agents. For PROCESSING agents (workflow orchestration), use create_processing_agent instead."),
+  prompt: z54.string().describe("System prompt for the agent"),
+  tools: z54.array(z54.string()).optional().describe("Tool keys (strings) to assign. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array of tool names. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
+  middleware: z54.array(middlewareConfigSchema).optional().describe("Middleware configuration objects. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here \u2014 tool names go in the separate 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  subAgents: z54.array(z54.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+  internalSubAgents: z54.array(z54.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+  modelKey: z54.string().optional().describe("Model key to use")
+});
+registerToolLattice(
+  "create_agent",
+  {
+    name: "create_agent",
+    description: "Create and save a new REACT or DEEP_AGENT. For PROCESSING agents, use create_processing_agent instead. Returns the new agent's ID and name. NOTE: 'tools' is a string array of tool names, 'middleware' is an object array of middleware configs \u2014 they are separate fields and must not be mixed. IMPORTANT: If the agent needs user confirmation, approval, or must ask clarifying questions, include the 'ask_user_to_clarify' middleware (type: 'ask_user_to_clarify', no config required).",
+    schema: createAgentSchema
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const id = await generateAgentId(tenantId, input.name);
+      const config = {
+        key: id,
+        name: input.name,
+        description: input.description || "",
+        type: input.type === "deep_agent" ? AgentType2.DEEP_AGENT : AgentType2.REACT,
+        prompt: input.prompt,
+        ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
+        ...input.middleware && input.middleware.length > 0 ? { middleware: input.middleware } : {},
+        ...input.subAgents && input.subAgents.length > 0 ? { subAgents: input.subAgents } : {},
+        ...input.internalSubAgents ? { internalSubAgents: input.internalSubAgents } : {},
+        ...input.modelKey ? { modelKey: input.modelKey } : {}
+      };
+      await store.createAssistant(tenantId, id, {
+        name: input.name,
+        description: input.description,
+        graphDefinition: config
+      });
+      return JSON.stringify({ id, name: input.name, type: input.type });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to create agent: ${error.message}` });
+    }
+  }
+);
+var topologyEdgeSchema = z54.object({
+  from: z54.string().describe("Source agent ID. For the first edge, this is the orchestrator (use the orchestrator's name as a placeholder \u2014 the tool will replace it with the actual ID). For subsequent chained edges, this is the previous stage's sub-agent ID."),
+  to: z54.string().describe("Target agent ID (the sub-agent to delegate to)"),
+  purpose: z54.string().describe("Business purpose of this delegation step \u2014 what the sub-agent should accomplish")
+});
+var createProcessingAgentSchema = z54.object({
+  name: z54.string().describe("Display name for the processing agent"),
+  description: z54.string().optional().describe("Short description"),
+  prompt: z54.string().describe("System prompt for the orchestrator. Should describe how to route tasks through the topology."),
+  edges: z54.array(topologyEdgeSchema).min(1).describe("Topology edges defining the workflow. Each edge describes a delegation step with its business purpose. The orchestrator will follow this topology to delegate tasks to sub-agents."),
+  tools: z54.array(z54.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
+  subAgents: z54.array(z54.string()).describe("IDs of sub-agents that form the workflow pipeline. These must be created first via create_agent."),
+  internalSubAgents: z54.array(z54.any()).optional().describe("Inline sub-agent configs (alternative to pre-created sub-agents)"),
+  middleware: z54.array(middlewareConfigSchema).optional().describe("Additional middleware config objects beyond the auto-managed topology middleware. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  modelKey: z54.string().optional().describe("Model key to use")
+}).refine(
+  (data) => {
+    const edgeTargets = new Set(data.edges.map((e) => e.to));
+    const subAgentIds = new Set(data.subAgents);
+    for (const target of edgeTargets) {
+      if (!subAgentIds.has(target)) {
+        return false;
+      }
+    }
+    return true;
+  },
+  { message: "All edge targets (to) must be included in the subAgents list" }
+);
+registerToolLattice(
+  "create_processing_agent",
+  {
+    name: "create_processing_agent",
+    description: "Create a PROCESSING agent with a business-defined workflow topology. The edges define a serial delegation chain: the first edge starts from the orchestrator (use its name as placeholder), then each subsequent edge chains from the previous stage's sub-agent. Sub-agents must be created first via create_agent. NOTE: 'tools' is a string array of tool names, 'middleware' is an object array \u2014 they are separate fields and must not be mixed. IMPORTANT: If any sub-agent or the orchestrator needs user confirmation/approval, include the 'ask_user_to_clarify' middleware on that specific agent.",
+    schema: createProcessingAgentSchema
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const id = await generateAgentId(tenantId, input.name);
+      const normalize = (s) => s.toLowerCase().replace(/[_\-\s]/g, "");
+      const resolveFrom = (rawFrom) => {
+        const fromLower = rawFrom.toLowerCase();
+        const nameLower = input.name.toLowerCase();
+        if (fromLower === nameLower || fromLower === "orchestrator" || fromLower === "orchestrator-id" || normalize(rawFrom) === normalize(input.name)) {
+          return id;
+        }
+        return rawFrom;
+      };
+      const topologyMiddleware = {
+        id: "topology",
+        type: "topology",
+        name: "Topology",
+        description: `Enforce ${input.edges.length}-step workflow topology`,
+        enabled: true,
+        config: {
+          edges: input.edges.map((e) => ({
+            from: resolveFrom(e.from),
+            to: e.to,
+            purpose: e.purpose
+          }))
+        }
+      };
+      const additionalMiddleware = input.middleware || [];
+      const middleware = [topologyMiddleware, ...additionalMiddleware];
+      const config = {
+        key: id,
+        name: input.name,
+        description: input.description || "",
+        type: AgentType2.PROCESSING,
+        prompt: input.prompt,
+        ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
+        middleware,
+        subAgents: input.subAgents,
+        ...input.internalSubAgents ? { internalSubAgents: input.internalSubAgents } : {},
+        ...input.modelKey ? { modelKey: input.modelKey } : {}
+      };
+      await store.createAssistant(tenantId, id, {
+        name: input.name,
+        description: input.description,
+        graphDefinition: config
+      });
+      return JSON.stringify({
+        id,
+        name: input.name,
+        type: "processing",
+        topology: {
+          edges: input.edges.map((e) => ({ from: resolveFrom(e.from), to: e.to, purpose: e.purpose }))
+        }
+      });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to create processing agent: ${error.message}` });
+    }
+  }
+);
+var updateProcessingAgentSchema = z54.object({
+  id: z54.string().describe("The PROCESSING agent ID to update"),
+  name: z54.string().optional().describe("New display name for the orchestrator"),
+  description: z54.string().optional().describe("New short description"),
+  prompt: z54.string().optional().describe("New system prompt for the orchestrator"),
+  edges: z54.array(topologyEdgeSchema).min(1).optional().describe("New topology edges. First edge's from must reference the orchestrator by name (the tool replaces it). Subsequent edges chain from previous sub-agent IDs."),
+  tools: z54.array(z54.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array \u2014 do NOT put middleware-like objects here."),
+  subAgents: z54.array(z54.string()).optional().describe("New IDs of sub-agents in the workflow pipeline"),
+  middleware: z54.array(middlewareConfigSchema).optional().describe("Additional middleware config objects (topology middleware is auto-managed, do not include it). Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  modelKey: z54.string().optional().describe("New model key")
+}).refine(
+  (data) => {
+    if (!data.edges) return true;
+    const subAgentIds = new Set(data.subAgents || []);
+    if (subAgentIds.size === 0) return true;
+    const edgeTargets = new Set(data.edges.map((e) => e.to));
+    for (const target of edgeTargets) {
+      if (!subAgentIds.has(target)) {
+        return false;
+      }
+    }
+    return true;
+  },
+  { message: "All edge targets (to) must be included in the subAgents list" }
+);
+registerToolLattice(
+  "update_processing_agent",
+  {
+    name: "update_processing_agent",
+    description: "Update an existing PROCESSING agent's topology edges, name, prompt, tools, or sub-agents. Use this instead of update_agent for PROCESSING agents because edges require proper placeholder resolution and topology middleware management. NOTE: 'tools' is a string array of tool names, 'middleware' is an object array \u2014 they are separate fields and must not be mixed. For user approval/confirmation scenarios, add middleware with type: 'ask_user_to_clarify'.",
+    schema: updateProcessingAgentSchema
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const existing = await store.getAssistantById(tenantId, input.id);
+      if (!existing) {
+        return JSON.stringify({ error: `Agent '${input.id}' not found` });
+      }
+      const existingConfig = existing.graphDefinition || {};
+      if (existingConfig.type !== AgentType2.PROCESSING) {
+        return JSON.stringify({ error: `Agent '${input.id}' is not a PROCESSING agent (type: ${existingConfig.type})` });
+      }
+      const normalize = (s) => s.toLowerCase().replace(/[_\-\s]/g, "");
+      const orchestratorName = input.name || existingConfig.name || existing.name || "";
+      const resolveFrom = (rawFrom) => {
+        const fromLower = rawFrom.toLowerCase();
+        const nameLower = orchestratorName.toLowerCase();
+        if (fromLower === nameLower || fromLower === "orchestrator" || fromLower === "orchestrator-id" || normalize(rawFrom) === normalize(orchestratorName)) {
+          return input.id;
+        }
+        return rawFrom;
+      };
+      let middleware = existingConfig.middleware || [];
+      let resolvedEdges;
+      if (input.edges) {
+        resolvedEdges = input.edges.map((e) => ({
+          from: resolveFrom(e.from),
+          to: e.to,
+          purpose: e.purpose
+        }));
+        const topoIndex = middleware.findIndex(
+          (m) => m.type === "topology"
+        );
+        const topoMiddleware = {
+          id: "topology",
+          type: "topology",
+          name: "Topology",
+          description: `Enforce ${resolvedEdges.length}-step workflow topology`,
+          enabled: true,
+          config: { edges: resolvedEdges }
+        };
+        if (topoIndex >= 0) {
+          middleware = [...middleware];
+          middleware[topoIndex] = topoMiddleware;
+        } else {
+          middleware = [topoMiddleware, ...middleware];
+        }
+        if (input.middleware) {
+          const nonTopo = input.middleware.filter(
+            (m) => m.type !== "topology"
+          );
+          const topoIdx = middleware.findIndex(
+            (m) => m.type === "topology"
+          );
+          const prefix = middleware.slice(0, topoIdx + 1);
+          const suffix = middleware.slice(topoIdx + 1);
+          middleware = [...prefix, ...nonTopo];
+        }
+      } else if (input.middleware) {
+        const nonTopo = input.middleware.filter(
+          (m) => m.type !== "topology"
+        );
+        const topoIdx = middleware.findIndex(
+          (m) => m.type === "topology"
+        );
+        if (topoIdx >= 0) {
+          middleware = [...middleware.slice(0, topoIdx + 1), ...nonTopo];
+        } else {
+          middleware = [...middleware, ...nonTopo];
+        }
       }
-    }
-    const updatedSkill = {
-      ...skill,
-      name: updates.name ?? skill.name,
-      description: updates.description ?? skill.description,
-      license: updates.license ?? skill.license,
-      compatibility: updates.compatibility ?? skill.compatibility,
-      metadata: updates.metadata ?? skill.metadata,
-      content: updates.content !== void 0 ? updates.content : skill.content,
-      subSkills: updates.subSkills !== void 0 ? updates.subSkills : skill.subSkills,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    await this.writeSkillFile(updatedSkill, context);
-    return updatedSkill;
-  }
-  /**
-    * Delete a skill by ID
-    */
-  async deleteSkill(tenantId, id, context) {
-    if (isBuiltInSkill(id)) {
-      throw new Error(
-        `Skill "${id}" is a built-in skill and cannot be deleted`
+      const mergedConfig = {
+        ...existingConfig,
+        ...input.name !== void 0 ? { name: input.name } : {},
+        ...input.description !== void 0 ? { description: input.description } : {},
+        ...input.prompt !== void 0 ? { prompt: input.prompt } : {},
+        ...input.tools !== void 0 ? { tools: input.tools } : {},
+        ...input.subAgents !== void 0 ? { subAgents: input.subAgents } : {},
+        ...input.modelKey !== void 0 ? { modelKey: input.modelKey } : {},
+        middleware,
+        key: input.id
+      };
+      const newName = input.name || existing.name;
+      await store.updateAssistant(tenantId, input.id, {
+        name: newName,
+        description: input.description !== void 0 ? input.description : existing.description,
+        graphDefinition: mergedConfig
+      });
+      const topoConfig = middleware.find(
+        (m) => m.type === "topology"
       );
+      return JSON.stringify({
+        id: input.id,
+        name: newName,
+        type: "processing",
+        topology: {
+          edges: topoConfig?.config?.edges || resolvedEdges || []
+        }
+      });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to update processing agent: ${error.message}` });
     }
+  }
+);
+var updateAgentSchema = z54.object({
+  id: z54.string().describe("The agent ID to update"),
+  config: z54.object({
+    name: z54.string().optional().describe("New display name for the agent"),
+    description: z54.string().optional().describe("New short description"),
+    type: z54.enum(["react", "deep_agent"]).optional().describe("Agent type"),
+    prompt: z54.string().optional().describe("New system prompt for the agent"),
+    tools: z54.array(z54.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
+    middleware: z54.array(middlewareConfigSchema).optional().describe("Middleware configurations. NOTE: middleware objects have type/name/description/enabled/config fields and are NOT the same as tools. Tool keys go in the 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+    subAgents: z54.array(z54.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+    internalSubAgents: z54.array(z54.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+    modelKey: z54.string().optional().describe("Model key to use")
+  }).describe("Configuration fields to update. Only include the fields you want to change.")
+});
+registerToolLattice(
+  "update_agent",
+  {
+    name: "update_agent",
+    description: "Update an existing agent's configuration. Provide the agent ID and the fields to change. Returns the updated agent's ID and name. NOTE: For user approval/confirmation scenarios, add middleware with type: 'ask_user_to_clarify'.",
+    schema: updateAgentSchema
+  },
+  async (input, exeConfig) => {
     try {
-      const sandbox = await this.getSandbox(tenantId, context);
-      const dirPath = this.getSkillDirectoryPath(tenantId, id);
-      const deleteResult = await sandbox.shell.execCommand({
-        command: `rm -rf ${dirPath}`
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const existing = await store.getAssistantById(tenantId, input.id);
+      if (!existing) {
+        return JSON.stringify({ error: `Agent '${input.id}' not found` });
+      }
+      const existingConfig = existing.graphDefinition || {};
+      const mergedConfig = { ...existingConfig, ...input.config };
+      const newName = input.config.name || existing.name;
+      await store.updateAssistant(tenantId, input.id, {
+        name: newName,
+        description: input.config.description !== void 0 ? input.config.description : existing.description,
+        graphDefinition: mergedConfig
       });
-      if (deleteResult.exit_code !== 0) {
-        return false;
-      }
-      return true;
+      return JSON.stringify({ id: input.id, name: newName });
     } catch (error) {
-      console.error(`Error deleting skill ${id}:`, error);
-      return false;
+      return JSON.stringify({ error: `Failed to update agent: ${error.message}` });
     }
   }
-  /**
-    * Check if skill exists
-    */
-  async hasSkill(tenantId, id, context) {
-    if (isBuiltInSkill(id)) return true;
-    const skill = await this.getSkillById(tenantId, id, context);
-    return skill !== null;
+);
+registerToolLattice(
+  "delete_agent",
+  {
+    name: "delete_agent",
+    description: "Permanently delete an agent by its ID. This action cannot be undone.",
+    schema: z54.object({
+      id: z54.string().describe("The agent ID to delete")
+    })
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const existing = await store.getAssistantById(tenantId, input.id);
+      if (!existing) {
+        return JSON.stringify({ error: `Agent '${input.id}' not found`, success: false });
+      }
+      const success = await store.deleteAssistant(tenantId, input.id);
+      return JSON.stringify({ success, id: input.id });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to delete agent: ${error.message}` });
+    }
   }
-  /**
-    * Search skills by metadata within a tenant
-    */
-  async searchByMetadata(tenantId, metadataKey, metadataValue, context) {
-    const allSkills = await this.getAllSkills(tenantId, context);
-    return allSkills.filter(
-      (skill) => skill.metadata && skill.metadata[metadataKey] === metadataValue
-    );
+);
+registerToolLattice(
+  "list_tools",
+  {
+    name: "list_tools",
+    description: "List all available tools that can be assigned to agents. Returns each tool's name (use this string value in the 'tools' array), description, and whether it requires user approval. The tool names from this list are what you pass as strings in the 'tools' field of create_agent or update_agent.",
+    schema: z54.object({})
+  },
+  async (_input, _exeConfig) => {
+    try {
+      const lattices = toolLatticeManager.getAllLattices();
+      return JSON.stringify({
+        tools: lattices.map((l) => ({
+          name: l.config.name,
+          description: l.config.description,
+          needUserApprove: l.config.needUserApprove ?? false
+        }))
+      });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to list tools: ${error.message}` });
+    }
   }
-  /**
-    * Filter skills by compatibility within a tenant
-    */
-  async filterByCompatibility(tenantId, compatibility, context) {
-    const allSkills = await this.getAllSkills(tenantId, context);
-    return allSkills.filter((skill) => skill.compatibility === compatibility);
+);
+registerToolLattice(
+  "invoke_agent",
+  {
+    name: "invoke_agent",
+    description: "Invoke an agent with a test message and return its response. Use this to verify an agent works correctly after creating or modifying it. The agent must be compiled (already created and valid).",
+    schema: z54.object({
+      id: z54.string().describe("The agent ID to invoke"),
+      message: z54.string().describe("The test message to send to the agent")
+    })
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const { id, message } = input;
+      const store = getAssistStore();
+      const existing = await store.getAssistantById(tenantId, id);
+      if (!existing) {
+        return JSON.stringify({ error: `Agent '${id}' not found` });
+      }
+      const threadId = v42();
+      const agent = new Agent({
+        tenant_id: tenantId,
+        assistant_id: id,
+        thread_id: threadId
+      });
+      const result = await agent.invoke({ input: { message } });
+      const messages = result?.messages || [];
+      const lastAi = [...messages].reverse().find(
+        (m) => m.role === "ai" || m.type === "ai"
+      );
+      const content = lastAi?.content ?? "(no response)";
+      return JSON.stringify({
+        agentId: id,
+        threadId,
+        response: typeof content === "string" ? content : JSON.stringify(content)
+      });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to invoke agent: ${error.message}` });
+    }
   }
-  /**
-    * Filter skills by license within a tenant
-    */
-  async filterByLicense(tenantId, license, context) {
-    const allSkills = await this.getAllSkills(tenantId, context);
-    return allSkills.filter((skill) => skill.license === license);
+);
+
+// src/agent_lattice/agentArchitectConfig.ts
+import { AgentType as AgentType3 } from "@axiom-lattice/protocols";
+
+// src/agent_lattice/agentArchitectPrompt.ts
+var AGENT_ARCHITECT_PROMPT = `# Agent Architect
+
+You are an **Agent Architect** \u2014 an expert AI system designer. You help users transform natural language requirements into working AI agents.
+
+## Your Tools
+
+You have nine tools:
+- **list_agents** \u2014 See all existing agents for this workspace
+- **list_tools** \u2014 See all available tools that can be assigned to agents
+- **get_agent** \u2014 View the full configuration of a specific agent
+- **create_agent** \u2014 Create a REACT or DEEP_AGENT agent
+- **create_processing_agent** \u2014 Create a PROCESSING agent with business-defined workflow topology
+- **update_processing_agent** \u2014 Modify a PROCESSING agent's topology edges, name, prompt, or sub-agents
+- **update_agent** \u2014 Modify an existing REACT or DEEP_AGENT agent's configuration
+- **delete_agent** \u2014 Remove an agent permanently
+- **invoke_agent** \u2014 Test an agent by sending a message and getting its response
+
+## Global Interaction Rules
+
+1. **One question at a time.** Never overwhelm the user. Each message should ask exactly one question or present exactly one decision.
+2. **Confirm before creating.** Always present your design to the user and get explicit approval before calling create_agent or update_agent.
+3. **Be concise.** Show configs clearly but briefly. Use structured formats when presenting designs.
+4. **Use kebab-case for agent names.** E.g., "code-reviewer", "data-analyzer".
+
+---
+
+## Agent Types Overview
+
+| Type | Best for | Execution Model |
+|------|----------|----------------|
+| **react** | Simple, single-responsibility tasks | Classic ReAct loop (think \u2192 act \u2192 observe) |
+| **processing** | Standard BPO workflows, preset process orchestration | Topology-driven: predefined agent topology with reliable multi-agent coordination |
+| **deep_agent** | Complex, open-ended tasks requiring dynamic decomposition | Self-generating dynamic todos: agent analyzes the task and creates its own execution plan at runtime |
+
+---
+
+## Workflow A: Simple Agent (REACT type)
+
+Use this for straightforward tasks \u2014 a single agent with a single responsibility, no sub-agent decomposition needed. The classic ReAct pattern: the agent reasons, acts, and observes in a loop.
+
+### Step 1: Understand the Goal
+Ask: What should this agent do? Who will use it? What are the inputs and outputs?
+
+### Step 2: Choose Middleware
+Based on the goal, recommend which middleware the agent needs. Call **list_tools** first to verify what's available, then consult the **Middleware Config Reference** at the bottom of this prompt for exact config shapes.
+
+**IMPORTANT:** If the agent needs user confirmation, approval, or must ask the user clarifying questions, you MUST include the **ask_user_to_clarify** middleware. Do NOT assume the user will be available to answer in chat \u2014 the ask_user_to_clarify tool is the only way for the agent to pause and request input.
+
+### Step 3: Write the System Prompt
+Craft the agent's system prompt with:
+1. **Role definition** \u2014 Who the agent is and what it does
+2. **Workflow** \u2014 Step-by-step instructions
+3. **Constraints** \u2014 Boundaries, quality standards, forbidden actions
+
+Present the prompt. Get user confirmation.
+
+### Step 4: Create
+Call create_agent with the agreed configuration.
+
+---
+
+## Workflow B: Workflow Agent (PROCESSING type)
+
+Use this when the task follows a standard BPO (Business Process Orchestration) pattern \u2014 a predefined topology of sub-agents working through a preset pipeline or process. The topology is designed upfront and sub-agents coordinate according to the defined flow. This is the most reliable type for multi-agent workflows where the process is well-understood.
+
+### Phase 1: Process Analysis
+
+Ask: What is the end-to-end process we need to automate? What are the stages?
+
+Based on the answer, identify the processing stages. Output a **pipeline**:
+
+\`\`\`
+I see the following processing stages:
+\u251C\u2500\u2500 Input Intake: [what happens]
+\u251C\u2500\u2500 Stage 1: [processing step]
+\u251C\u2500\u2500 Stage 2: [processing step]
+\u2514\u2500\u2500 Output: [final deliverable]
+
+Do these stages look right?
+\`\`\`
+
+### Phase 2: Topology Design
+
+Define the agent topology. Each stage may be handled by a dedicated sub-agent. Create a **topology diagram**:
+
+\`\`\`
+    \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510      \u250C\u2500\u2500\u2500\u2500\u2510      \u250C\u2500\u2500\u2500\u2500\u2510      \u250C\u2500\u2500\u2500\u2500\u2510
+    \u2502  Orchestrator    \u2502 \u2500\u2500\u25BA  \u2502Stage\u2502 \u2500\u2500\u25BA  \u2502Stage\u2502 \u2500\u2500\u25BA  \u2502Stage\u2502
+    \u2502                  \u2502      \u2502  1  \u2502      \u2502  2  \u2502      \u2502  3  \u2502
+    \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518      \u2514\u2500\u2500\u2500\u2500\u2518      \u2514\u2500\u2500\u2500\u2500\u2518      \u2514\u2500\u2500\u2500\u2500\u2518
+
+Flow: Orchestrator \u2192 Stage 1 \u2192 Stage 2 \u2192 Stage 3 \u2192 Output
+
+Each edge chains from the previous node:
+  Orchestrator \u2500\u2500\u25BA Stage 1 \u2500\u2500\u25BA Stage 2 \u2500\u2500\u25BA Stage 3
+\`\`\`
+
+**Design checks:**
+- Each stage has exactly one responsibility
+- The flow between stages is a serial chain \u2014 each stage processes output from the previous one
+- The orchestrator directs the first stage, then each stage hands off to the next
+- The orchestrator enforces the topology \u2014 it does NOT improvise
+- Error handling per stage: retry, skip, or escalate
+
+### Phase 3: Design Each Sub-Agent
+
+For each sub-agent, one at a time:
+
+1. **Responsibility** \u2014 One sentence
+2. **System Prompt** \u2014 Role + workflow + constraints
+3. **Middleware** \u2014 Which middleware, and why (include ask_user_to_clarify if this sub-agent needs user approval)
+4. **Input/Output contract** \u2014 What it receives, what it returns
+
+Present each sub-agent design. Get user confirmation before moving to the next.
+
+### Phase 4: Design the Orchestrator
+
+The orchestrator is the parent PROCESSING agent. Use **create_processing_agent** (NOT create_agent):
+
+1. **Responsibility** \u2014 Receive user request, route through the pipeline stages, enforce topology
+2. **System Prompt** \u2014 The defined topology, when to call which sub-agent, error handling
+3. **Topology edges** \u2014 One edge per pipeline stage with a business-meaningful purpose
+4. **Sub-agent list** \u2014 All sub-agents with their role in the pipeline
+
+### Phase 5: Final Review
+
+Before creating, check:
+1. **Completeness** \u2014 Is every stage of the process covered by an edge?
+2. **Purposes** \u2014 Does each edge's purpose clearly describe the business intent?
+3. **Order** \u2014 Is the edge sequence correct?
+4. **Handoffs** \u2014 Is data passed correctly between stages?
+5. **Edge cases** \u2014 What happens on invalid input, stage failure, timeout?
+
+### Creation Order
+
+Always create sub-agents FIRST (via create_agent as react agents), then the orchestrator via create_processing_agent.
+
+\`\`\`
+Creating:
+1. create_agent(name: "stage-1", type: "react", ...)
+2. create_agent(name: "stage-2", type: "react", ...)
+3. create_agent(name: "stage-3", type: "react", ...)
+4. create_processing_agent(
+     name: "orchestrator",
+     prompt: "...",
+     edges: [
+       { from: "orchestrator", to: "stage-1-id", purpose: "Validate and normalize input data" },
+       { from: "stage-1-id", to: "stage-2-id", purpose: "Transform data into target format" },
+       { from: "stage-2-id", to: "stage-3-id", purpose: "Generate final output report" },
+     ],
+     subAgents: ["stage-1-id", "stage-2-id", "stage-3-id"],
+   )
+\`\`\`
+
+**Why serial?** The topology is a chain: Orchestrator \u2192 Stage 1 \u2192 Stage 2 \u2192 Stage 3. Only the first edge's \`from\` references the orchestrator (by name). Subsequent edges chain from the previous sub-agent's ID. The tool automatically replaces the orchestrator name placeholder with the actual generated ID.
+
+---
+
+## Workflow C: Dynamic Agent (DEEP_AGENT type)
+
+Use this for complex, open-ended tasks where the execution path cannot be fully predetermined. The DEEP_AGENT analyzes the user's intent, self-generates a dynamic todo list, and iteratively works through it \u2014 creating, updating, and completing todos as understanding evolves. This is ideal when the task requires exploration, research, or creative problem-solving where the steps emerge during execution.
+
+### Phase 1: Domain Analysis
+
+Ask: What is the overall goal? What makes this complex or open-ended?
+
+Explain why a DEEP_AGENT is the right choice (dynamic decomposition, exploration-driven, adaptive planning).
+
+### Phase 2: Identify Capabilities
+
+Instead of designing a fixed topology, identify what capabilities the agent needs:
+
+\`\`\`
+The agent will need:
+\u251C\u2500\u2500 Capability A: [what the agent must be able to do]
+\u251C\u2500\u2500 Capability B: [what the agent must be able to do]
+\u2514\u2500\u2500 Capability C: [what the agent must be able to do]
+\`\`\`
+
+Each capability maps to middleware or a sub-agent tool.
+
+### Phase 3: Design the Agent
+
+1. **System Prompt** \u2014 Emphasize the dynamic todo-driven workflow. The agent should:
+   - Analyze the user's request and break it into a todo list
+   - Work through todos one at a time
+   - Update and refine the todo list as understanding deepens
+   - Self-correct and adapt based on intermediate findings
+
+2. **Middleware** \u2014 Tools the agent needs:
+   - **filesystem** \u2014 Essential for persistent work
+   - **code_eval** \u2014 If computation or data analysis is needed
+   - **browser** \u2014 If research or web access is needed
+   - **skill** \u2014 If domain-specific workflows are available
+   - **widget** \u2014 If visual output (diagrams, interactive content) is beneficial
+   - **ask_user_to_clarify** \u2014 If the agent needs to confirm actions or ask clarifying questions
+
+3. **Sub-agents** (optional) \u2014 Specialized agents the deep agent can delegate to for specific capabilities
+
+### Phase 4: Final Review
+
+Before creating, check:
+1. **Autonomy** \u2014 Can the agent operate independently?
+2. **Tools** \u2014 Does it have everything needed to self-decompose tasks?
+3. **Guardrails** \u2014 Are there clear boundaries on what the agent should NOT do?
+
+### Creation
+
+\`\`\`
+create_agent(
+  name: "research-agent",
+  type: "deep_agent",
+  prompt: "...",
+  middleware: [...],
+  subAgents: [...]  // optional
+)
+\`\`\`
+
+---
+
+## Editing Existing Agents
+
+When the user wants to modify an agent:
+1. Call **get_agent** to see the current config
+2. Understand what the user wants to change
+3. Present the proposed changes
+4. Call **update_agent** to apply
+
+## Deleting Agents
+
+When the user wants to delete an agent:
+1. Call **get_agent** to show what will be deleted
+2. Warn if this agent is referenced as a sub-agent by others
+3. Ask for explicit confirmation
+4. Call **delete_agent**
+
+## Agent Configuration Reference
+
+### create_agent (REACT and DEEP_AGENT)
+
+All fields except name, type, and prompt are optional.
+
+\`\`\`typescript
+{
+  name: string,              // Required. Display name
+  description?: string,      // Optional. Short description
+  type: "react" | "deep_agent", // Required
+  prompt: string,            // Required. System prompt
+  tools?: string[],          // Optional. Tool keys from list_tools
+  middleware?: MiddlewareConfig[],  // Optional. See middleware reference below
+  subAgents?: string[],      // DEEP_AGENT only. IDs of sub-agents
+  internalSubAgents?: AgentConfig[],    // DEEP_AGENT only. Inline sub-agent configs
+  modelKey?: string,         // Optional. Model to use
+}
+\`\`\`
+
+### create_processing_agent (PROCESSING)
+
+Creates a PROCESSING agent with a business-defined workflow topology. Sub-agents must already exist.
+
+\`\`\`typescript
+{
+  name: string,              // Required. Display name for the orchestrator
+  description?: string,      // Optional. Short description
+  prompt: string,            // Required. System prompt \u2014 how to route through the topology
+  edges: [{                  // Required. At least 1 edge defining the workflow
+    from: string,            // Orchestrator's ID (use placeholder name; tool auto-replaces)
+    to: string,              // Sub-agent ID to delegate to
+    purpose: string,         // Business purpose \u2014 what this step accomplishes
+  }],
+  tools?: string[],          // Optional. Tool keys from list_tools
+  subAgents: string[],       // Required. IDs of sub-agents in the pipeline
+  internalSubAgents?: AgentConfig[],  // Optional. Inline sub-agent configs
+  middleware?: MiddlewareConfig[],    // Optional. Additional middleware (topology is auto-added)
+  modelKey?: string,         // Optional. Model to use
+}
+\`\`\`
+
+### create_processing_agent (PROCESSING)
+
+Creates a PROCESSING agent with a business-defined workflow topology. Sub-agents must already exist.
+
+\`\`\`typescript
+{
+  name: string,              // Required. Display name for the orchestrator
+  description?: string,      // Optional. Short description
+  prompt: string,            // Required. System prompt \u2014 how to route through the topology
+  edges: [{                  // Required. At least 1 edge defining the serial workflow chain
+    from: string,            // Source agent ID. First edge: use orchestrator name as placeholder (tool auto-replaces). Subsequent edges: previous sub-agent ID
+    to: string,              // Sub-agent ID to delegate to
+    purpose: string,         // Business purpose \u2014 what this step accomplishes
+  }],
+  subAgents: string[],       // Required. IDs of sub-agents in the pipeline
+  internalSubAgents?: AgentConfig[],  // Optional. Inline sub-agent configs
+  middleware?: MiddlewareConfig[],    // Optional. Additional middleware (topology is auto-added)
+  modelKey?: string,         // Optional. Model to use
+}
+\`\`\`
+
+### Middleware Config Reference
+
+Each middleware entry uses this base shape:
+
+\`\`\`typescript
+{
+  id: string,          // Unique ID, usually same as type
+  type: string,        // Middleware type from the table below
+  name: string,        // Display name
+  description: string, // What this middleware provides
+  enabled: true,       // Always true for active middleware
+  config: { ... }      // Type-specific config (see table)
+}
+\`\`\`
+
+#### filesystem
+Provides: \`ls\`, \`read_file\`, \`write_file\`, \`edit_file\`, \`glob\`, \`grep\`
+| config field | type | description |
+|-------------|------|-------------|
+| backend | string | Pluggable backend, usually omitted (uses default) |
+| systemPrompt | string? | Custom system prompt override for filesystem conventions |
+
+#### code_eval
+Provides: \`run_code\` \u2014 execute Python/JavaScript in a sandbox
+| config field | type | description |
+|-------------|------|-------------|
+| vmIsolation | "agent" | "project" | "global" | Sandbox isolation level. Default recommended: \`"agent"\` |
+| timeout | number? | Execution timeout in milliseconds |
+| memoryLimit | number? | Memory limit in MB |
+
+#### browser
+Provides: \`browser_navigate\`, \`browser_click\`, \`browser_screenshot\`, \`browser_get_markdown\`, etc. (21 tools)
+| config field | type | description |
+|-------------|------|-------------|
+| vmIsolation | "agent" | "project" | "global" | Sandbox isolation level. Default recommended: \`"agent"\` |
+| headless | boolean? | Whether to run in headless mode |
+
+#### sql
+Provides: \`sql_list_tables\`, \`sql_table_info\`, \`sql_query_checker\`, \`sql_query\`
+| config field | type | description |
+|-------------|------|-------------|
+| databaseKeys | string[] | Array of database config keys to expose. Required. |
+| databaseDescriptions | Record<string,string>? | Optional human-readable descriptions keyed by database key |
+
+#### skill
+Provides: \`load_skill_content\` \u2014 load and read detailed skill instructions
+| config field | type | description |
+|-------------|------|-------------|
+| skills | string[]? | List of specific skill IDs to expose |
+| readAll | boolean? | When \`true\`, all available skills are exposed (recommended) |
+| heading | string? | Optional heading for the skills section |
+| extraNote | string? | Optional extra note appended after skills list |
+
+#### metrics
+Provides: \`list_datasources\`, \`query_metrics_list\`, \`query_semantic_metric_data\`, \`query_tables_list\`, \`execute_sql_query\`, etc. (7 tools)
+| config field | type | description |
+|-------------|------|-------------|
+| serverKeys | string[] | List of metrics server keys. Required. |
+| serverDescriptions | Record<string,string>? | Optional descriptions for each server |
+| connectAll | boolean? | When \`true\`, connects to all available metrics servers automatically |
+
+#### ask_user_to_clarify
+Provides: \`ask_user_to_clarify\` \u2014 pause execution and present questions with predefined options to the user. The agent halts until the user responds, then receives the answers as structured data.
+**Use this when:** the agent needs to confirm an action, get user approval, ask "which one?", or gather missing parameters. Without this middleware, the agent CANNOT interact with the user mid-execution.
+Config: \`{}\` \u2014 no configuration needed.
+
+#### widget
+Provides: \`load_guidelines\`, \`show_widget\` \u2014 render interactive HTML widgets and SVG diagrams
+Config: \`{}\` \u2014 no configuration needed.
+
+#### claw
+Provides: bootstrap file management (AGENTS.md, SOUL.md, etc.) \u2014 injects project context into system prompt
+| config field | type | description |
+|-------------|------|-------------|
+| injectBootstrapFiles | boolean? | Whether to inject bootstrap files into system prompt. Default: \`true\` |
+| bootstrapFiles | object? | Custom content for each bootstrap file |
+
+\`bootstrapFiles\` sub-fields: \`agents\`, \`soul\`, \`identity\`, \`user\`, \`tools\`, \`bootstrap\` \u2014 each is an optional string.
+
+#### date
+Provides: \`get_current_date_time\` \u2014 get current date and time
+| config field | type | description |
+|-------------|------|-------------|
+| timezone | string? | IANA timezone like \`"Asia/Shanghai"\` or \`"America/New_York"\`. Default: \`"UTC"\` |
+
+#### scheduler
+Provides: \`schedule_at\`, \`schedule_after\`, \`schedule_recurring\`, \`cancel_scheduled_task\`, \`list_scheduled_tasks\`
+| config field | type | description |
+|-------------|------|-------------|
+| defaultMaxRetries | number? | Default max retries for scheduled tasks. Default: \`0\` |
+
+#### topology
+Provides: \`read_topo_progress\` \u2014 enforces multi-agent workflow topology. **Required for PROCESSING agents \u2014 auto-injected by create_processing_agent.**
+| config field | type | description |
+|-------------|------|-------------|
+| edges | TopologyEdge[] | **Required.** Directed edges: \`{ from: string, to: string, purpose: string }\`. The \`purpose\` must describe the business intent of this delegation step. |
+| trackingStore | object? | Optional persistence for workflow run tracking | |
+
+### When to use ask_user_to_clarify Middleware
+
+**CRITICAL: Always add this middleware when the agent needs user confirmation, approval, or clarification.** Without it, the agent cannot interact with the user during execution.
+
+**Required scenarios:**
+- Confirming irreversible actions (delete data, send emails, make purchases, modify production configs)
+- Asking the user to choose between options (e.g., "Which database?", "Which report format?")
+- Gathering missing parameters the user didn't provide upfront
+- Requesting user approval before proceeding to a critical step
+- Disambiguating vague user requests before acting
+
+**Tool capabilities:**
+| Feature | Description |
+|---------|-------------|
+| Single choice | User picks ONE option from a list (e.g., "Choose environment: [production] [staging]") |
+| Multiple choice | User picks SEVERAL options (e.g., "Select reports: [sales] [inventory] [hr]") |
+| Required | Forces the user to answer before the agent continues |
+| allowOther | Lets the user type a custom answer beyond listed options |
+
+**Design rule:** If your agent's system prompt says anything like "confirm with the user before...", "ask the user to choose...", or "get approval for...", you MUST include the \`ask_user_to_clarify\` middleware.
+
+### Quick Pick: Common Middleware Combos
+
+| Agent Role | Recommended Middleware |
+|-----------|----------------------|
+| Code assistant | filesystem, code_eval, widget |
+| Data analyst | filesystem, sql, code_eval, widget |
+| Web researcher | browser, filesystem, widget |
+| Operations / SRE | metrics, sql, widget |
+| Process orchestrator | skill, date, scheduler, widget |
+| General assistant | filesystem, date, widget |
+| Approval-gated operations | ask_user_to_clarify, filesystem, widget |
+| Interactive Q&A | ask_user_to_clarify, date, widget |
+
+### update_processing_agent
+
+Updates a PROCESSING agent's topology edges, name, prompt, or sub-agents. Unlike update_agent, this properly handles placeholder resolution for edge \`from\` values and manages the topology middleware correctly.
+
+\`\`\`typescript
+{
+  id: string,                // Required. The PROCESSING agent ID to update
+  name?: string,             // Optional. New display name
+  description?: string,      // Optional. New short description
+  prompt?: string,           // Optional. New orchestrator system prompt
+  edges?: [{                 // Optional. New topology edges (serial chain)
+    from: string,            // First edge: orchestrator name placeholder. Subsequent: previous sub-agent ID
+    to: string,              // Sub-agent ID
+    purpose: string,         // Business purpose
+  }],
+  subAgents?: string[],      // Optional. New sub-agent IDs
+  middleware?: MiddlewareConfig[],  // Optional. Additional middleware (topology auto-managed)
+  modelKey?: string,         // Optional. New model
+}
+\`\`\`
+
+**When to use:** Use this whenever you need to change a PROCESSING agent's topology \u2014 adding/removing/recruiting pipeline stages, changing the flow order, or updating edge purposes. Use regular \`update_agent\` only for REACT and DEEP_AGENT agents.
+
+### update_agent parameters
+
+\`\`\`typescript
+{
+  id: string,                // Required. Agent ID to update
+  config: {                  // Required. Full or partial agent config
+    name?: string,
+    description?: string,
+    prompt?: string,
+    middleware?: [...],
+    // ... any other fields
   }
-  /**
-    * Get sub-skills of a parent skill within a tenant
-    */
-  async getSubSkills(tenantId, parentSkillName, context) {
-    const parentSkill = await this.getSkillById(tenantId, parentSkillName, context);
-    if (!parentSkill || !parentSkill.subSkills || parentSkill.subSkills.length === 0) {
-      return [];
+}
+\`\`\`
+`;
+
+// src/agent_lattice/agentArchitectConfig.ts
+var AGENT_ARCHITECT_KEY = "agent-architect";
+var agentArchitectConfig = {
+  key: AGENT_ARCHITECT_KEY,
+  name: "Agent Architect",
+  description: "Design and manage AI agents through natural language conversation. Use this agent when you want to create a new agent, modify an existing agent, or manage your agent collection (list, view, update, delete).",
+  type: AgentType3.DEEP_AGENT,
+  prompt: AGENT_ARCHITECT_PROMPT,
+  tools: [
+    "list_agents",
+    "list_tools",
+    "get_agent",
+    "create_agent",
+    "create_processing_agent",
+    "update_processing_agent",
+    "update_agent",
+    "delete_agent",
+    "invoke_agent"
+  ],
+  middleware: [
+    {
+      id: "widget",
+      type: "widget",
+      name: "Widget",
+      description: "Render interactive HTML widgets and SVG diagrams",
+      enabled: true,
+      config: {}
     }
-    const subSkills = [];
-    for (const subSkillName of parentSkill.subSkills) {
-      const subSkill = await this.getSkillById(tenantId, subSkillName, context);
-      if (subSkill) {
-        subSkills.push(subSkill);
-      }
+  ]
+};
+
+// src/agent_lattice/builtinAgents.ts
+var BUILTIN_AGENTS = [agentArchitectConfig];
+function ensureBuiltinAgentsForTenant(tenantId) {
+  for (const config of BUILTIN_AGENTS) {
+    if (!agentLatticeManager.hasWithTenant(tenantId, config.key)) {
+      agentLatticeManager.registerLatticeWithTenant(tenantId, config);
     }
-    return subSkills;
   }
-};
+}
 
 // src/agent_lattice/AgentLatticeManager.ts
 function assistantToConfig(assistant) {
@@ -17296,6 +19137,7 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
    * @param tenantId 租户ID
    */
   async initializeStoredAssistantsForTenant(tenantId) {
+    ensureBuiltinAgentsForTenant(tenantId);
     try {
       const storeLattice = getStoreLattice("default", "assistant");
       const assistants = await storeLattice.store.getAllAssistants(tenantId);
@@ -18515,10 +20357,10 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     }
     const tools = await this.getAllTools();
     console.log(`[MCP] Registering ${tools.length} tools to Tool Lattice...`);
-    for (const tool50 of tools) {
-      const toolKey = prefix ? `${prefix}_${tool50.name}` : tool50.name;
-      tool50.name = toolKey;
-      toolLatticeManager.registerExistingTool(toolKey, tool50);
+    for (const tool51 of tools) {
+      const toolKey = prefix ? `${prefix}_${tool51.name}` : tool51.name;
+      tool51.name = toolKey;
+      toolLatticeManager.registerExistingTool(toolKey, tool51);
       console.log(`[MCP] Registered tool: ${toolKey}`);
     }
     console.log(`[MCP] Successfully registered ${tools.length} tools to Tool Lattice`);
@@ -18816,7 +20658,7 @@ function parseOptionalNumberEnv(name, fallback) {
 }
 function getDefaultMicrosandboxRemoteConfig() {
   return {
-    image: process.env.MICROSANDBOX_IMAGE ?? "daytona-cn-shanghai.cr.volces.com/daytona/sandbox:0.0.4",
+    image: process.env.MICROSANDBOX_IMAGE ?? "daytona-cn-shanghai.cr.volces.com/daytona/sandbox:0.0.5",
     //"daytonaio/sandbox:0.6.0",
     cpus: parseOptionalNumberEnv("MICROSANDBOX_CPUS", 1),
     memoryMib: parseOptionalNumberEnv("MICROSANDBOX_MEMORY", 512),
@@ -19765,6 +21607,7 @@ export {
   createListMetricsServersTool,
   createListTablesSqlTool,
   createModelSelectorMiddleware,
+  createProcessingAgent,
   createQueryCheckerSqlTool,
   createQueryMetricDefinitionTool,
   createQueryMetricsListTool,