@axiom-lattice/gateway 8.0.2 → 8.1.1

package/dist/index.mjs

@@ -2782,6 +2782,52 @@ import {
 
 // src/services/threads/threadOwnership.ts
 import { getStoreLattice as getStoreLattice5 } from "@axiom-lattice/core";
+var DELEGATED_THREAD_SEPARATOR = "____";
+var MAX_DELEGATED_THREAD_LINEAGE = 8;
+async function threadHasTenantRecord(tenantId, threadId) {
+  try {
+    const thread = await getStoreLattice5("default", "thread").store.getThreadById(
+      tenantId,
+      threadId
+    );
+    if (thread) return true;
+  } catch {
+  }
+  try {
+    const ledger = getStoreLattice5("default", "agentRun").store;
+    const runs = await ledger.listRuns(tenantId, threadId, { limit: 1 });
+    if (runs.length > 0) return true;
+  } catch {
+  }
+  try {
+    const tasks = getStoreLattice5("default", "task").store;
+    const matches = await tasks.list({ tenantId, threadId, limit: 1 });
+    return matches.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function threadLineageRootedInTenant(tenantId, threadId) {
+  let candidate = threadId;
+  for (let depth = 0; depth < MAX_DELEGATED_THREAD_LINEAGE; depth += 1) {
+    if (await threadHasTenantRecord(tenantId, candidate)) return true;
+    const boundary = candidate.lastIndexOf(DELEGATED_THREAD_SEPARATOR);
+    if (boundary <= 0) return false;
+    candidate = candidate.slice(0, boundary);
+  }
+  return false;
+}
+async function delegatedThreadOwnedBy(tenantId, assistantId, threadId) {
+  const marker = `${DELEGATED_THREAD_SEPARATOR}${assistantId}_`;
+  let boundary = threadId.indexOf(marker);
+  while (boundary > 0) {
+    if (await threadLineageRootedInTenant(tenantId, threadId.slice(0, boundary))) {
+      return true;
+    }
+    boundary = threadId.indexOf(marker, boundary + DELEGATED_THREAD_SEPARATOR.length);
+  }
+  return false;
+}
 async function threadOwnedBy(tenantId, assistantId, threadId) {
   try {
     const thread = await getStoreLattice5("default", "thread").store.getThreadById(
@@ -2800,10 +2846,12 @@ async function threadOwnedBy(tenantId, assistantId, threadId) {
   try {
     const tasks = getStoreLattice5("default", "task").store;
     const matches = await tasks.list({ tenantId, threadId, limit: 1 });
-    return matches.some((task) => task.ownerType === "agent" && task.ownerId === assistantId);
+    if (matches.some((task) => task.ownerType === "agent" && task.ownerId === assistantId)) {
+      return true;
+    }
   } catch {
-    return false;
   }
+  return delegatedThreadOwnedBy(tenantId, assistantId, threadId);
 }
 async function threadIsNewForTenant(tenantId, threadId) {
   try {
@@ -22296,6 +22344,9 @@ var ModelProviderService = class {
       resolveDiscoveryTimeoutMs()
     );
     const previous = await this.deps.providerStore.listModels(tenantId, id3);
+    const previousById = new Map(
+      previous.map((model) => [model.modelId, model])
+    );
     const previousIds = new Set(previous.map((model) => model.modelId));
     let discovered;
     try {
@@ -22324,6 +22375,9 @@ var ModelProviderService = class {
       id3,
       discovered.map((model) => ({
         ...model,
+        // A tenant may have renamed a model. Discovery must not overwrite that
+        // override with the upstream name; brand-new rows take the upstream one.
+        displayName: previousById.get(model.id)?.displayName ?? model.displayName,
         // Same rule as `setModels`: a row this provider just brought in starts
         // with the default config, a row already stored keeps the tenant's.
         extra: previousIds.has(model.id) ? void 0 : { ...DEFAULT_MODEL_EXTRA }
@@ -22505,30 +22559,36 @@ var ModelProviderService = class {
   async setModels(userId, tenantId, id3, selection) {
     await this.assertAdmin(userId, tenantId);
     const provider = await this.requireProvider(tenantId, id3);
-    if (selection.filter((entry) => entry.isDefault === true).length > 1) {
+    const previous = await this.deps.providerStore.listModels(tenantId, id3);
+    const previousById = new Map(
+      previous.map((model) => [model.modelId, model])
+    );
+    const normalized = selection.map((entry) => {
+      const stored = previousById.get(entry.modelId);
+      const kindChanged = stored !== void 0 && entry.kind !== void 0 && entry.kind !== (stored.kind ?? "chat");
+      return kindChanged ? { ...entry, isDefault: false } : entry;
+    });
+    if (normalized.filter((entry) => entry.isDefault === true).length > 1) {
       throw new ModelProviderServiceError(
         "INVALID_INPUT",
         400,
         "Only one model can be the tenant's default"
       );
     }
-    const previous = await this.deps.providerStore.listModels(tenantId, id3);
-    const previousById = new Map(
-      previous.map((model) => [model.modelId, model])
-    );
     await this.deps.providerStore.replaceProviderModels(
       tenantId,
       id3,
-      selection.map((entry) => ({
+      normalized.map((entry) => ({
         id: entry.modelId,
         enabled: entry.enabled,
         // A model the upstream stopped offering stays in the set, flagged
         // rather than dropped: deleting it would silently break anything
         // referencing its key.
         stale: entry.stale ?? false,
-        // The selection carries only ids and states, so a model already in the
-        // snapshot keeps the metadata discovery gave it.
-        displayName: previousById.get(entry.modelId)?.displayName,
+        // The selection carries only edited rows' names, so a model already in
+        // the snapshot keeps its name when the field is omitted. An empty
+        // string clears the tenant override.
+        displayName: entry.displayName !== void 0 ? entry.displayName.trim() || void 0 : previousById.get(entry.modelId)?.displayName,
         ownedBy: previousById.get(entry.modelId)?.ownedBy,
         // An omitted `extra` means "keep what is stored" — the picker sends no
         // config, and a sync must not wipe one set by hand. The store resolves
@@ -22604,6 +22664,10 @@ var ModelProviderService = class {
         providerId2,
         providerModels.map((model) => ({
           id: model.modelId,
+          // This is a whole-set write: any field left out is cleared, so the
+          // metadata that only discovery knows must travel with it.
+          displayName: model.displayName,
+          ownedBy: model.ownedBy,
           enabled: model.enabled,
           stale: model.stale,
           extra: model.extra,
@@ -22636,6 +22700,9 @@ var ModelProviderService = class {
       provider.id,
       rows.map((row) => ({
         id: row.modelId,
+        // Whole-set write: keep the metadata this method is not changing.
+        displayName: row.displayName,
+        ownedBy: row.ownedBy,
         enabled: row.enabled,
         stale: row.stale,
         kind: row.kind,
@@ -22894,6 +22961,9 @@ var setModelsSchema = z9.object({
   models: z9.array(
     z9.object({
       modelId: z9.string().trim().min(1).max(512),
+      // Omitted means "leave the stored name alone"; an empty string
+      // clears a tenant override. Same rule as `extra`.
+      displayName: z9.string().trim().max(255).optional(),
       enabled: z9.boolean(),
       stale: z9.boolean().optional(),
       // Omitted means "leave the stored config alone" — the picker sends