@agent-native/core 0.92.11 → 0.93.0

package/corpus/core/src/integrations/integration-memory.ts

@@ -0,0 +1,187 @@
+import type { ActionEntry } from "../agent/production-agent.js";
+import {
+  resourceDeleteByPath,
+  resourceGetByPath,
+  resourceList,
+  resourcePut,
+} from "../resources/store.js";
+import { getIntegrationRequestContext } from "../server/request-context.js";
+
+const INDEX_PATH = "memory/MEMORY.md";
+const MAX_PROMPT_CHARS = 12_000;
+const EMPTY_INDEX = "# Channel Memory\n";
+
+function requireScopeId(): string {
+  const scopeId = getIntegrationRequestContext()?.scopeId;
+  if (!scopeId) {
+    throw new Error(
+      "Channel memory is only available inside an authorized integration scope.",
+    );
+  }
+  return scopeId;
+}
+
+function ownerForScope(scopeId: string): string {
+  return `__integration_scope__:${scopeId}`;
+}
+
+function memoryName(value: unknown): string {
+  const name = String(value ?? "")
+    .trim()
+    .toLowerCase();
+  if (!/^[a-z0-9][a-z0-9_-]{0,79}$/.test(name)) {
+    throw new Error(
+      "Memory name must use 1-80 lowercase letters, numbers, dashes, or underscores.",
+    );
+  }
+  return name;
+}
+
+function memoryText(value: unknown, name: string, max: number): string {
+  const text = String(value ?? "").trim();
+  if (!text) throw new Error(`${name} is required`);
+  return text.slice(0, max);
+}
+
+export async function listIntegrationMemory(scopeId = requireScopeId()) {
+  const owner = ownerForScope(scopeId);
+  const resources = await resourceList(owner, "memory/");
+  return resources
+    .filter((resource) => resource.path !== INDEX_PATH)
+    .map((resource) => ({
+      name: resource.path.replace(/^memory\//, "").replace(/\.md$/, ""),
+      path: resource.path,
+      updatedAt: resource.updatedAt,
+      size: resource.size,
+    }));
+}
+
+export async function rememberForIntegrationScope(
+  input: {
+    name: string;
+    description: string;
+    content: string;
+  },
+  scopeId = requireScopeId(),
+): Promise<{ name: string; description: string }> {
+  const owner = ownerForScope(scopeId);
+  const name = memoryName(input.name);
+  const description = memoryText(input.description, "description", 300);
+  const content = memoryText(input.content, "content", 20_000);
+  const date = new Date().toISOString().slice(0, 10);
+  await resourcePut(
+    owner,
+    `memory/${name}.md`,
+    `---\ntype: channel\ndescription: ${description.replace(/\n/g, " ")}\nupdated: ${date}\n---\n\n${content}`,
+    "text/markdown",
+  );
+
+  const existing = await resourceGetByPath(owner, INDEX_PATH);
+  const lines = (existing?.content || EMPTY_INDEX)
+    .split("\n")
+    .filter((line) => !line.startsWith(`- [${name}]`));
+  lines.push(`- [${name}](${name}.md) — ${description}`);
+  await resourcePut(
+    owner,
+    INDEX_PATH,
+    lines.join("\n").trimEnd() + "\n",
+    "text/markdown",
+  );
+  return { name, description };
+}
+
+export async function forgetIntegrationMemory(
+  input: {
+    name: string;
+  },
+  scopeId = requireScopeId(),
+): Promise<{ name: string; deleted: boolean }> {
+  const owner = ownerForScope(scopeId);
+  const name = memoryName(input.name);
+  const deleted = await resourceDeleteByPath(owner, `memory/${name}.md`);
+  const existing = await resourceGetByPath(owner, INDEX_PATH);
+  if (existing?.content) {
+    const next = existing.content
+      .split("\n")
+      .filter((line) => !line.startsWith(`- [${name}]`))
+      .join("\n")
+      .trimEnd();
+    await resourcePut(owner, INDEX_PATH, `${next}\n`, "text/markdown");
+  }
+  return { name, deleted };
+}
+
+export async function loadIntegrationMemoryPrompt(
+  scopeId: string | undefined,
+): Promise<string> {
+  if (!scopeId) return "";
+  const owner = ownerForScope(scopeId);
+  const index = await resourceGetByPath(owner, INDEX_PATH);
+  if (!index?.content) return "";
+  const resources = await resourceList(owner, "memory/");
+  const entries: string[] = [];
+  for (const resource of resources
+    .filter((item) => item.path !== INDEX_PATH)
+    .slice(0, 20)) {
+    const full = await resourceGetByPath(owner, resource.path);
+    if (full?.content) entries.push(full.content.slice(0, 4_000));
+  }
+  if (!entries.length) return "";
+  return `\n\n<integration-memory scope="${scopeId}">\nThese are explicit memories saved for this conversation scope. Policy and system instructions override them.\n${entries.join("\n\n")}\n</integration-memory>`.slice(
+    0,
+    MAX_PROMPT_CHARS,
+  );
+}
+
+export function integrationMemoryActions(): Record<string, ActionEntry> {
+  return {
+    "list-integration-memory": {
+      tool: {
+        description:
+          "List explicit memories saved for the current messaging channel. This is unavailable outside an authorized channel scope.",
+        parameters: { type: "object", properties: {} },
+      },
+      readOnly: true,
+      parallelSafe: true,
+      run: async () => JSON.stringify(await listIntegrationMemory()),
+    },
+    "remember-for-integration-scope": {
+      tool: {
+        description:
+          "Save a durable memory ONLY when the user explicitly asks to remember something for this channel/conversation. Never infer consent or auto-save ordinary chat.",
+        parameters: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            description: { type: "string" },
+            content: { type: "string" },
+          },
+          required: ["name", "description", "content"],
+        },
+      },
+      run: async (args: Record<string, unknown>) =>
+        JSON.stringify(
+          await rememberForIntegrationScope({
+            name: String(args.name ?? ""),
+            description: String(args.description ?? ""),
+            content: String(args.content ?? ""),
+          }),
+        ),
+    },
+    "forget-integration-memory": {
+      tool: {
+        description:
+          "Delete one explicit memory from the current messaging channel when the user asks to forget it.",
+        parameters: {
+          type: "object",
+          properties: { name: { type: "string" } },
+          required: ["name"],
+        },
+      },
+      run: async (args: Record<string, unknown>) =>
+        JSON.stringify(
+          await forgetIntegrationMemory({ name: String(args.name ?? "") }),
+        ),
+    },
+  };
+}

