@axiom-lattice/core 5.0.0 → 6.1.0

package/dist/index.mjs

@@ -50,6 +50,17 @@ var ModelLattice = class extends BaseChatModel {
     this.config = config;
     this.llm = this.initChatModel(config);
   }
+  /**
+   * 返回构造时使用的配置
+   *
+   * 供调用方（如 models 控制器）读取 apiKey 是否存在、以及展示元数据，
+   * 避免反射读取私有字段。
+   *
+   * @returns 构造时传入的 LLMConfig
+   */
+  getConfig() {
+    return this.config;
+  }
   /**
    * 返回模型类型
    */
@@ -189,6 +200,9 @@ var ModelLattice = class extends BaseChatModel {
         maxRetries: config.maxRetries || 2,
         streaming: config.streaming,
         reasoning: { effort: "none" },
+        // Responses API and Chat Completions are different paths with different
+        // request fields; an endpoint that supports only one rejects the other.
+        ...config.useResponsesApi ? { useResponsesApi: true } : {},
         apiKey: config.apiKey || process.env[config.apiKeyEnvName || "OPENAI_API_KEY"],
         configuration: {
           baseURL: config.baseURL
@@ -279,9 +293,74 @@ var ModelLatticeManager = class _ModelLatticeManager extends BaseLatticeManager
   getLatticeKeys() {
     return this.keys();
   }
+  // ========== 租户维度 API ==========
+  // 键由基类拼装为 models:{tenantId}:{key}。注意 "default" 租户的键与旧版
+  // key-only API 完全一致（models:default:{key}），因此对该租户是逐字节兼容的。
+  /**
+   * 以租户维度注册模型Lattice
+   *
+   * 同名 key 采用「后写覆盖」语义：先移除再注册，避免基类重复注册时抛错。
+   *
+   * @param tenantId 租户ID
+   * @param key Lattice键名
+   * @param config 模型配置
+   */
+  registerLatticeWithTenant(tenantId2, key5, config) {
+    const client = new ModelLattice(config);
+    const modelLattice = {
+      key: key5,
+      client
+    };
+    if (this.hasWithTenant(tenantId2, key5)) {
+      this.removeWithTenant(tenantId2, key5);
+    }
+    this.registerWithTenant(tenantId2, key5, modelLattice);
+  }
+  /**
+   * 获取指定租户的模型Lattice
+   * @param tenantId 租户ID
+   * @param key Lattice键名
+   */
+  getModelLatticeWithTenant(tenantId2, key5) {
+    return this.getWithTenant(tenantId2, key5);
+  }
+  /**
+   * 检查指定租户的模型Lattice是否存在
+   * @param tenantId 租户ID
+   * @param key Lattice键名
+   */
+  hasLatticeWithTenant(tenantId2, key5) {
+    return this.hasWithTenant(tenantId2, key5);
+  }
+  /**
+   * 获取指定租户的所有模型Lattice
+   * @param tenantId 租户ID
+   */
+  getAllLatticesByTenant(tenantId2) {
+    return this.getAllByTenant(tenantId2);
+  }
+  /**
+   * 获取指定租户的所有模型键名
+   *
+   * 只返回键名，不构造 Lattice 对象数组，适合仅需判断存在性的调用方。
+   *
+   * @param tenantId 租户ID
+   */
+  getLatticeKeysByTenant(tenantId2) {
+    return this.keysByTenant(tenantId2);
+  }
+  /**
+   * 移除指定租户的模型Lattice
+   * @param tenantId 租户ID
+   * @param key Lattice键名
+   */
+  removeLatticeWithTenant(tenantId2, key5) {
+    return this.removeWithTenant(tenantId2, key5);
+  }
 };
 var modelLatticeManager = ModelLatticeManager.getInstance();
 var registerModelLattice = (key5, config) => modelLatticeManager.registerLattice(key5, config);
+var registerModelLatticeForTenant = (tenantId2, key5, config) => modelLatticeManager.registerLatticeWithTenant(tenantId2, key5, config);
 var getModelLattice = (key5) => modelLatticeManager.getModelLattice(key5);
 
 // src/tool_lattice/get_current_date_time/index.ts
@@ -2013,6 +2092,240 @@ var InMemoryMcpServerConfigStore = class {
   }
 };
 
