@agent-native/core 0.122.4 → 0.123.0

package/corpus/core/src/integrations/webhook-handler.ts

@@ -31,7 +31,10 @@ import {
   engineToProvider,
   type ActionEntry,
 } from "../agent/production-agent.js";
-import { appendDurableContinuationContext } from "../agent/run-loop-with-resume.js";
+import {
+  appendDurableContinuationContext,
+  runAgentLoopDirectWithSoftTimeout,
+} from "../agent/run-loop-with-resume.js";
 import { startRun, type ActiveRun } from "../agent/run-manager.js";
 import {
   buildCurrentTimeUserContext,
@@ -124,9 +127,17 @@ const INTEGRATION_CAMPAIGN_NO_PROGRESS_TIMEOUT_MS = 45_000;
  * the loop itself emits one when it hits an internal step budget. The run's
  * status is still "completed", so without this check a cut-off research request
  * is reported to the user as a model that answered with nothing.
+ *
+ * Only the LAST terminal event decides: an in-invocation resume that recovered
+ * from an earlier boundary goes on to emit `done`, and that run did finish.
  */
 function endedAtContinuationBoundary(run: ActiveRun): boolean {
-  return run.events.some((runEvent) => runEvent.event.type === "auto_continue");
+  for (let i = run.events.length - 1; i >= 0; i--) {
+    const event = run.events[i].event;
+    if (event.type === "auto_continue") return true;
+    if (event.type === "done" || event.type === "error") return false;
+  }
+  return false;
 }
 
 function continuationBoundaryReason(run: ActiveRun): ContinuationReason {
@@ -1273,38 +1284,50 @@ async function processIncomingMessage(
               modelCandidate,
             );
 
-            usage = await runAgentLoop({
-              engine,
-              model: resolvedModel,
-              systemPrompt: effectiveSystemPrompt,
-              tools,
-              availableTools,
-              messages,
-              actions: runnableActions,
-              send: async (event) => {
-                if (progress) {
-                  await Promise.resolve(progress.onEvent(event)).catch(
-                    () => {},
-                  );
-                }
-                await send(event);
+            // Wrapper, not raw `runAgentLoop`: an integration turn has no
+            // browser to re-POST a continuation, so a transport-level cut
+            // (gateway 45s, socket hang up, upstream 5xx) has to be resumed
+            // inside this invocation or the user's Slack thread just stops.
+            // Same budget the run-manager resolved for this run below.
+            usage = await runAgentLoopDirectWithSoftTimeout(
+              {
+                engine,
+                model: resolvedModel,
+                systemPrompt: effectiveSystemPrompt,
+                tools,
+                availableTools,
+                messages,
+                actions: runnableActions,
+                send: async (event) => {
+                  if (progress) {
+                    await Promise.resolve(progress.onEvent(event)).catch(
+                      () => {},
+                    );
+                  }
+                  await send(event);
+                },
+                signal,
+                threadId,
+                approvedToolCalls: incoming.approvedToolCalls,
+                // Messaging integrations are interactive chat surfaces. They
+                // need the same initial completion headroom as web chat so
+                // reasoning cannot consume the small per-engine default and
+                // leave a user-facing Slack reply empty.
+                maxOutputTokens: resolveMainChatMaxOutputTokens(resolvedModel),
+                // Explicitly resolve the normal chat default so an empty-final
+                // retry can step its reasoning effort down rather than
+                // repeatedly letting the engine choose Medium.
+                reasoningEffort: normalizeReasoningEffortForRequest(
+                  resolvedModel,
+                  undefined,
+                ),
               },
-              signal,
-              threadId,
-              approvedToolCalls: incoming.approvedToolCalls,
-              // Messaging integrations are interactive chat surfaces. They
-              // need the same initial completion headroom as web chat so
-              // reasoning cannot consume the small per-engine default and
-              // leave a user-facing Slack reply empty.
-              maxOutputTokens: resolveMainChatMaxOutputTokens(resolvedModel),
-              // Explicitly resolve the normal chat default so an empty-final
-              // retry can step its reasoning effort down rather than
-              // repeatedly letting the engine choose Medium.
-              reasoningEffort: normalizeReasoningEffortForRequest(
-                resolvedModel,
-                undefined,
-              ),
-            });
+              undefined,
+              {
+                useHostedDefault: true,
+                backgroundFunction: isInBackgroundFunctionRuntime(),
+              },
+            );
             return usage;
           },
         );

package/corpus/core/src/jobs/scheduler.ts

@@ -12,6 +12,7 @@ import {
   getOwnerActiveApiKey,
   type ActionEntry,
 } from "../agent/production-agent.js";
+import { runAgentLoopDirectWithSoftTimeout } from "../agent/run-loop-with-resume.js";
 import { startRun, resolveRunSoftTimeoutMs } from "../agent/run-manager.js";
 import { attachToolSearch } from "../agent/tool-search.js";
 import { createThread } from "../chat-threads/store.js";
@@ -427,11 +428,15 @@ async function isJobRunAsStillValid(
       return { ok: false, reason: `user "${jobUserEmail}" no longer exists` };
     }
     if (jobOrgId) {
-      const memberResult = await db.execute({
+      const { queryOrgMembers } = await import("../org/context.js");
+      // Shared reader so this and getOrgContext cannot disagree about what a
+      // failed org_members read means: null = tables absent on a brand-new
+      // install (nothing to validate against), throw = unreadable.
+      const memberRows = await queryOrgMembers({
         sql: `SELECT 1 FROM org_members WHERE org_id = ? AND LOWER(email) = LOWER(?) LIMIT 1`,
         args: [jobOrgId, jobUserEmail],
       });
-      if (!memberResult.rows || memberResult.rows.length === 0) {
+      if (memberRows && memberRows.length === 0) {
         return {
           ok: false,
           reason: `user "${jobUserEmail}" is no longer a member of org "${jobOrgId}"`,
@@ -440,20 +445,9 @@ async function isJobRunAsStillValid(
     }
     return { ok: true };
   } catch (err: any) {
-    // Tables may not exist on a brand-new install (no auth tables yet).
-    // Treat that as "valid" rather than blocking every job. The check is
-    // only meaningful once the auth tables exist.
-    const msg = err?.message?.toLowerCase() ?? "";
-    if (
-      msg.includes("does not exist") ||
-      msg.includes("no such table") ||
-      msg.includes("undefined table")
-    ) {
-      return { ok: true };
-    }
-    // Any other DB error: be conservative and let the job run rather than
-    // blocking on an unexpected failure mode (e.g. transient connection
-    // issue). We log so it's visible.
+    // Unreadable user/membership state: let the job run rather than blocking
+    // on a failure mode we cannot interpret (e.g. transient connection issue,
+    // or auth tables missing on a brand-new install). We log so it's visible.
     console.warn(
       `[recurring-jobs] User/membership validation failed for "${jobUserEmail}":`,
       err?.message,
@@ -462,6 +456,31 @@ async function isJobRunAsStillValid(
   }
 }
 
+/**
+ * A soft-timeout / no-progress checkpoint is a continuation boundary, not a
+ * finish — but `terminalStatusForEvent` maps `auto_continue` to status
+ * "completed". A scheduled job has no client to drive that continuation, so
+ * without this check a truncated half-answer is recorded as a success and
+ * shipped to the job's delivery target. Only the LAST terminal event decides:
+ * an earlier boundary the in-invocation resume already recovered from is
+ * followed by `done`, and that job really did finish.
+ */
+export function jobRunCutOffReason(run: {
+  events?: readonly { event: { type: string; reason?: string } }[];
+}): string | null {
+  const events = run.events ?? [];
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i].event;
+    if (event.type === "auto_continue") {
+      return event.reason === "run_timeout" || event.reason === "no_progress"
+        ? event.reason
+        : null;
+    }
+    if (event.type === "done" || event.type === "error") return null;
+  }
+  return null;
+}
+
 async function executeJob(
   resource: Resource,
   meta: JobFrontmatter,
@@ -623,8 +642,12 @@ async function executeJob(
             runId,
             thread.id,
             async (send, signal) => {
-              try {
-                jobUsageRef.current = await runAgentLoop({
+              // Wrapper, not raw `runAgentLoop`: a job has no browser to
+              // re-POST a continuation, so an interrupted transport (gateway
+              // 45s cut, socket hang up, upstream 5xx) has to be resumed
+              // inside this same invocation or the job is simply lost.
+              jobUsageRef.current = await runAgentLoopDirectWithSoftTimeout(
+                {
                   engine,
                   model,
                   systemPrompt,
@@ -635,10 +658,9 @@ async function executeJob(
                   send,
                   signal,
                   threadId: thread.id,
-                });
-              } catch (err) {
-                throw err;
-              }
+                },
+                softTimeoutMs,
+              );
             },
             // onComplete: run finished (completed or aborted)
             async (run) => {
@@ -646,7 +668,14 @@ async function executeJob(
                 clearTimeout(hardAbortTimer);
                 hardAbortTimer = null;
               }
-              if (run.status === "completed") {
+              const cutOffReason = jobRunCutOffReason(run);
+              if (cutOffReason) {
+                reject(
+                  new Error(
+                    `Job run was cut off before finishing (${cutOffReason})`,
+                  ),
+                );
+              } else if (run.status === "completed") {
                 responseText = collectFinalResponseTextFromAgentEvents(
                   (run.events ?? []).map((event) => event.event),
                 );
@@ -657,6 +686,11 @@ async function executeJob(
             },
             {
               softTimeoutMs,
+              // Without this the row is dispatch_mode NULL and the stale
+              // reaper applies RUN_STALE_MS (15s) — a window sized for a
+              // foreground run a browser is actively streaming. Nothing
+              // streams a job, so it gets reaped mid-flight.
+              dispatchMode: "background",
               // turnId defaults to runId — fine for single-turn jobs
             },
           );

package/corpus/core/src/localization/default-messages.ts

@@ -55,6 +55,15 @@ const messages = {
     profileSaveError: "Could not update profile",
     profileMenuItem: "Profile",
   },
+  secrets: {
+    scopeLabel: "Scope",
+    scopePersonal: "Personal",
+    scopeWorkspace: "Workspace",
+    scopePersonalDescription:
+      "Only your own signed-in sessions use this key. Integration, webhook, scheduled job, automation, and agent-to-agent runs sign in as their owner rather than as you, so they cannot read it.",
+    scopeWorkspaceDescription:
+      "Everyone in this workspace uses this key, including integration, webhook, scheduled job, automation, and agent-to-agent runs.",
+  },
   agentResources: {
     openDocs: "Open {{section}} documentation",
     backToResources: "Back to agent resources",
@@ -339,7 +348,6 @@ const messages = {
     addOwnKeys: "Add your own keys",
     configureProviderKeys: "Configure Anthropic, OpenAI, or another provider",
     checkingAiConnection: "Checking AI connection...",
-    connectionUnavailable: "Unable to check AI connection. Click to retry.",
     delegatedAgent: {
       asking: "Asking {{name}}...",
       asked: "Asked {{name}}",
@@ -745,6 +753,10 @@ const messages = {
     createOrgCardTitle: "Create an Organization",
     createOrgCardDescription:
       "Set up a team to collaborate with your colleagues.",
+    createOrgVaultNotice:
+      "Vault keys aren't shared between organizations. A new organization starts with an empty vault, so you'll need to add its own API keys and credentials before connected apps work.",
+    acceptInvitationOrgSwitchNotice:
+      "Joining makes {{name}} your active organization. Connected apps will switch to {{name}}'s vault keys, so anything using keys saved in your current organization may stop working until {{name}} has its own.",
     joinDomainOne:
       "An organization matching your email domain already exists. Join it to collaborate with your teammates.",
     joinDomainMany:
@@ -771,10 +783,20 @@ const messages = {
     remove: "Remove",
     save: "Save",
     loading: "Loading...",
+    dangerZone: "Danger zone",
+    deleteOrg: "Delete organization",
+    deleteOrgDescription:
+      "Permanently deletes this organization, its members, and its pending invitations. Data owned by the organization becomes inaccessible. This cannot be undone.",
+    deleteOrgConfirmPrompt: "Type {{name}} to confirm.",
+    deleteOrgConfirmPlaceholder: "Organization name",
+    deleteOrgConfirmCta: "Delete organization",
+    deleteOrgPending: "Deleting…",
   },
   integrations: {
     webhookUrl: "Webhook URL",
     copyWebhookUrl: "Copy webhook URL",
+    webhookUrlLocalOnly:
+      "{{platform}} can't call {{url}} — that address only exists on this machine. Deploy the app, or expose this server through an HTTPS tunnel, then open this page from the public address to get a webhook URL you can paste.",
     notConfigured:
       "Not configured. Set the required secrets to enable this integration.",
     enable: "Enable",

package/corpus/core/src/observability/evals.ts

@@ -128,14 +128,13 @@ function scoreErrorRecovery(
   runStatus: string,
 ): EvalResult {
   const hadErrors = summary.failedTools > 0;
-  let score: number;
-  if (!hadErrors) {
-    score = 1.0;
-  } else if (runStatus === "completed") {
-    score = 1.0;
-  } else {
-    score = 0;
-  }
+  // `truncated` scores 0 alongside errored/aborted: a turn that hit a budget or
+  // timeout boundary did not recover from its tool errors, it ran out of room.
+  // Before `truncated` existed those runs were stored as `completed` and scored
+  // a full 1.0, so this criterion's historical series has a discontinuity at the
+  // point that status was introduced.
+  const recovered = runStatus === "completed";
+  const score = !hadErrors || recovered ? 1.0 : 0;
   return makeEvalResult({
     ...fromSummary(summary),
     evalType: "automated",

package/corpus/core/src/observability/traces.ts

@@ -247,6 +247,7 @@ export async function instrumentAgentLoop(opts: {
     actions: Record<string, any>;
     send: (event: AgentChatEvent) => void;
     signal: AbortSignal;
+    onUsage?: (usage: AgentLoopUsage) => void;
     providerOptions?: any;
     runId?: string;
   }) => Promise<AgentLoopUsage>;
@@ -259,6 +260,7 @@ export async function instrumentAgentLoop(opts: {
     actions: Record<string, any>;
     send: (event: AgentChatEvent) => void;
     signal: AbortSignal;
+    onUsage?: (usage: AgentLoopUsage) => void;
     providerOptions?: any;
     runId?: string;
   };

package/corpus/core/src/org/accept-pending.ts

@@ -1,5 +1,5 @@
 import { getDbExec } from "../db/client.js";
-import { putUserSetting } from "../settings/user-settings.js";
+import { setActiveOrgId } from "./active-org.js";
 
 const nanoid = (): string =>
   globalThis.crypto?.randomUUID?.().replace(/-/g, "") ??
@@ -88,7 +88,7 @@ export async function acceptPendingInvitationsForEmail(
   const activeOrgId = accepted[0]?.orgId ?? null;
   if (activeOrgId) {
     try {
-      await putUserSetting(email, "active-org-id", { orgId: activeOrgId });
+      await setActiveOrgId(email, activeOrgId, "accepted pending invitation");
     } catch {
       // user_settings table might not exist in a minimal template — not fatal.
     }

package/corpus/core/src/org/active-org.ts

@@ -0,0 +1,73 @@
+import { warnAgent } from "../agent/action-warnings.js";
+import { getUserSetting, putUserSetting } from "../settings/user-settings.js";
+
+type ActiveOrgSetting = { orgId: string | null } | null;
+
+/**
+ * Every write to `active-org-id` goes through here, so no call site can move an
+ * account between organizations silently. Vault credentials are scoped per
+ * organization, so a repoint makes every key synced under the previous org
+ * unreadable for that account, and the only symptom is a missing-credential
+ * error naming the key. The UI notices (`org.createOrgVaultNotice`,
+ * `org.acceptInvitationOrgSwitchNotice`) only reach a human looking at the
+ * screen; roster and identity migrations run by an agent reach this setting with
+ * no notice anywhere in their path, so the warnings below go to `warnAgent` and
+ * surface in the conversation that ordered the repoint.
+ *
+ * Lives in its own module because `auto-join-domain` and `accept-pending` are
+ * imported by `context`, so hosting this in `context` would make the cycle.
+ */
+export async function setActiveOrgId(
+  email: string,
+  orgId: string | null,
+  reason: string,
+): Promise<void> {
+  await warnOnCrossOrgRepoint(email, orgId, reason);
+  await putUserSetting(email, "active-org-id", { orgId });
+}
+
+async function warnOnCrossOrgRepoint(
+  email: string,
+  nextOrgId: string | null,
+  reason: string,
+): Promise<void> {
+  if (!nextOrgId) return;
+
+  let previousOrgId: string | null;
+  try {
+    const setting = (await getUserSetting(
+      email,
+      "active-org-id",
+    )) as ActiveOrgSetting;
+    previousOrgId = typeof setting?.orgId === "string" ? setting.orgId : null;
+  } catch {
+    // "Unreadable" is not "had no previous org" — report which one happened, so
+    // a silent repoint can never read as a first-time assignment in the log.
+    warnAgent({
+      severity: "critical",
+      code: "org-active-org-previous-unreadable",
+      message:
+        `Could not read the previous active organization before ` +
+        `repointing an account to ${nextOrgId} (${reason}). If that account already ` +
+        `belonged to a different organization, every vault credential synced under ` +
+        `the old organization is now unreadable for it.`,
+    });
+    return;
+  }
+
+  if (!previousOrgId || previousOrgId === nextOrgId) return;
+
+  warnAgent({
+    severity: "critical",
+    code: "org-cross-org-repoint",
+    message:
+      `Repointed an account's active organization from ` +
+      `${previousOrgId} to ${nextOrgId} (${reason}). Vault credentials are scoped per ` +
+      `organization and are NOT shared between them: every API key synced under ` +
+      `${previousOrgId} is now unreadable for this account until it is re-saved in ` +
+      `${nextOrgId}. Requests will fail with missing-credential errors that name the ` +
+      `key rather than this organization change. If this came from a roster, identity, ` +
+      `or user-list migration, put the account back and add its members to the ` +
+      `EXISTING organization instead of a new one.`,
+  });
+}

package/corpus/core/src/org/auto-join-domain.ts

@@ -1,5 +1,6 @@
 import { getDbExec } from "../db/client.js";
-import { getUserSetting, putUserSetting } from "../settings/user-settings.js";
+import { getUserSetting } from "../settings/user-settings.js";
+import { setActiveOrgId } from "./active-org.js";
 
 const nanoid = (): string =>
   globalThis.crypto?.randomUUID?.().replace(/-/g, "") ??
@@ -103,7 +104,11 @@ export async function autoJoinDomainMatchingOrgs(
       const hasActive = Boolean(existing?.orgId);
       if (options.activateJoinedOrg === "always" || !hasActive) {
         activeOrgId = joined[0].orgId;
-        await putUserSetting(email, "active-org-id", { orgId: activeOrgId });
+        await setActiveOrgId(
+          email,
+          activeOrgId,
+          "auto-joined domain-matched org",
+        );
       }
     } catch {
       // settings table missing — not fatal.