@axiom-lattice/core 6.0.0 → 6.1.1

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);
@@ -11236,8 +11551,8 @@ function readLoopBreakerConfig(env = process.env) {
     return Math.floor(parsed);
   };
   return {
-    repeatWarn: parse(env.AGENT_REPEATED_TOOL_CALL_WARN, 3),
-    repeatStop: parse(env.AGENT_REPEATED_TOOL_CALL_STOP, 5),
+    repeatWarn: parse(env.AGENT_REPEATED_TOOL_CALL_WARN, 20),
+    repeatStop: parse(env.AGENT_REPEATED_TOOL_CALL_STOP, 25),
     runLimit: parse(env.AGENT_TOOL_CALL_RUN_LIMIT, 300),
     skillRunLimit: parse(env.AGENT_SKILL_CALL_RUN_LIMIT, 8)
   };
@@ -11260,9 +11575,9 @@ var BREAKER_STATE_SCHEMA = z41.object({
   repeatedToolCallMemberSignatures: z41.array(z41.string()).default([])
 });
 function createRepeatedToolCallBreakerMiddleware(options = {}) {
-  const rawWarn = options.warnThreshold ?? 3;
+  const rawWarn = options.warnThreshold ?? 20;
   const warnThreshold = rawWarn > 0 ? Math.max(2, rawWarn) : 0;
-  const stopThreshold = Math.max(1, options.stopThreshold ?? 5);
+  const stopThreshold = Math.max(1, options.stopThreshold ?? 25);
   return createMiddleware10({
     name: "RepeatedToolCallBreaker",
     stateSchema: BREAKER_STATE_SCHEMA,
@@ -34372,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,
@@ -38728,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";
 
@@ -41718,7 +42077,7 @@ var manageTaskSchema = z70.object({
   parentId: z70.string().optional().describe("Parent task ID for grouping subtasks"),
   sourceId: z70.string().optional().describe("Source session/thread ID"),
   context: z70.record(z70.unknown()).optional().describe("Additional context data"),
-  ownerType: z70.enum(["user", "agent"]).optional().describe("Owner type. Defaults to 'user' if omitted"),
+  ownerType: z70.enum(["user", "agent"]).optional().describe("Owner type. Defaults to the runtime actor: agent runtime (no user identity) -> 'agent', user runtime -> 'user'."),
   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"),
@@ -41905,7 +42264,9 @@ function createTaskMiddleware(options = {}) {
         return projectPolicyError(error);
       }
     }
-    const ownerId = input.ownerId || trustedScope?.assistantId || (input.ownerType === "agent" ? rc.assistant_id : null) || rc.user_id;
+    const runtimeOwnerType = rc.user_id ? "user" : rc.assistant_id ? "agent" : "user";
+    const requestedOwnerType = input.ownerType ?? runtimeOwnerType;
+    const ownerId = input.ownerId || trustedScope?.assistantId || (requestedOwnerType === "agent" ? rc.assistant_id : null) || rc.user_id;
     const store = getTaskStore();
     const deleteOneTask = async (id) => {
       if (delegatedTaskId && id !== delegatedTaskId) {
@@ -41974,7 +42335,7 @@ function createTaskMiddleware(options = {}) {
             createScopeProjectId = createScopeProjectId ?? parentTask.projectId;
           }
         }
-        const effectiveOwnerType = delegatedTaskId ? "agent" : trustedProject ? "agent" : input.ownerType || "user";
+        const effectiveOwnerType = delegatedTaskId ? "agent" : trustedProject ? "agent" : requestedOwnerType;
         const effectiveOwnerId = delegatedTaskId ? rc.assistant_id : ownerId;
         if (delegatedTaskId && !effectiveOwnerId) {
           return delegatedTaskScopeError(delegatedTaskId);
@@ -42000,6 +42361,14 @@ function createTaskMiddleware(options = {}) {
             }
           }
         }
+        if (!delegatedTaskId && (typeof effectiveOwnerId !== "string" || effectiveOwnerId.length === 0)) {
+          return JSON.stringify({
+            success: false,
+            code: "TASK_OWNER_REQUIRED",
+            error: "Cannot resolve task owner: no user or agent identity in this run.",
+            hint: 'Provide an explicit ownerId, or retry with ownerType:"agent" if this run has an agent identity.'
+          });
+        }
         if (effectiveOwnerType === "agent" && (input.result !== void 0 || input.failureReason !== void 0)) {
           return JSON.stringify({
             success: false,
@@ -43054,13 +43423,22 @@ function createTaskMiddleware(options = {}) {
     try {
       response = await handleManageTaskAction(input, config, validateExecutionResult, markMutation);
     } catch (error) {
-      if (!(error instanceof ExecutionResultNotPendingError)) throw error;
+      if (error instanceof GraphInterrupt3) throw error;
+      if (error instanceof ExecutionResultNotPendingError) {
+        return JSON.stringify({
+          success: false,
+          code: "EXECUTION_RESULT_NOT_PENDING",
+          taskId: error.taskId,
+          executionResultId: error.executionResultId,
+          error: error.message
+        });
+      }
+      if (input.executionResultId) throw error;
       return JSON.stringify({
         success: false,
-        code: "EXECUTION_RESULT_NOT_PENDING",
-        taskId: error.taskId,
-        executionResultId: error.executionResultId,
-        error: error.message
+        code: "TASK_ACTION_FAILED",
+        error: error instanceof Error ? error.message : String(error),
+        hint: "The action did not complete. Fix the input or retry; do not repeat the identical call."
       });
     }
     return reconcileExplicitExecutionResult(
@@ -43226,8 +43604,8 @@ changes only when acceptance criteria are truly met.
 ${TASK_CONVERGENCE_GUIDANCE}
 
 ### Ownership defaults
-- No params: ownerType defaults to "user" with current user's ID
-- ownerType="agent": auto-fills ownerId from current agent (subtask for yourself)
+- No params: ownerType defaults to the runtime actor (user runtime -> current user's ID; agent runtime -> current agent's ID)
+- ownerType="agent": auto-fills ownerId from the current agent (subtask for yourself)
 - Explicit ownerId: assign to a specific agent or user`;
       const boundTaskId = request.state?.taskId;
       const binding = typeof boundTaskId === "string" && boundTaskId ? renderTaskBinding(boundTaskId) : "";
@@ -43246,7 +43624,7 @@ ${TASK_CONVERGENCE_GUIDANCE}
           description: `Manage persistent tasks and their activity timelines for user and agent tasks.
 
 ## Owner defaults
-- No ownerType/ownerId: auto-assigned to current user
+- No ownerType/ownerId: auto-assigned to the runtime actor (user runtime -> current user; agent runtime -> current agent)
 - ownerType="agent" without ownerId: auto-assigned to current agent
 - Explicit ownerId: assign to a specific agent (cross-agent delegation)
 
@@ -46143,6 +46521,7 @@ export {
   InMemoryDatabaseConfigStore,
   InMemoryMailboxStore,
   InMemoryMenuStore,
+  InMemoryModelProviderStore,
   InMemoryOpenAuditStore,
   InMemoryProjectBotMembershipStore,
   InMemoryProjectMembershipStore,
@@ -46236,6 +46615,7 @@ export {
   ThreadStatus2 as ThreadStatus,
   TokenCache,
   ToolLatticeManager,
+  UnsafeUpstreamUrlError,
   VectorStoreLatticeManager,
   VectorStoreProviderManager,
   VolumeFilesystem,
@@ -46244,6 +46624,7 @@ export {
   agentLatticeManager,
   appendReconciliationWarning,
   appendUiFence,
+  assertSafeUpstreamUrl,
   buildGrepResultsDict,
   buildInput,
   buildNamedVolumeName,
@@ -46426,6 +46807,7 @@ export {
   registerExistingToolWithTenant,
   registerLoggerLattice,
   registerModelLattice,
+  registerModelLatticeForTenant,
   registerQueueLattice,
   registerSTTModelLattice,
   registerSandboxProviderType,