@axiom-lattice/gateway 8.1.0 → 8.2.0

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 {
@@ -3064,6 +3112,29 @@ async function listAllRuns(ledger, tenantId, threadId) {
     if (page.length < ACTIVE_RUN_PAGE_SIZE) return runs;
   }
 }
+var INPUT_PREVIEW_MAX = 200;
+function contentToPreview(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    if (typeof part === "string") return part;
+    return isRecord(part) && typeof part.text === "string" ? part.text : "";
+  }).join("");
+}
+function inputPreview(input) {
+  if (!isRecord(input)) return null;
+  if (typeof input.message === "string") {
+    return input.message.trim().slice(0, INPUT_PREVIEW_MAX) || null;
+  }
+  const messages = Array.isArray(input.messages) ? input.messages : [];
+  for (const message of messages) {
+    if (!isRecord(message)) continue;
+    if (message.role !== void 0 && message.role !== "human") continue;
+    const text = contentToPreview(message.content).trim();
+    if (text) return text.slice(0, INPUT_PREVIEW_MAX);
+  }
+  return null;
+}
 function toSafeRun(run2) {
   return {
     runId: run2.runId,
@@ -3075,7 +3146,9 @@ function toSafeRun(run2) {
     createdAt: run2.createdAt,
     updatedAt: run2.updatedAt,
     startedAt: run2.startedAt,
-    finishedAt: run2.finishedAt
+    finishedAt: run2.finishedAt,
+    messageId: run2.inputMessageIds[0] ?? null,
+    inputPreview: inputPreview(run2.input)
   };
 }
 function isTerminal(run2) {
@@ -3205,6 +3278,35 @@ function createRunLifecycleHandlers(deps = {}) {
   const pollIntervalMs = deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
   const now = deps.now ?? Date.now;
   const sleep = deps.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms)));