+// src/store_lattice/InMemoryModelProviderStore.ts
+var InMemoryModelProviderStore = class {
+  constructor() {
+    this.providers = /* @__PURE__ */ new Map();
+    this.models = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get composite key for providers
+   */
+  getProviderKey(tenantId2, id) {
+    return `${tenantId2}:${id}`;
+  }
+  /**
+   * Get composite key for snapshot models
+   */
+  getModelKey(tenantId2, providerId, modelId) {
+    return `${tenantId2}:${providerId}:${modelId}`;
+  }
+  /**
+   * Get all provider configurations for a tenant
+   */
+  async listProviders(tenantId2) {
+    return Array.from(this.providers.values()).filter(
+      (provider) => provider.tenantId === tenantId2
+    );
+  }
+  /**
+   * Get a provider configuration by ID
+   */
+  async getProviderById(tenantId2, id) {
+    return this.providers.get(this.getProviderKey(tenantId2, id)) || null;
+  }
+  /**
+   * Get a provider configuration by business name
+   */
+  async getProviderByName(tenantId2, name) {
+    const providers = await this.listProviders(tenantId2);
+    return providers.find((provider) => provider.name === name) || null;
+  }
+  /**
+   * Create a new provider configuration
+   */
+  async createProvider(tenantId2, id, data) {
+    const now = /* @__PURE__ */ new Date();
+    const entry = {
+      id,
+      tenantId: tenantId2,
+      name: data.name,
+      displayName: data.displayName,
+      protocol: data.protocol,
+      apiStyle: data.apiStyle ?? "chat-completions",
+      // Phase 1 pins the LLM provider: the UI does not offer a choice, and some
+      // initChatModel branches hardcode their own baseURL and would silently
+      // ignore the tenant's (see ADR-138 decision 7b).
+      llmProvider: "openai",
+      baseURL: data.baseURL,
+      apiKey: data.apiKey || void 0,
+      apiKeyHint: data.apiKey ? data.apiKey.slice(-4) : void 0,
+      enabled: data.enabled ?? true,
+      status: "unknown",
+      createdAt: now,
+      updatedAt: now
+    };
+    this.providers.set(this.getProviderKey(tenantId2, id), entry);
+    return entry;
+  }
+  /**
+   * Update an existing provider configuration.
+   * An omitted or empty `apiKey` leaves the stored key untouched.
+   */
+  async updateProvider(tenantId2, id, updates) {
+    const key5 = this.getProviderKey(tenantId2, id);
+    const existing = this.providers.get(key5);
+    if (!existing) {
+      return null;
+    }
+    const hasNewApiKey = Boolean(updates.apiKey);
+    const clearsApiKey = updates.clearApiKey === true;
+    const updated = {
+      ...existing,
+      name: updates.name ?? existing.name,
+      displayName: updates.displayName !== void 0 ? updates.displayName : existing.displayName,
+      protocol: updates.protocol ?? existing.protocol,
+      apiStyle: updates.apiStyle ?? existing.apiStyle,
+      baseURL: updates.baseURL ?? existing.baseURL,
+      apiKey: clearsApiKey ? void 0 : hasNewApiKey ? updates.apiKey : existing.apiKey,
+      apiKeyHint: clearsApiKey ? void 0 : hasNewApiKey ? updates.apiKey?.slice(-4) : existing.apiKeyHint,
+      enabled: updates.enabled ?? existing.enabled,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.providers.set(key5, updated);
+    return updated;
+  }
+  /**
+   * Delete a provider configuration and its model snapshot
+   */
+  async deleteProvider(tenantId2, id) {
+    await this.deleteModelsByProvider(tenantId2, id);
+    return this.providers.delete(this.getProviderKey(tenantId2, id));
+  }
+  /**
+   * Record the outcome of a discovery attempt
+   */
+  async markProviderStatus(tenantId2, id, status, lastError, discoveredAt) {
+    const key5 = this.getProviderKey(tenantId2, id);
+    const existing = this.providers.get(key5);
+    if (!existing) {
+      return;
+    }
+    this.providers.set(key5, {
+      ...existing,
+      status,
+      lastError: status === "ok" ? void 0 : lastError,
+      lastDiscoveredAt: discoveredAt ?? existing.lastDiscoveredAt,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * List snapshot models for a tenant
+   */
+  async listModels(tenantId2, providerId) {
+    return Array.from(this.models.values()).filter(
+      (model) => model.tenantId === tenantId2 && (providerId === void 0 || model.providerId === providerId)
+    );
+  }
+  /**
+   * Get a single snapshot model.
+   * Keyed by provider as well as model id, since two providers in the same
+   * tenant may expose the same upstream model id.
+   */
+  async getModel(tenantId2, providerId, modelId) {
+    return this.models.get(this.getModelKey(tenantId2, providerId, modelId)) || null;
+  }
+  /**
+   * Replace a provider's model snapshot with the result of one discovery.
+   *
+   * Model ids are scoped per provider, so the same upstream id may appear
+   * under several providers in one tenant — each is an independent model.
+   *
+   * Models the upstream no longer offers are removed; models that survive keep
+   * the tenant's enable/disable choice rather than being reset.
+   */
+  async replaceProviderModels(tenantId2, providerId, models) {
+    const previous = await this.listModels(tenantId2, providerId);
+    const previousById = new Map(
+      previous.map((model) => [model.modelId, model])
+    );
+    const incomingIds = new Set(models.map((model) => model.id));
+    for (const model of previous) {
+      if (!incomingIds.has(model.modelId)) {
+        this.models.delete(
+          this.getModelKey(tenantId2, providerId, model.modelId)
+        );
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    const upserted = [];
+    for (const model of models) {
+      const existing = previousById.get(model.id);
+      const entry = {
+        id: `${providerId}:${model.id}`,
+        tenantId: tenantId2,
+        providerId,
+        modelId: model.id,
+        displayName: model.displayName,
+        ownedBy: model.ownedBy,
+        upstreamCreatedAt: model.createdAt ? new Date(model.createdAt) : void 0,
+        // An explicit `enabled` from the caller wins; discovery omits it and
+        // the tenant's earlier choice is preserved.
+        enabled: model.enabled ?? existing?.enabled ?? true,
+        // Unlike `enabled`, this is not preserved: a model present in the list
+        // the caller just read is, by definition, no longer stale. Only an
+        // explicit flag marks one.
+        stale: model.stale ?? false,
+        discoveredAt: now
+      };
+      this.models.set(this.getModelKey(tenantId2, providerId, model.id), entry);
+      upserted.push(model.id);
+    }
+    return upserted;
+  }
+  /**
+   * Enable or disable a single snapshot model
+   */
+  async setModelEnabled(tenantId2, providerId, modelId, enabled) {
+    const key5 = this.getModelKey(tenantId2, providerId, modelId);
+    const existing = this.models.get(key5);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      enabled
+    };
+    this.models.set(key5, updated);
+    return updated;
+  }
+  /**
+   * Delete every snapshot model belonging to a provider
+   */
+  async deleteModelsByProvider(tenantId2, providerId) {
+    let deleted = 0;
+    for (const [key5, model] of Array.from(this.models.entries())) {
+      if (model.tenantId === tenantId2 && model.providerId === providerId) {
+        this.models.delete(key5);
+        deleted += 1;
+      }
+    }
+    return deleted;
+  }
+  /**
+   * Clear all providers and models (useful for testing)
+   */
+  clear() {
+    this.providers.clear();
+    this.models.clear();
+  }
+  /**
+   * Clear providers and models for a specific tenant
+   */
+  clearByTenant(tenantId2) {
+    for (const [key5, provider] of Array.from(this.providers.entries())) {
+      if (provider.tenantId === tenantId2) {
+        this.providers.delete(key5);
+      }
+    }
+    for (const [key5, model] of Array.from(this.models.entries())) {
+      if (model.tenantId === tenantId2) {
+        this.models.delete(key5);
+      }
+    }
+  }
+};
+
 // src/store_lattice/InMemoryAgentWebAppStore.ts
 import { randomUUID } from "crypto";
 function cloneAppearance(appearance) {
@@ -4501,6 +4814,7 @@ var defaultProjectStore = new InMemoryProjectStore(defaultCapabilityBundleCoordi
 var defaultDatabaseConfigStore = new InMemoryDatabaseConfigStore();
 var defaultMetricsServerConfigStore = new InMemoryMetricsServerConfigStore();
 var defaultMcpServerConfigStore = new InMemoryMcpServerConfigStore();
+var defaultModelProviderStore = new InMemoryModelProviderStore();
 var defaultAgentWebAppStore = new InMemoryAgentWebAppStore();
 var defaultCapabilityBundleStore = new InMemoryCapabilityBundleStore(defaultProjectStore, defaultCapabilityBundleCoordinator);
 var defaultProjectRoomCoordinator = new InMemoryProjectRoomCoordinator();
@@ -4522,6 +4836,7 @@ storeLatticeManager.registerLattice("default", "project", defaultProjectStore);
 storeLatticeManager.registerLattice("default", "database", defaultDatabaseConfigStore);
 storeLatticeManager.registerLattice("default", "metrics", defaultMetricsServerConfigStore);
 storeLatticeManager.registerLattice("default", "mcp", defaultMcpServerConfigStore);
+storeLatticeManager.registerLattice("default", "modelProvider", defaultModelProviderStore);
 storeLatticeManager.registerLattice("default", "agentWebApp", defaultAgentWebAppStore);
 storeLatticeManager.registerLattice("default", "capabilityBundle", defaultCapabilityBundleStore);
 storeLatticeManager.registerLattice("default", "projectRoom", defaultProjectRoomStore);
@@ -28847,7 +29162,7 @@ var agentArchitectConfig = {
     "delete_agent",
     "manage_binding"
   ],
-  subAgents: ["document-parser-benchmark"],
+  subAgents: ["document-parser", "document-parser-benchmark"],
   middleware: [
     {
       id: "filesystem",
@@ -30552,6 +30867,7 @@ async function removeCollectionVectorStore(name, tenantId2) {
 
 // src/mcp_lattice/McpLatticeManager.ts
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
+import { DynamicStructuredTool as DynamicStructuredTool2 } from "@langchain/core/tools";
 
 // src/mcp_lattice/reconnectPolicy.ts
 var DEFAULT_CONNECT_TIMEOUT_MS = 15e3;
@@ -30560,6 +30876,13 @@ var DEFAULT_DELAY_MS = 1e3;
 var MAX_BACKOFF_MS = 3e4;
 var HEALTH_CHECK_INTERVAL_MS = 3e4;
 var HEALTH_CHECK_TIMEOUT_MS = 5e3;
+function isMcpConnectionError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (!message) return false;
+  return /not connected|connection closed|session not found|no session|maximum reconnection/i.test(
+    message
+  );
+}
 function nextBackoffDelay(attempt, base = DEFAULT_DELAY_MS, max = MAX_BACKOFF_MS) {
   if (attempt <= 0) return base;
   return Math.min(base * Math.pow(2, attempt - 1), max);
@@ -30584,12 +30907,21 @@ async function withTimeout(operation, ms, onTimeout) {
 
 // src/mcp_lattice/McpLatticeManager.ts
 var realClientFactory = ({ mcpServers }) => new MultiServerMCPClient({ mcpServers });
+function extractRawCall(tool68) {
+  const rawCall = tool68._call;
+  if (typeof rawCall === "function") return rawCall.bind(tool68);
+  return async (...args) => {
+    const invoke = tool68.invoke.bind(tool68);
+    return invoke(args[0], args[2]);
+  };
+}
 var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
   constructor() {
     super(...arguments);
     this.runtimes = /* @__PURE__ */ new Map();
     this.clientFactory = realClientFactory;
     this.healthCheckInFlight = false;
+    this.reconnectPromises = /* @__PURE__ */ new Map();
   }
   static getInstance() {
     if (!_McpLatticeManager._instance) {
@@ -30847,6 +31179,64 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     rt.attempt = 0;
     await this.reconnectRuntime(rt);
   }
+  /**
+   * Single-flight a forced reconnect per `(tenantId, serverKey)` so concurrent
+   * tool calls that all hit the same dead session reconnect once, not once each.
+   */
+  reconnectShared(rt) {
+    const key5 = this.compositeKey(rt.id.tenantId, rt.id.serverKey);
+    const existing = this.reconnectPromises.get(key5);
+    if (existing) return existing;
+    const work = this.reconnectServer(rt.id.tenantId, rt.id.serverKey).finally(() => {
+      if (this.reconnectPromises.get(key5) === work) this.reconnectPromises.delete(key5);
+    });
+    this.reconnectPromises.set(key5, work);
+    return work;
+  }
+  /**
+   * Wrap a raw MCP tool so a call landing on a torn-down session
+   * (`Not connected` / `Connection closed` / session expiry) transparently
+   * forces a reconnect and retries once against the fresh client, instead of
+   * failing the surrounding run. Non-connection errors propagate untouched.
+   */
+  wrapToolForResilience(rt, raw) {
+    const call = extractRawCall(raw);
+    return new DynamicStructuredTool2({
+      name: raw.name,
+      description: raw.description,
+      schema: raw.schema,
+      responseFormat: raw.responseFormat,
+      defaultConfig: raw.defaultConfig,
+      metadata: raw.metadata,
+      returnDirect: raw.returnDirect,
+      func: async (...args) => this.invokeResilient(rt, raw.name, call, args)
+    });
+  }
+  async invokeResilient(rt, toolName2, call, args) {
+    try {
+      await this.ensureConnected(rt.id.tenantId, rt.id.serverKey);
+      return await call(...args);
+    } catch (error) {
+      if (!isMcpConnectionError(error) || !this.isActive(rt)) throw error;
+      console.warn(
+        `[MCP] ${rt.id.tenantId}/${rt.id.serverKey}: tool "${toolName2}" hit a dead session; reconnecting and retrying once`,
+        error instanceof Error ? error.message : error
+      );
+      try {
+        await this.reconnectShared(rt);
+      } catch (reconnectError) {
+        console.warn(
+          `[MCP] ${rt.id.tenantId}/${rt.id.serverKey}: reconnect for tool "${toolName2}" failed`,
+          reconnectError instanceof Error ? reconnectError.message : reconnectError
+        );
+        throw error;
+      }
+      const fresh = await this.getRawTools(rt.id.tenantId, rt.id.serverKey);
+      const match = fresh.find((t) => t.name === toolName2);
+      if (!match) throw error;
+      return await extractRawCall(match)(...args);
+    }
+  }
   async checkHealth() {
     if (this.healthCheckInFlight) return;
     this.healthCheckInFlight = true;
@@ -30865,8 +31255,12 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
           await withTimeout(session.listTools(), HEALTH_CHECK_TIMEOUT_MS, async () => {
           });
           if (!this.isActive(rt) || rt.state !== "connected") continue;
-        } catch {
+        } catch (error) {
           if (this.isActive(rt) && rt.state === "connected") {
+            console.warn(
+              `[MCP] ${rt.id.tenantId}/${rt.id.serverKey}: health check failed; scheduling reconnect`,
+              error instanceof Error ? error.message : error
+            );
             rt.state = "failed";
             this.scheduleReconnect(rt);
           }
@@ -31072,7 +31466,8 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
       const visibility = Array.isArray(rawVisibility) ? rawVisibility : typeof rawVisibility === "string" ? [rawVisibility] : void 0;
       if (visibility && !visibility.includes("model")) continue;
       const ref = extractAppsRef(meta, serverKey);
-      const registered = ref ? wrapMcpToolWithUi(tool68, ref) : tool68;
+      const resilient = this.wrapToolForResilience(rt, tool68);
+      const registered = ref ? wrapMcpToolWithUi(resilient, ref) : resilient;
       const toolKey = _McpLatticeManager.buildToolKey(serverKey, tool68.name);
       try {
         toolLatticeManager.registerExistingToolWithTenant(tenantId2, toolKey, registered);
@@ -31141,6 +31536,7 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
       }
     }
     this.runtimes.clear();
+    this.reconnectPromises.clear();
   }
 };
 var mcpManager = McpLatticeManager.getInstance();
@@ -34291,13 +34687,16 @@ var LatticeEvalProject = class {
   constructor(project, onCaseComplete) {
     this.suites = /* @__PURE__ */ new Map();
     this.project = project;
-    const judgeModelKey = resolveJudgeModelKey(this.project.judge_agent_config.modelKey, modelLatticeManager);
+    const tenantId2 = this.project.lattice_server_config.tenant_id || "default";
+    const judgeModelKey = resolveJudgeModelKey(
+      this.project.judge_agent_config.modelKey,
+      modelLatticeManager
+    );
     if (!modelLatticeManager.hasLattice(judgeModelKey)) {
       throw new Error(
         `Judge model "${judgeModelKey}" not found. Register it first or provide a valid modelKey.`
       );
     }
-    const tenantId2 = this.project.lattice_server_config.tenant_id || "default";
     this.judgeAgentKey = `${this.project.projectName}_judge_agent`;
     const judgeAgentConfig = {
       key: this.judgeAgentKey,
@@ -35240,7 +35639,7 @@ function snapshotDate(value) {
 
 // src/services/TaskLifecycleService.ts
 import { createHash as createHash6 } from "crypto";
-import { parseTaskBeliefState, replaceTaskBeliefState, snapshotExactArray as snapshotExactArray2, snapshotExactRecord as snapshotExactRecord7, taskBeliefStatesEqual } from "@axiom-lattice/protocols";
+import { parseTaskBeliefState, replaceTaskBeliefState, taskBeliefStatesEqual } from "@axiom-lattice/protocols";
 
 // src/middlewares/taskBelief.ts
 import { createHash as createHash5 } from "crypto";
@@ -35352,14 +35751,6 @@ async function applyBeliefImpacts(taskStore, owner, impacts) {
   }
   return { description: current.description ?? "", task: current };
 }
-function parseExternalDependency(value) {
-  const row = snapshotExactRecord7(value, ["type", "summary", "requestedAt", "dependencyTaskIds"]);
-  const ids = snapshotExactArray2(row?.dependencyTaskIds);
-  if (!row || row.type !== "external_dependency" || typeof row.summary !== "string" || !row.summary.trim() || typeof row.requestedAt !== "string" || !Number.isFinite(Date.parse(row.requestedAt)) || !ids || ids.length === 0 || ids.some((id) => typeof id !== "string" || !id.trim())) return void 0;
-  const trimmed = ids.map((id) => id.trim());
-  if (new Set(trimmed).size !== trimmed.length) return void 0;
-  return { type: "external_dependency", summary: row.summary, requestedAt: row.requestedAt, dependencyTaskIds: trimmed };
-}
 function unsupportedTaskStatus() {
   return failure2(
     "TASK_STATUS_UNSUPPORTED",
@@ -35658,9 +36049,6 @@ var TaskLifecycleService = class {
       if (interruption && typeof interruption === "object" && interruption.type === "review_required") {
         return failure2("REVIEW_APPROVAL_REQUIRED", "Review interruption requires explicit approval or rejection.");
       }
-      if (interruption && typeof interruption === "object" && interruption.type === "external_dependency" && !parseExternalDependency(interruption)) {
-        return failure2("INVALID_EXTERNAL_DEPENDENCY", "Stored external dependency interruption is malformed.");
-      }
       const previousInterruption = interruption && typeof interruption === "object" ? interruption : {};
       const resumeKey = this.resumeEventKey(task);
       const audit = { eventKey: resumeKey, previousInterruption };
@@ -35841,6 +36229,108 @@ var TaskLifecycleService = class {
       detail: { previousStatus: "failed" }
     });
   }
+  /**
+   * Reopens a terminal agent task by returning it to in_progress.
+   *
+   * @param input Task, actor, and optional thread.
+   * @returns Structured lifecycle result. `completed` and `cancelled` tasks
+   *   reopen to `in_progress`; an already-`in_progress` task is acknowledged
+   *   without mutation; any other status or a lost CAS yields
+   *   `TASK_STATUS_CONFLICT`.
+   * @remarks This is the single reverse edge of the terminal-irreversibility
+   *   relaxation. It records the status change only; re-dispatch is owned by
+   *   the application layer and is never triggered here.
+   */
+  async reopenTask(input) {
+    return this.transitionAgentTask({
+      ...input,
+      targetStatus: "in_progress",
+      expectedStatuses: ["completed", "cancelled"],
+      updates: { status: "in_progress", failureReason: null, result: null },
+      summary: "Task reopened",
+      detail: { type: "reopen" }
+    });
+  }
+  /**
+   * Transfers a human-authored task's ownership to a chosen Agent before dispatch.
+   *
+   * @param input Task, actor, destination Agent, and optional Task Thread.
+   * @returns Structured result with the reassigned owner and an `owner_assigned` audit.
+   * @remarks Only tasks with `context.source === "user"` can be assigned this way.
+   *   Repeated assignment to the same owner is idempotent (repair-writes the audit
+   *   without a CAS). This changes owner only, never status, so it publishes no
+   *   Project lifecycle notification.
+   */
+  async assignOwner(input) {
+    let task;
+    try {
+      task = await this.deps.taskStore.getById(input.tenantId, input.taskId);
+    } catch {
+      return failure2("TASK_STORE_READ_FAILED", "Failed to read task lifecycle state.");
+    }
+    if (!task) return failure2("TASK_NOT_FOUND", "Task was not found.");
+    if (task.context?.source !== "user") {
+      return failure2("TASK_NOT_HUMAN_MANAGED", "Only user-authored tasks can be assigned to an Agent.");
+    }
+    const storedThreadId = typeof task.context?.thread_id === "string" && task.context.thread_id.length > 0 ? task.context.thread_id : void 0;
+    const effectiveThreadId = storedThreadId ?? input.threadId;
+    const detail = { type: "owner_assigned", fromOwnerType: task.ownerType, toOwnerId: input.ownerId };
+    if (task.ownerType === "agent" && task.ownerId === input.ownerId && (input.threadId === void 0 || storedThreadId === input.threadId)) {
+      const eventKey2 = this.statusEventKey(task, "owner_assigned", detail);
+      const event2 = await this.writeStatusEvent(
+        task,
+        input.actor,
+        effectiveThreadId,
+        "activity",
+        "Task owner assigned",
+        detail,
+        eventKey2
+      );
+      return {
+        success: true,
+        task,
+        mutated: false,
+        eventKey: event2.eventKey,
+        ...event2.warning ? { warnings: [event2.warning] } : {}
+      };
+    }
+    const context = { ...task.context ?? {} };
+    if (input.threadId && !storedThreadId) context.thread_id = input.threadId;
+    let updated;
+    try {
+      updated = await this.deps.taskStore.updateIfStatusAndUpdatedAt(
+        input.tenantId,
+        input.taskId,
+        { ownerType: "agent", ownerId: input.ownerId, context },
+        [task.status],
+        task.updatedAt
+      );
+    } catch {
+      return failure2(
+        "TASK_STORE_WRITE_FAILED",
+        "Failed to assign the task owner.",
+        "The store rejected the write."
+      );
+    }
+    if (!updated) return failure2("TASK_STATUS_CONFLICT", "Task changed concurrently.");
+    const eventKey = this.statusEventKey(updated, "owner_assigned", detail);
+    const event = await this.writeStatusEvent(
+      updated,
+      input.actor,
+      effectiveThreadId,
+      "activity",
+      "Task owner assigned",
+      detail,
+      eventKey
+    );
+    return {
+      success: true,
+      task: updated,
+      mutated: true,
+      eventKey: event.eventKey,
+      ...event.warning ? { warnings: [event.warning] } : {}
+    };
+  }
   /** Atomically cancels a nonterminal agent task and records an idempotent status event. */
   async cancelTask(input) {
     return this.transitionAgentTask({
@@ -35921,19 +36411,7 @@ var TaskLifecycleService = class {
   async interruptTask(input) {
     const summary = input.summary.trim();
     if (!summary) return failure2("MISSING_INTERRUPTION_SUMMARY", "Agent interruption requires a nonblank summary.");
-    if (input.type !== "external_dependency" && input.dependencyTaskIds !== void 0) {
-      return failure2("INVALID_EXTERNAL_DEPENDENCY", "dependencyTaskIds are only valid for external dependencies.");
-    }
     const requestedAt = this.now().toISOString();
-    const external = input.type === "external_dependency" ? parseExternalDependency({
-      type: input.type,
-      summary,
-      requestedAt,
-      dependencyTaskIds: input.dependencyTaskIds
-    }) : void 0;
-    if (input.type === "external_dependency" && !external) {
-      return failure2("INVALID_EXTERNAL_DEPENDENCY", "External dependencies require exact, unique nonblank task IDs.");
-    }
     let task;
     try {
       task = await this.deps.taskStore.getById(input.tenantId, input.taskId);
@@ -35947,29 +36425,17 @@ var TaskLifecycleService = class {
     if (threadFailure) return threadFailure;
     const currentInterruption = task.context?.interruption;
     if (task.status === "interrupted" && currentInterruption && typeof currentInterruption === "object") {
-      const storedExternal = parseExternalDependency(currentInterruption);
-      if (input.type === "external_dependency") {
-        if (!external || !storedExternal || storedExternal.summary !== external.summary || canonicalJson(storedExternal.dependencyTaskIds) !== canonicalJson(external.dependencyTaskIds)) {
-          return failure2(
-            "TASK_STATUS_CONFLICT",
-            "Task is already interrupted by a different or malformed external dependency.",
-            "Use manage_task get to inspect the existing interruption in task context.interruption."
-          );
-        }
-      } else if (currentInterruption.type !== input.type || currentInterruption.summary !== summary) {
+      if (currentInterruption.type !== input.type || currentInterruption.summary !== summary) {
         return failure2(
           "TASK_STATUS_CONFLICT",
           "Task is already interrupted by a different request.",
           "Use manage_task get to inspect the existing interruption, or resume it first."
         );
       }
-      const detail = storedExternal ? { ...storedExternal } : currentInterruption;
+      const detail = currentInterruption;
       const eventKey2 = this.statusEventKey(task, "interrupted", detail);
       const event2 = await this.writeStatusEvent(task, input.actor, input.threadId, "interrupted", summary, detail, eventKey2);
       const warnings2 = event2.warning ? [event2.warning] : [];
-      if (storedExternal && task.workspaceId && task.projectId) {
-        return this.finishExternalDependencyInterruption(task, input, storedExternal, event2, warnings2, false);
-      }
       return {
         success: true,
         task,
@@ -35985,11 +36451,7 @@ var TaskLifecycleService = class {
         "Only pending or in_progress tasks can be interrupted. Use manage_task get to check the current status."
       );
     }
-    if (external && task.workspaceId && task.projectId) {
-      const dependencyFailure = await this.validateExternalDependencies(task, external.dependencyTaskIds);
-      if (dependencyFailure) return dependencyFailure;
-    }
-    const interruption = external ? { ...external } : { type: input.type, summary, requestedAt };
+    const interruption = { type: input.type, summary, requestedAt };
     let updated;
     try {
       updated = await this.deps.taskStore.updateIfStatusAndUpdatedAt(input.tenantId, input.taskId, {
@@ -36011,9 +36473,6 @@ var TaskLifecycleService = class {
     const eventKey = this.statusEventKey(updated, "interrupted", interruption);
     const event = await this.writeStatusEvent(updated, input.actor, input.threadId, "interrupted", summary, interruption, eventKey);
     const warnings = event.warning ? [event.warning] : await this.notifyWinningTransition(updated, "interrupted", event);
-    if (external && updated.workspaceId && updated.projectId) {
-      return this.finishExternalDependencyInterruption(updated, input, external, event, warnings, true);
-    }
     return {
       success: true,
       task: updated,
@@ -37252,7 +37711,9 @@ var TaskLifecycleService = class {
       };
     }
     if (!input.expectedStatuses.includes(task.status)) return failure2("TASK_STATUS_CONFLICT", "Task status cannot make this transition.");
-    const updates = { ...input.updates, context: clearInterruptionContext(task.context) };
+    const clearedContext = clearInterruptionContext(task.context);
+    const withThread = input.threadId && task.context?.thread_id === void 0 ? { ...clearedContext ?? {}, thread_id: input.threadId } : clearedContext;
+    const updates = { ...input.updates, context: withThread };
     let updated;
     try {
       updated = await this.deps.taskStore.updateIfStatusAndUpdatedAt(
@@ -37340,85 +37801,6 @@ var TaskLifecycleService = class {
       return [{ code: "LIFECYCLE_NOTIFICATION_FAILED", taskId: task.id, eventKey: event.eventKey }];
     }
   }
-  async validateExternalDependencies(task, dependencyTaskIds) {
-    const declared = new Set(task.dependencies ?? []);
-    if (dependencyTaskIds.some((id) => id === task.id || !declared.has(id))) {
-      return failure2("INVALID_EXTERNAL_DEPENDENCY", "External dependency IDs must be declared non-self dependencies.");
-    }
-    try {
-      for (const id of dependencyTaskIds) {
-        const dependency = await this.deps.taskStore.getById(task.tenantId, id);
-        if (!dependency || dependency.workspaceId !== task.workspaceId || dependency.projectId !== task.projectId || dependency.status === "completed") {
-          return failure2("INVALID_EXTERNAL_DEPENDENCY", "External dependencies must exist, remain incomplete, and share exact scope.");
-        }
-      }
-    } catch {
-      return failure2("TASK_STORE_READ_FAILED", "Failed to validate external dependencies.");
-    }
-    return void 0;
-  }
-  async externalDependencyReadiness(task, dependencyTaskIds) {
-    try {
-      for (const id of dependencyTaskIds) {
-        const dependency = await this.deps.taskStore.getById(task.tenantId, id);
-        if (!dependency || dependency.workspaceId !== task.workspaceId || dependency.projectId !== task.projectId || dependency.status !== "completed") return { kind: "blocked" };
-      }
-      return { kind: "ready" };
-    } catch {
-      return {
-        kind: "error",
-        warning: { code: "DEPENDENCY_READ_FAILED", taskId: task.id }
-      };
-    }
-  }
-  async finishExternalDependencyInterruption(task, input, interruption, event, warnings, mutated) {
-    if (event.warning) {
-      return { success: true, task, mutated, eventKey: event.eventKey, warnings };
-    }
-    const readiness = await this.externalDependencyReadiness(task, interruption.dependencyTaskIds);
-    if (readiness.kind === "blocked") {
-      return { success: true, task, mutated, eventKey: event.eventKey, ...warnings.length ? { warnings } : {} };
-    }
-    if (readiness.kind === "error") {
-      return {
-        success: true,
-        task,
-        mutated,
-        eventKey: event.eventKey,
-        warnings: [...warnings, { ...readiness.warning, eventKey: event.eventKey }]
-      };
-    }
-    const resumed = await this.resumeInterruption({
-      tenantId: input.tenantId,
-      taskId: input.taskId,
-      actor: input.actor,
-      threadId: input.threadId
-    });
-    if (resumed.success) {
-      const combined = [...warnings, ...resumed.warnings ?? []];
-      return {
-        ...resumed,
-        mutated: mutated || resumed.mutated,
-        ...combined.length ? { warnings: combined } : {}
-      };
-    }
-    let current;
-    try {
-      current = await this.deps.taskStore.getById(input.tenantId, input.taskId);
-    } catch {
-      return resumed;
-    }
-    if (current?.status === "in_progress" && (!current.context?.thread_id || current.context?.thread_id === input.threadId)) {
-      return {
-        success: true,
-        task: current,
-        mutated,
-        eventKey: event.eventKey,
-        ...warnings.length ? { warnings } : {}
-      };
-    }
-    return resumed;
-  }
   async clearAuditMarker(task, key5) {
     const context = withoutContextKey(task.context, key5);
     try {
@@ -38664,6 +39046,47 @@ function clearEncryptionKeyCache() {
   keyValidated = false;
 }
 
+// src/util/safeUpstreamUrl.ts
+var UnsafeUpstreamUrlError = class extends Error {
+  constructor(reason, message, statusCode = 400) {
+    super(message);
+    this.reason = reason;
+    this.statusCode = statusCode;
+    this.name = "UnsafeUpstreamUrlError";
+  }
+};
+async function assertSafeUpstreamUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new UnsafeUpstreamUrlError(
+      "INVALID_BASE_URL",
+      "Base URL is not a valid URL"
+    );
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new UnsafeUpstreamUrlError(
+      "UNSUPPORTED_SCHEME",
+      "Base URL must use http or https"
+    );
+  }
+  if (url.username.length > 0 || url.password.length > 0) {
+    throw new UnsafeUpstreamUrlError(
+      "CREDENTIALS_IN_URL",
+      "Base URL must not embed credentials; configure the API key separately"
+    );
+  }
+  const hostname = url.hostname.replace(/^\[/, "").replace(/\]$/, "");
+  if (hostname.length === 0) {
+    throw new UnsafeUpstreamUrlError(
+      "INVALID_BASE_URL",
+      "Base URL must include a host"
+    );
+  }
+  return { url };
+}
+
 // src/middlewares/skillMiddleware.ts
 import { createMiddleware as createMiddleware19 } from "langchain";
 
@@ -41316,6 +41739,9 @@ function trustedRosterScope(trusted) {
     callerAssistantId: context.assistantId
   };
 }
+function trustedRosterExempt(trusted) {
+  return trusted.projectTask?.rosterExempt === true;
+}
 async function requireTrustedOwner(trusted, targetAssistantId) {
   const context = trusted.projectTask ?? trusted.projectRoom;
   const memberships = getStoreLattice("default", "projectBotMembership").store;
@@ -41580,6 +42006,7 @@ async function validateTrustedChildDependencyWait(store, tenantId2, parent, depe
     if (dependency.status === "completed") continue;
     if (!["pending", "in_progress", "interrupted"].includes(dependency.status) || dependency.parentId !== parent.id || dependency.ownerType !== "agent" || !hasExactContextSource(dependency, expectedSource)) return void 0;
     incompleteChildren += 1;
+    if (trustedRosterExempt(trusted)) continue;
     try {
       await requireTrustedOwner(trusted, dependency.ownerId);
     } catch (error) {
@@ -41654,7 +42081,6 @@ var manageTaskSchema = z70.object({
   ownerId: z70.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
   requireReview: z70.boolean().optional().describe("If true, agent completion pauses as interrupted(review_required) for HITL approval"),
   dependencies: z70.array(z70.string()).optional().describe("List of task IDs that must be completed before this task can start"),
-  dependencyTaskIds: z70.array(z70.string().trim().min(1)).optional().describe("Exact blocking task IDs required for an external_dependency interruption"),
   result: z70.string().optional().describe("Result summary. Used with set_status status='completed' or update status='completed'"),
   failureReason: z70.string().optional().describe("Failure reason. Used with set_status status='failed' or update status='failed'"),
   files: z70.array(z70.object({
@@ -41823,7 +42249,7 @@ function createTaskMiddleware(options = {}) {
     const workspaceId = trustedScope?.workspaceId ?? rc.workspaceId;
     const projectId = trustedScope?.projectId ?? rc.projectId;
     const revalidateCaller = async () => {
-      if (!trustedProject) return void 0;
+      if (!trustedProject || trustedRosterExempt(trustedProject)) return void 0;
       try {
         await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
       } catch (error) {
@@ -41831,7 +42257,7 @@ function createTaskMiddleware(options = {}) {
       }
       return void 0;
     };
-    if (trustedProject) {
+    if (trustedProject && !trustedRosterExempt(trustedProject)) {
       try {
         await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
       } catch (error) {
@@ -41864,10 +42290,12 @@ function createTaskMiddleware(options = {}) {
       if (trustedProject) {
         const snapshot = taskMutationSnapshot(existing);
         if (!snapshot) return trustedContextError();
-        try {
-          await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
-        } catch (error) {
-          return projectPolicyError(error);
+        if (!trustedRosterExempt(trustedProject)) {
+          try {
+            await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
+          } catch (error) {
+            return projectPolicyError(error);
+          }
         }
         deleted = await store.deleteIfSnapshot(tenantId2, id, snapshot);
       } else {
@@ -41920,13 +42348,15 @@ function createTaskMiddleware(options = {}) {
               "Target Project task owner is not active in the exact roster."
             ));
           }
-          try {
-            await requireTrustedOwner(trustedProject, ownerId);
-          } catch (error) {
-            return projectPolicyError(error instanceof ProjectTaskOwnerPolicyError ? error : new ProjectTaskOwnerPolicyError(
-              "PROJECT_TASK_OWNER_INACTIVE",
-              "Target Project task owner is not active in the exact roster."
-            ));
+          if (!trustedRosterExempt(trustedProject)) {
+            try {
+              await requireTrustedOwner(trustedProject, ownerId);
+            } catch (error) {
+              return projectPolicyError(error instanceof ProjectTaskOwnerPolicyError ? error : new ProjectTaskOwnerPolicyError(
+                "PROJECT_TASK_OWNER_INACTIVE",
+                "Target Project task owner is not active in the exact roster."
+              ));
+            }
           }
         }
         if (effectiveOwnerType === "agent" && (input.result !== void 0 || input.failureReason !== void 0)) {
@@ -41974,10 +42404,12 @@ function createTaskMiddleware(options = {}) {
             )) return trustedContextError("Parent or dependency task changed before creation.");
             const callerError = await revalidateCaller();
             if (callerError) return callerError;
-            try {
-              await requireTrustedOwner(trustedProject, ownerId);
-            } catch (error) {
-              return projectPolicyError(error);
+            if (!trustedRosterExempt(trustedProject)) {
+              try {
+                await requireTrustedOwner(trustedProject, ownerId);
+              } catch (error) {
+                return projectPolicyError(error);
+              }
             }
           }
           return store.create({
@@ -42235,18 +42667,6 @@ function createTaskMiddleware(options = {}) {
             return trustedFailure;
           }
         }
-        if (trustedProject && input.dependencyTaskIds !== void 0) {
-          const interruption = input.context?.interruption;
-          const interruptionType2 = interruption && typeof interruption === "object" ? interruption.type : void 0;
-          if (input.status !== "interrupted" || interruptionType2 !== "external_dependency") {
-            taskUpdateBlocked(input.id, "INVALID_EXTERNAL_DEPENDENCY", {});
-            return JSON.stringify({
-              success: false,
-              code: "INVALID_EXTERNAL_DEPENDENCY",
-              error: "dependencyTaskIds are only valid for external dependency interruptions."
-            });
-          }
-        }
         if (trustedProject && (input.ownerType !== void 0 && input.ownerType !== existing.ownerType || input.ownerId !== void 0 && input.ownerId !== existing.ownerId)) {
           taskUpdateBlocked(input.id, "TASK_OWNERSHIP_VIA_DISPATCH_REQUIRED", {
             inputOwnerType: input.ownerType,
@@ -42438,7 +42858,7 @@ function createTaskMiddleware(options = {}) {
             return trustedContextError("Parent or dependency task changed before update.");
           }
         }
-        if (trustedProject) {
+        if (trustedProject && !trustedRosterExempt(trustedProject)) {
           try {
             await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
           } catch (error) {
@@ -42478,7 +42898,7 @@ function createTaskMiddleware(options = {}) {
         const workItemSummary = input.summary;
         let activityWarnings;
         try {
-          if (trustedProject) {
+          if (trustedProject && !trustedRosterExempt(trustedProject)) {
             try {
               await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
             } catch (error) {
@@ -42563,18 +42983,6 @@ function createTaskMiddleware(options = {}) {
             return trustedFailure;
           }
         }
-        if (trustedProject && input.dependencyTaskIds !== void 0) {
-          const interruption = input.context?.interruption;
-          const interruptionType2 = interruption && typeof interruption === "object" ? interruption.type : void 0;
-          if (input.status !== "interrupted" || interruptionType2 !== "external_dependency") {
-            taskUpdateBlocked(input.id, "INVALID_EXTERNAL_DEPENDENCY", {});
-            return JSON.stringify({
-              success: false,
-              code: "INVALID_EXTERNAL_DEPENDENCY",
-              error: "dependencyTaskIds are only valid for external dependency interruptions."
-            });
-          }
-        }
         if (trustedProject && (input.ownerType !== void 0 && input.ownerType !== existing.ownerType || input.ownerId !== void 0 && input.ownerId !== existing.ownerId)) {
           taskUpdateBlocked(input.id, "TASK_OWNERSHIP_VIA_DISPATCH_REQUIRED", {});
           return JSON.stringify({
@@ -42656,11 +43064,11 @@ function createTaskMiddleware(options = {}) {
           const interruption = input.context?.interruption;
           const explicitType = interruption && typeof interruption === "object" ? interruption.type : void 0;
           const type = explicitType ?? "missing_input";
-          if (type !== "missing_input" && type !== "external_dependency" && type !== "user_decision") {
+          if (type !== "missing_input" && type !== "user_decision") {
             return JSON.stringify({
               success: false,
               code: "INVALID_INTERRUPTION_TYPE",
-              error: "Agent interruption type must be missing_input, external_dependency, or user_decision."
+              error: "Agent interruption type must be missing_input or user_decision."
             });
           }
           await validateExecutionResult();
@@ -42672,8 +43080,7 @@ function createTaskMiddleware(options = {}) {
             type,
             summary: input.summary ?? "",
             actor,
-            threadId: statusThreadId,
-            dependencyTaskIds: input.dependencyTaskIds
+            threadId: statusThreadId
           });
           return lifecycleMutationResponse(interrupted);
         }
@@ -43381,7 +43788,6 @@ canonical Belief State:
 };
 
 // src/middlewares/documentLearningMiddleware.ts
-import { AgentType as AgentType9 } from "@axiom-lattice/protocols";
 import { createMiddleware as createMiddleware24 } from "langchain";
 
 // src/middlewares/documentLearningSkills.ts
@@ -43626,15 +44032,6 @@ var createDocumentLearningMiddleware = () => createMiddleware24({
   contextSchema,
   tools: []
 });
-var DOCUMENT_LEARNER_SYSTEM_PROMPT = `You are a capability learning specialist.
-
-CRITICAL FIRST ACTION \u2014 before any response about the task:
-1. Call the \`skill\` tool with skill_name: "agent-architecture" to load the
-authoritative Charter.
-2. Call the \`skill\` tool with skill_name: "document-learning-learn-capability" to
-load the source-to-capability workflow.
-Never announce that you will follow a skill. Load both in this order and follow
-their content. If either load fails, retry it once, then report the failure.`;
 var documentLearningPlugin = {
   meta: {
     type: "document-learning",
@@ -43643,92 +44040,6 @@ var documentLearningPlugin = {
     description: "\u4ECE\u6587\u6863\u4E2D\u5B66\u4E60\u77E5\u8BC6\uFF0C\u81EA\u52A8\u6784\u5EFA\u6280\u80FD\u4F53\u7CFB\u548C\u8BC4\u6D4B\u3002 Learn knowledge from documents and build structured skill systems with evaluations.",
     recommends: ["skill", "eval"]
   },
-  agents: {
-    "document-learner": {
-      key: "document-learner",
-      name: "Document Learning Agent",
-      description: "Read documents and build structured skill systems with evaluations. Use this agent when you need to extract knowledge from documents and turn it into reusable, testable agent skills.",
-      type: AgentType9.DEEP_AGENT,
-      prompt: DOCUMENT_LEARNER_SYSTEM_PROMPT,
-      subAgents: ["document-parser-benchmark"],
-      tools: [
-        "invoke_agent",
-        "list_agents",
-        "create_agent",
-        "update_agent",
-        "delete_agent",
-        "get_agent",
-        "list_tools",
-        "list_middleware_types"
-      ],
-      middleware: [
-        {
-          id: "skill",
-          type: "skill",
-          name: "Skill",
-          description: "Skill creation and loading",
-          enabled: true,
-          config: { readAll: true }
-        },
-        {
-          id: "document-learning",
-          type: "document-learning",
-          name: "Document Learning",
-          description: "Source-to-capability learning workflow",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "eval",
-          type: "eval",
-          name: "Eval",
-          description: "Evaluation design and execution",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "task",
-          type: "task",
-          name: "Task",
-          description: "Training process tracking with approval gates",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "widget",
-          type: "widget",
-          name: "Widget",
-          description: "Visualize benchmark results and eval dashboards",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "ask_user_to_clarify",
-          type: "ask_user_to_clarify",
-          name: "Ask User",
-          description: "Wait for user input at approval gates",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "filesystem",
-          type: "filesystem",
-          name: "Filesystem",
-          description: "Read documents, write skill files",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "document-parser",
-          type: "document-parser",
-          name: "Document Parser",
-          description: "Parse documents with the chosen engine",
-          enabled: true,
-          config: { connectAll: true }
-        }
-      ]
-    }
-  },
   skills: {
     "document-learning-learn-capability": {
       version: "1.0.0",
@@ -43957,7 +44268,7 @@ function createParseDocumentTool({
 }
 
 // src/middlewares/documentParserMiddleware.ts
-import { AgentType as AgentType10 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType9 } from "@axiom-lattice/protocols";
 
 // src/middlewares/documentBenchmarkWorkflow.ts
 var DOCUMENT_PARSER_BENCHMARK_YAML = `name: document-parser-benchmark
@@ -44410,6 +44721,23 @@ function createDocumentParserMiddleware(config) {
     tools: [createParseDocumentTool({ connectAll, connections, baseUrl, apiKey })]
   });
 }
+var DOCUMENT_PARSER_SYSTEM_PROMPT = `You are the Document Parser. Turn documents (pdf, docx, images, spreadsheets, and similar) into clean Markdown.
+
+CRITICAL FIRST ACTION: call the \`skill\` tool with skill_name: "document-parser-markitdown" and follow it. Never announce skill loads.
+
+DEFAULT \u2014 local MarkItDown:
+- Single file: run \`markitdown <input> -o <output.md>\` via shell.
+- Batch or literature collections: use the scripts bundled in the skill.
+- After converting, verify the output is non-empty and its structure/tables are intact, then report the exact input -> output paths.
+
+ESCALATION \u2014 remote parse_document:
+- Call parse_document only when local conversion fails, the format is unsupported, the output is empty or materially incomplete, the structure is badly damaged, OCR quality is inadequate, or the user explicitly asks for professional parsing.
+- When the user is unsatisfied with quality, use ask_user_to_clarify to ask whether to switch to a remote engine, and recommend one engine based on the observed file features and the user's feedback. If the user names an engine, use it.
+
+BENCHMARK:
+- Only when the user explicitly asks to compare engines. Confirm with ask_user_to_clarify first, then delegate to the document-parser-benchmark subagent. Never benchmark by default.
+
+Report only what you actually produced; never claim success without inspecting the output file.`;
 var documentParserPlugin = {
   meta: {
     type: "document-parser",
@@ -44480,9 +44808,59 @@ var documentParserPlugin = {
   },
   middleware: (config) => createDocumentParserMiddleware(config),
   agents: {
+    "document-parser": {
+      key: "document-parser",
+      type: AgentType9.DEEP_AGENT,
+      name: "Document Parser",
+      description: "Parse documents (pdf, docx, images, spreadsheets) into clean Markdown. Defaults to local MarkItDown; escalates to remote engines only when quality or format needs it; runs engine benchmarking only on explicit request.",
+      prompt: DOCUMENT_PARSER_SYSTEM_PROMPT,
+      subAgents: ["document-parser-benchmark"],
+      middleware: [
+        {
+          id: "skill",
+          type: "skill",
+          name: "Skill",
+          description: "Load the local MarkItDown parsing procedure",
+          enabled: true,
+          config: { readAll: true }
+        },
+        {
+          id: "filesystem",
+          type: "filesystem",
+          name: "Filesystem",
+          description: "Read source documents and write Markdown output",
+          enabled: true,
+          config: { vmIsolation: "project" }
+        },
+        {
+          id: "code_eval",
+          type: "code_eval",
+          name: "Code Runner",
+          description: "Run the markitdown CLI and bundled conversion scripts",
+          enabled: true,
+          config: { vmIsolation: "project" }
+        },
+        {
+          id: "document-parser",
+          type: "document-parser",
+          name: "Document Parser",
+          description: "Remote parse_document fallback for hard documents",
+          enabled: true,
+          config: { connectAll: true }
+        },
+        {
+          id: "ask_user_to_clarify",
+          type: "ask_user_to_clarify",
+          name: "Ask User",
+          description: "Confirm engine switches and benchmark runs",
+          enabled: true,
+          config: {}
+        }
+      ]
+    },
     "document-parser-benchmark": {
       key: "document-parser-benchmark",
-      type: AgentType10.WORKFLOW,
+      type: AgentType9.WORKFLOW,
       name: "Document Parser Benchmark",
       description: "Benchmark document parsing engines. Parses a document with 5 engines in parallel, scores results, and produces a ranking report. Use this when you need to evaluate which parsing engine works best for a given document.",
       prompt: "Benchmark document parsing engines: parse with 5 engines, score, and rank results.",
@@ -44522,8 +44900,8 @@ import { createHash as createHash7 } from "crypto";
 import {
   descriptorDataValue as descriptorDataValue2,
   parseTrustedRunContext as parseTrustedRunContext3,
-  snapshotExactArray as snapshotExactArray3,
-  snapshotExactRecord as snapshotExactRecord8
+  snapshotExactArray as snapshotExactArray2,
+  snapshotExactRecord as snapshotExactRecord7
 } from "@axiom-lattice/protocols";
 import { createMiddleware as createMiddleware26, tool as tool66 } from "langchain";
 import { z as z72 } from "zod";
@@ -44571,7 +44949,7 @@ function readTrustedRoomScope(config) {
 }
 function exactValues2(value, required, optional = []) {
   try {
-    return snapshotExactRecord8(value, required, optional);
+    return snapshotExactRecord7(value, required, optional);
   } catch {
     return void 0;
   }
@@ -44607,7 +44985,7 @@ function snapshotMembership3(value) {
   return { ...values, joinedAt, updatedAt };
 }
 function snapshotRows(value) {
-  return snapshotExactArray3(value) ?? [];
+  return snapshotExactArray2(value) ?? [];
 }
 async function hasActiveCurrentMembership(scope) {
   const memberships = getStoreLattice("default", "projectBotMembership").store;
@@ -44694,7 +45072,7 @@ var projectRoomPlugin = {
 // src/middlewares/sandboxPluginsMiddleware.ts
 import { createMiddleware as createMiddleware27, tool as tool67 } from "langchain";
 import { z as z73 } from "zod";
-import { AgentType as AgentType11 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType10 } from "@axiom-lattice/protocols";
 
 // src/middlewares/sandboxPluginsSkills.ts
 var PLUGIN_JSON_TEMPLATE = `{
@@ -45444,7 +45822,7 @@ var sandboxPluginsPlugin = {
       key: "plugin-builder",
       name: "Plugin Builder",
       description: "Author and manage tenant plugins in the shared sandbox: clarify goal, inputs/outputs, credentials, and whether a UI is needed; then write the manifest and JS handlers, add an optional HTML MCP App UI, and validate/test with the manage_plugin tool.",
-      type: AgentType11.DEEP_AGENT,
+      type: AgentType10.DEEP_AGENT,
       prompt: PLUGIN_BUILDER_PROMPT,
       middleware: [
         {
@@ -46124,6 +46502,7 @@ export {
   InMemoryDatabaseConfigStore,
   InMemoryMailboxStore,
   InMemoryMenuStore,
+  InMemoryModelProviderStore,
   InMemoryOpenAuditStore,
   InMemoryProjectBotMembershipStore,
   InMemoryProjectMembershipStore,
@@ -46217,6 +46596,7 @@ export {
   ThreadStatus2 as ThreadStatus,
   TokenCache,
   ToolLatticeManager,
+  UnsafeUpstreamUrlError,
   VectorStoreLatticeManager,
   VectorStoreProviderManager,
   VolumeFilesystem,
@@ -46225,6 +46605,7 @@ export {
   agentLatticeManager,
   appendReconciliationWarning,
   appendUiFence,
+  assertSafeUpstreamUrl,
   buildGrepResultsDict,
   buildInput,
   buildNamedVolumeName,
@@ -46356,6 +46737,7 @@ export {
   invokeWithRetry,
   isBuiltInSkill,
   isDirectRoom,
+  isMcpConnectionError,
   isPluginSkillAuthorizedInSandbox,
   isPluginSkillManagedInSandbox,
   isUsingDefaultKey,
@@ -46378,7 +46760,6 @@ export {
   parallelLimit,
   parseCronExpression,
   parseDirectRoomType,
-  parseExternalDependency,
   parseJudgeVerdict,
   parsePackSize,
   parseQueuedExecutionMode,
@@ -46407,6 +46788,7 @@ export {
   registerExistingToolWithTenant,
   registerLoggerLattice,
   registerModelLattice,
+  registerModelLatticeForTenant,
   registerQueueLattice,
   registerSTTModelLattice,
   registerSandboxProviderType,