package/corpus/core/src/integrations/pending-tasks-retry-job.ts

@@ -2,6 +2,7 @@ import { getDbExec } from "../db/client.js";
 import { withConfiguredAppBasePath } from "../server/app-base-path.js";
 import { FRAMEWORK_ROUTE_PREFIX } from "../server/core-routes-plugin.js";
 import { signInternalToken } from "./internal-token.js";
+import { MAX_PENDING_TASK_ATTEMPTS } from "./pending-tasks-store.js";
 
 /**
  * Retries stuck integration webhook tasks.
@@ -35,8 +36,6 @@ const PENDING_STUCK_AFTER_MS = 90_000;
 const DEFAULT_PROCESSING_STUCK_AFTER_MS = 5 * 60 * 1000;
 const SERVERLESS_PROCESSING_STUCK_AFTER_MS = 75_000;
 /** After this many attempts we give up and mark the task failed */
-const MAX_ATTEMPTS = 3;
-
 const PROCESSOR_PATH = `${FRAMEWORK_ROUTE_PREFIX}/integrations/process-task`;
 
 let retryInterval: ReturnType<typeof setInterval> | null = null;
@@ -109,25 +108,26 @@ export async function retryStuckPendingTasks(
     try {
       // Cap retries — mark failed and move on so the row stops bouncing
       // between pending and processing forever.
-      if (row.attempts >= MAX_ATTEMPTS) {
+      if (row.attempts >= MAX_PENDING_TASK_ATTEMPTS) {
         await client.execute({
           sql: `
             UPDATE integration_pending_tasks
                SET status = 'failed',
                    updated_at = ?,
-                   error_message = COALESCE(error_message, ?)
+                   error_message = COALESCE(error_message, ?),
+                   payload = '{}'
              WHERE id = ?
                AND status = ?
           `,
           args: [
             Date.now(),
-            `Retry job: exceeded ${MAX_ATTEMPTS} attempts`,
+            `Retry job: exceeded ${MAX_PENDING_TASK_ATTEMPTS} attempts`,
             row.id,
             row.status,
           ],
         });
         console.warn(
-          `[integrations] Pending task ${row.id} exceeded ${MAX_ATTEMPTS} attempts — marking failed`,
+          `[integrations] Pending task ${row.id} exceeded ${MAX_PENDING_TASK_ATTEMPTS} attempts — marking failed`,
         );
         continue;
       }

package/corpus/core/src/integrations/pending-tasks-store.ts

@@ -18,6 +18,7 @@ import {
 } from "../db/ddl-guard.js";
 
 let _initPromise: Promise<void> | undefined;
+export const MAX_PENDING_TASK_ATTEMPTS = 3;
 
 async function ensureTable(): Promise<void> {
   if (!_initPromise) {
@@ -128,6 +129,31 @@ export interface PendingTask {
   completedAt: number | null;
 }
 
+/**
+ * Whether a provider thread currently has queued or executing work.
+ *
+ * Messaging adapters use this to accept unmentioned replies only while an
+ * agent task is active. This prevents broad message subscriptions from turning
+ * every channel message into an agent invocation.
+ */
+export async function hasActivePendingTask(
+  platform: string,
+  externalThreadId: string,
+): Promise<boolean> {
+  await ensureTable();
+  const client = getDbExec();
+  const { rows } = await client.execute({
+    sql: `SELECT 1 AS active
+      FROM integration_pending_tasks
+      WHERE platform = ?
+        AND external_thread_id = ?
+        AND status IN ('pending', 'processing')
+      LIMIT 1`,
+    args: [platform, externalThreadId],
+  });
+  return rows.length > 0;
+}
+
 function rowToTask(row: Record<string, unknown>): PendingTask {
   return {
     id: row.id as string,
@@ -239,10 +265,24 @@ export async function claimPendingTask(
       ? `UPDATE integration_pending_tasks
          SET status = ?, attempts = attempts + 1, updated_at = ?
          WHERE id = ? AND status = 'pending'
+           AND NOT EXISTS (
+             SELECT 1 FROM integration_pending_tasks active
+             WHERE active.platform = integration_pending_tasks.platform
+               AND active.external_thread_id = integration_pending_tasks.external_thread_id
+               AND active.status = 'processing'
+               AND active.id <> integration_pending_tasks.id
+           )
          RETURNING id, platform, external_thread_id, payload, owner_email, org_id, status, attempts, error_message, created_at, updated_at, completed_at`
       : `UPDATE integration_pending_tasks
          SET status = ?, attempts = attempts + 1, updated_at = ?
-         WHERE id = ? AND status = 'pending'`,
+         WHERE id = ? AND status = 'pending'
+           AND NOT EXISTS (
+             SELECT 1 FROM integration_pending_tasks active
+             WHERE active.platform = integration_pending_tasks.platform
+               AND active.external_thread_id = integration_pending_tasks.external_thread_id
+               AND active.status = 'processing'
+               AND active.id <> integration_pending_tasks.id
+           )`,
     args: ["processing", now, id],
   });
   const rows = result.rows ?? [];
@@ -263,6 +303,21 @@ export async function claimPendingTask(
   return fetched;
 }
 
+/** Next queued turn for a provider thread after its current task completes. */
+export async function getNextPendingTaskIdForThread(
+  platform: string,
+  externalThreadId: string,
+): Promise<string | null> {
+  await ensureTable();
+  const { rows } = await getDbExec().execute({
+    sql: `SELECT id FROM integration_pending_tasks
+      WHERE platform = ? AND external_thread_id = ? AND status = 'pending'
+      ORDER BY created_at ASC LIMIT 1`,
+    args: [platform, externalThreadId],
+  });
+  return rows[0]?.id ? String(rows[0].id) : null;
+}
+
 /** Mark a task as completed. */
 export async function markTaskCompleted(id: string): Promise<void> {
   await ensureTable();
@@ -270,9 +325,32 @@ export async function markTaskCompleted(id: string): Promise<void> {
   const now = Date.now();
   await client.execute({
     sql: `UPDATE integration_pending_tasks
-          SET status = ?, updated_at = ?, completed_at = ?
+          SET status = ?, updated_at = ?, completed_at = ?, payload = ?
           WHERE id = ?`,
-    args: ["completed", now, now, id],
+    // The payload can contain short-lived provider credentials such as a
+    // Discord interaction token. Once terminal, no retry needs the inbound
+    // body, so erase it instead of retaining secrets or user text indefinitely.
+    args: ["completed", now, now, "{}", id],
+  });
+}
+
+/**
+ * Return a transiently failed task to the retryable queue without erasing its
+ * payload. The payload may contain the only copy of the inbound message and is
+ * scrubbed only when the task reaches a permanent terminal state.
+ */
+export async function markTaskRetryable(
+  id: string,
+  errorMessage: string,
+): Promise<void> {
+  await ensureTable();
+  const client = getDbExec();
+  const now = Date.now();
+  await client.execute({
+    sql: `UPDATE integration_pending_tasks
+          SET status = ?, updated_at = ?, error_message = ?
+          WHERE id = ? AND status = 'processing'`,
+    args: ["pending", now, errorMessage.slice(0, 2000), id],
   });
 }
 
@@ -286,8 +364,8 @@ export async function markTaskFailed(
   const now = Date.now();
   await client.execute({
     sql: `UPDATE integration_pending_tasks
-          SET status = ?, updated_at = ?, error_message = ?
+          SET status = ?, updated_at = ?, error_message = ?, payload = ?
           WHERE id = ?`,
-    args: ["failed", now, errorMessage.slice(0, 2000), id],
+    args: ["failed", now, errorMessage.slice(0, 2000), "{}", id],
   });
 }