+  const withRunCreateLock = async (request, reply, tenantId, assistantId, threadId, operation) => {
+    const key = runCreateScopeKey(tenantId, assistantId, threadId);
+    return serializeRunCreate(key, async () => {
+      const leaseStore = resolveLeaseStore();
+      if (!leaseStore) return operation();
+      try {
+        return await withLease(
+          leaseStore,
+          key,
+          getReplicaId2(),
+          operation,
+          RUN_CREATE_LEASE
+        );
+      } catch (error) {
+        if (error instanceof LeaseAcquisitionTimeoutError) {
+          request.log.warn(
+            { err: error, leaseKey: key },
+            "Run create lease acquisition timed out"
+          );
+          return unavailable(
+            reply,
+            RUN_CREATE_LOCK_TIMEOUT,
+            "Could not serialize run creation for this thread; retry shortly"
+          );
+        }
+        throw error;
+      }
+    });
+  };
   const waitForTerminal = async (tenantId, params, initial) => {
     let current3 = initial;
     const deadline = now() + waitTimeoutMs;
@@ -3434,35 +3536,6 @@ function createRunLifecycleHandlers(deps = {}) {
       const outcome = await createPending();
       return outcome.ok ? respondCreated(outcome.run) : outcome.response;
     };
-    const withRunCreateLock = async (operation) => {
-      const key = runCreateScopeKey(tenantId, assistantId, threadId);
-      return serializeRunCreate(key, async () => {
-        const leaseStore = resolveLeaseStore();
-        if (!leaseStore) return operation();
-        try {
-          return await withLease(
-            leaseStore,
-            key,
-            getReplicaId2(),
-            operation,
-            RUN_CREATE_LEASE
-          );
-        } catch (error) {
-          if (error instanceof LeaseAcquisitionTimeoutError) {
-            request.log.warn(
-              { err: error, leaseKey: key },
-              "Run create lease acquisition timed out"
-            );
-            return unavailable(
-              reply,
-              RUN_CREATE_LOCK_TIMEOUT,
-              "Could not serialize run creation for this thread; retry shortly"
-            );
-          }
-          throw error;
-        }
-      });
-    };
     const scopedRunApiRuns = (runs) => runs.filter(
       (run2) => run2.tenantId === tenantId && run2.threadId === threadId && run2.assistantId === assistantId && run2.source === "run_api"
     );
@@ -3482,7 +3555,7 @@ function createRunLifecycleHandlers(deps = {}) {
       }
     };
     if (strategy === "reject") {
-      return withRunCreateLock(async () => {
+      return withRunCreateLock(request, reply, tenantId, assistantId, threadId, async () => {
         const read = await readThreadRuns();
         if (!read.ok) return read.response;
         const active2 = scopedRunApiRuns(read.runs).filter(isActiveRun);
@@ -3498,7 +3571,7 @@ function createRunLifecycleHandlers(deps = {}) {
       });
     }
     if (strategy === "interrupt") {
-      return withRunCreateLock(async () => {
+      return withRunCreateLock(request, reply, tenantId, assistantId, threadId, async () => {
         const read = await readThreadRuns();
         if (!read.ok) return read.response;
         const scoped = scopedRunApiRuns(read.runs);
@@ -3561,8 +3634,8 @@ function createRunLifecycleHandlers(deps = {}) {
         return createAndRespond();
       });
     }
-    if (strategy !== "rollback") return withRunCreateLock(createAndRespond);
-    return withRunCreateLock(async () => {
+    if (strategy !== "rollback") return withRunCreateLock(request, reply, tenantId, assistantId, threadId, createAndRespond);
+    return withRunCreateLock(request, reply, tenantId, assistantId, threadId, async () => {
       const active2 = (await listAllRuns(ledger, tenantId, threadId)).filter(
         (run2) => run2.tenantId === tenantId && run2.threadId === threadId && run2.assistantId === assistantId && run2.source !== "legacy" && (run2.status === "pending" || run2.status === "running")
       );
@@ -3697,6 +3770,76 @@ function createRunLifecycleHandlers(deps = {}) {
       return createAndRespond();
     });
   };
+  const cancelActive = async (request, reply) => {
+    if (!ledger) {
+      return unavailable(reply, RUN_LEDGER_UNAVAILABLE, "Run ledger is not available");
+    }
+    const tenantId = getTenantId4(request);
+    const { assistantId, threadId } = request.params;
+    if (!await ownsThread(tenantId, assistantId, threadId)) {
+      return notFound2(reply, THREAD_NOT_FOUND2, "Thread not found");
+    }
+    const router = resolveRouter();
+    return withRunCreateLock(request, reply, tenantId, assistantId, threadId, async () => {
+      let runs;
+      try {
+        runs = await listAllRuns(ledger, tenantId, threadId);
+      } catch (error) {
+        request.log.error({ err: error }, "Active run read failed");
+        return unavailable(reply, RUN_CREATE_UNAVAILABLE2, "Run queue is not available");
+      }
+      const active2 = runs.filter(
+        (run2) => run2.tenantId === tenantId && run2.assistantId === assistantId && run2.threadId === threadId && run2.source === "run_api" && isActiveRun(run2)
+      );
+      const cancelled = [];
+      const requested = [];
+      const failed = [];
+      for (const run2 of active2) {
+        try {
+          if (run2.status === "pending") {
+            const status2 = await ledger.requestCancel(tenantId, run2.runId);
+            if (status2 === "cancelled") {
+              const latest = await ledger.getRun(tenantId, run2.runId);
+              if (latest) cancelled.push(toSafeRun(latest));
+            } else if (status2 === "requested") {
+              requested.push(toSafeRun(run2));
+            }
+            continue;
+          }
+          if (router) {
+            const status2 = await router.requestCancelById({
+              tenantId,
+              assistantId,
+              threadId,
+              runId: run2.runId,
+              reason: "abort"
+            });
+            if (status2 === "requested" || status2 === "cancelled") {
+              requested.push(toSafeRun(run2));
+            }
+            continue;
+          }
+          const status = await ledger.requestCancel(tenantId, run2.runId);
+          if (status === "requested" || status === "cancelled") {
+            requested.push(toSafeRun(run2));
+          }
+        } catch (error) {
+          failed.push({
+            runId: run2.runId,
+            code: "RUN_CANCEL_FAILED",
+            message: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      return reply.status(200).send({
+        success: true,
+        accepted: failed.length === 0,
+        cancelled,
+        requested,
+        failed
+      });
+    });
+  };
   const list = async (request, reply) => {
     if (!ledger) {
       return unavailable(reply, RUN_LEDGER_UNAVAILABLE, "Run ledger is not available");
@@ -3706,12 +3849,14 @@ function createRunLifecycleHandlers(deps = {}) {
     if (!await ownsThread(tenantId, assistantId, threadId)) {
       return notFound2(reply, THREAD_NOT_FOUND2, "Thread not found");
     }
-    const runs = (await ledger.listRuns(tenantId, threadId)).filter(
-      (run2) => run2.tenantId === tenantId && run2.threadId === threadId && run2.assistantId === assistantId
+    const activeOnly = request.query.active === "true" || request.query.active === "1";
+    const source = request.query.source;
+    const scoped = (activeOnly ? await listAllRuns(ledger, tenantId, threadId) : await ledger.listRuns(tenantId, threadId)).filter(
+      (run2) => run2.tenantId === tenantId && run2.threadId === threadId && run2.assistantId === assistantId && (!activeOnly || isActiveRun(run2)) && (source === void 0 || run2.source === source)
     );
     return reply.status(200).send({
       success: true,
-      data: { runs: runs.map(toSafeRun) }
+      data: { runs: scoped.map(toSafeRun) }
     });
   };
   const get = async (request, reply) => {
@@ -4067,7 +4212,7 @@ function createRunLifecycleHandlers(deps = {}) {
       run: toSafeRun(outcome.run)
     });
   };
-  return { create, list, get, join: join4, cancel };
+  return { create, list, get, join: join4, cancel, cancelActive };
 }
 function registerRunLifecycleRoutes(app2, deps = {}) {
   const handlers = createRunLifecycleHandlers(deps);
@@ -4079,6 +4224,10 @@ function registerRunLifecycleRoutes(app2, deps = {}) {
     "/api/assistants/:assistantId/threads/:threadId/runs",
     handlers.list
   );
+  app2.post(
+    "/api/assistants/:assistantId/threads/:threadId/runs/cancel-active",
+    handlers.cancelActive
+  );
   app2.get(
     "/api/assistants/:assistantId/threads/:threadId/runs/:runId",
     handlers.get
@@ -20975,6 +21124,15 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
           return normalizeError2(reply, error);
         }
       });
+      routes.post(`${prefix}/assistants/:assistantId/threads/:threadId/runs/cancel-active`, async (request, reply) => {
+        try {
+          const params = mirrorThreadParams.parse(request.params);
+          const { proxy } = await authorizeRunMirror(request, params);
+          return await runLifecycle.cancelActive(proxy, reply);
+        } catch (error) {
+          return normalizeError2(reply, error);
+        }
+      });
       routes.post(`${prefix}/assistants/:assistantId/threads/:threadId/runs/:runId/cancel`, async (request, reply) => {
         try {
           const params = mirrorRunParams.parse(request.params);