@agent-native/core 0.92.11 → 0.93.0

package/corpus/core/src/client/RunStuckBanner.tsx

@@ -39,6 +39,19 @@ export interface RunStuckBannerProps {
    * itself only handles aborting the prior run.
    */
   onRetry?: (runId: string) => void;
+  /**
+   * Returns true when the run has a tool call or sub-agent (A2A) call that
+   * hasn't returned a result yet — typically backed by
+   * `chatHandle.hasInFlightWork()`. "No progress" for a stretch of time does
+   * not mean the run is dead: a long provider query or a cross-app `call
+   * agent` can legitimately emit nothing for minutes. When this returns
+   * true, Retry (which aborts the run) is hidden — aborting would destroy
+   * real in-flight work and re-execute the same long call from scratch.
+   * Only Cancel, an explicit destructive choice, remains available. Checked
+   * fresh on every render; omit to keep the unconditional Retry/Cancel
+   * behavior.
+   */
+  hasInFlightWork?: () => boolean;
   /**
    * Called whenever the stuck state transitions. Useful for surfacing
    * observability events (Sentry, PostHog) at the call site.
@@ -158,6 +171,7 @@ export function RunStuckBanner({
   onStuckStateChange,
   autoRetry = false,
   autoRetryOwnerId,
+  hasInFlightWork,
   className,
 }: RunStuckBannerProps) {
   const state = useRunStuckDetection({
@@ -175,6 +189,23 @@ export function RunStuckBanner({
   }
   const ownerId = autoRetryOwnerId ?? generatedOwnerIdRef.current;
   const backgroundWorkerStillAlive = isFreshBackgroundWorker(state);
+  // A live tool call or sub-agent (A2A) call means "no progress" is not the
+  // same as "dead" — the process is genuinely still doing the user's work.
+  // Retry aborts the run, so it must not be offered as the (implicitly
+  // safe-looking) primary action while real work is in flight; see the
+  // `hasInFlightWork` prop doc comment. Re-checked on every render (the
+  // underlying source mutates in place as tool/agent-call events stream in),
+  // which is why this is a function prop rather than a plain boolean.
+  //
+  // Two sources, combined disjunctively (either knowing = in flight): the
+  // SERVER-authoritative `state.hasInFlightWork` from /runs/active (the
+  // `in_flight_since` marker, correct even when the client's message list is
+  // stale after a reconnect/reader-mode replay) and the client-side proxy
+  // prop (unresolved tool-call parts in the local messages). Destroying live
+  // work is the failure we guard against, so we err toward "in flight" if
+  // either signal says so.
+  const inFlightWork =
+    state.hasInFlightWork === true || (hasInFlightWork?.() ?? false);
   // Server-continued runs are recovered by the SERVER (chained continuation
   // chunks + lost-handoff sweep); an automatic client abort would kill a live
   // server-chained run. Auto-retry is therefore disabled unconditionally for
@@ -229,6 +260,9 @@ export function RunStuckBanner({
       // comment on isServerContinuedDispatch above).
       isServerContinuedDispatch ||
       backgroundWorkerStillAlive ||
+      // A live tool/A2A call in flight — never auto-abort real work (see
+      // `inFlightWork` comment above).
+      inFlightWork ||
       !state.isStuck ||
       !state.runId ||
       busy.type !== "none" ||
@@ -264,6 +298,7 @@ export function RunStuckBanner({
     autoRetry,
     backgroundWorkerStillAlive,
     busy,
+    inFlightWork,
     isServerContinuedDispatch,
     onRetry,
     ownerId,
@@ -288,7 +323,10 @@ export function RunStuckBanner({
   };
 
   const handleRetry = async () => {
-    if (!state.runId || busy.type !== "none") return;
+    // Defense in depth: the button is hidden while `inFlightWork` is true
+    // (see render below), but guard the handler itself too so an abort can
+    // never be triggered against live work through this path.
+    if (!state.runId || busy.type !== "none" || inFlightWork) return;
     const runId = state.runId;
     setBusy({ type: "retry", runId });
     trackEvent("agent_chat_stuck_retry", {
@@ -305,6 +343,8 @@ export function RunStuckBanner({
   const stuckSeconds =
     state.stuckSinceMs != null ? Math.floor(state.stuckSinceMs / 1000) : null;
 
+  const stillWorking = backgroundWorkerStillAlive || inFlightWork;
+
   return (
     <div
       role="status"
@@ -322,41 +362,50 @@ export function RunStuckBanner({
       <div className="flex min-w-0 flex-1 flex-col gap-1.5">
         <div className="leading-snug">
           <span className="font-medium">
-            {backgroundWorkerStillAlive
+            {stillWorking
               ? "The agent is still working."
               : "This chat looks stuck."}
           </span>{" "}
           <span className="text-muted-foreground">
             No progress
             {stuckSeconds != null ? ` for ${stuckSeconds}s` : ""}.{" "}
-            {backgroundWorkerStillAlive
-              ? "The background worker is still alive; large updates can take a few minutes."
-              : "The agent may have hit a server timeout or lost its connection."}
+            {inFlightWork
+              ? "It's waiting on a call to another app or a long tool — canceling will stop that work."
+              : backgroundWorkerStillAlive
+                ? "The background worker is still alive; large updates can take a few minutes."
+                : "The agent may have hit a server timeout or lost its connection."}
             {autoRetry && busyType === "retry"
               ? " Retrying automatically now."
               : ""}
           </span>
         </div>
         <div className="flex flex-wrap items-center gap-2">
-          <button
-            type="button"
-            onClick={handleRetry}
-            disabled={busyType !== "none"}
-            className="inline-flex h-7 cursor-pointer items-center gap-1.5 rounded-md bg-foreground px-2.5 text-[11px] font-medium text-background transition-colors hover:bg-foreground/90 disabled:cursor-not-allowed disabled:opacity-60"
-          >
-            {busyType === "retry" ? (
-              <IconLoader2
-                size={12}
-                className="animate-spin"
-                aria-hidden="true"
-              />
-            ) : null}
-            Retry
-          </button>
+          {inFlightWork ? null : (
+            <button
+              type="button"
+              onClick={handleRetry}
+              disabled={busyType !== "none"}
+              className="inline-flex h-7 cursor-pointer items-center gap-1.5 rounded-md bg-foreground px-2.5 text-[11px] font-medium text-background transition-colors hover:bg-foreground/90 disabled:cursor-not-allowed disabled:opacity-60"
+            >
+              {busyType === "retry" ? (
+                <IconLoader2
+                  size={12}
+                  className="animate-spin"
+                  aria-hidden="true"
+                />
+              ) : null}
+              Retry
+            </button>
+          )}
           <button
             type="button"
             onClick={handleCancel}
             disabled={busyType !== "none"}
+            title={
+              inFlightWork
+                ? "Stop the in-progress run. Work that hasn't finished will be lost."
+                : undefined
+            }
             className="inline-flex h-7 cursor-pointer items-center gap-1.5 rounded-md border border-border bg-background px-2.5 text-[11px] font-medium text-foreground transition-colors hover:bg-accent disabled:cursor-not-allowed disabled:opacity-60"
           >
             {busyType === "cancel" ? (

package/corpus/core/src/client/agent-chat-adapter.ts

@@ -1,6 +1,10 @@
 import type { ChatModelAdapter, ChatModelRunResult } from "@assistant-ui/react";
 
 import { actionPreparationContinuationNote } from "../agent/action-continuation-guidance.js";
+import {
+  LLM_MISSING_CREDENTIALS_ERROR_CODE,
+  LLM_MISSING_CREDENTIALS_MESSAGE,
+} from "../agent/engine/credential-errors.js";
 import type {
   AgentChatStructuredContentPart,
   AgentChatStructuredMessage,
@@ -34,7 +38,9 @@ export type AgentChatSurfaceKind =
    */
   | "app"
   /** Chat rendered by the outer local dev frame, outside the app iframe. */
-  | "dev-frame";
+  | "dev-frame"
+  /** Chat hosted by Desktop for a local app with explicit code access. */
+  | "desktop";
 
 type AdapterHistoryMessage = {
   role: "user" | "assistant";
@@ -150,14 +156,36 @@ const BACKGROUND_FOLLOW_POLL_INTERVAL_MS = 1_000;
 // the 25s grace plus sweep/DB latency. This stays below the background
 // reconnect stuck threshold, but gives the server-owned recovery brain time to
 // surface the successor or terminal errored run before the client reports idle.
-const BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS = 150_000;
+//
+// THREE-SITE INVARIANT (keep in lockstep with run-store.ts and
+// agent-chat-plugin.ts — see `UNCLAIMED_BACKGROUND_RUN_FAST_SWEEP_MS`'s doc
+// comment in run-store.ts for the full derivation): a `chainServerDrivenContinuation`
+// deferral (server/production-agent.ts) leaves a successor row `running` with
+// no live worker until a sweep redispatches it. The budget is a derived
+// chain, each bound comfortably inside the next:
+//   UNCLAIMED_BACKGROUND_RUN_GRACE_MS            (25s)
+// + UNCLAIMED_BACKGROUND_RUN_FAST_SWEEP_MS       (20s)
+// = ~45-65s worst-case time-to-first-redispatch-attempt
+// < BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS            (150s, this constant)
+// < UNCLAIMED_BACKGROUND_RUN_REDISPATCH_BOUND_MS (300s, run-store.ts)
+// On top of that margin, the follow loop below never counts a tick against
+// this timeout at all while `/runs/active` reports `awaitingRedispatch:
+// true` — a server-authoritative "known deferred, recovery in progress"
+// signal, not a guess — so this timeout is a backstop for a genuinely lost
+// run, not the primary mechanism racing the sweep. Do NOT raise this value to
+// paper over a slow sweep; fix the sweep timing (run-store.ts /
+// agent-chat-plugin.ts) instead, and keep this comment's inequality chain
+// accurate if any of the four numbers change.
+export const BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS = 150_000;
 
 /**
  * User-facing copy for the server's background terminal reasons
  * (`agent_runs.terminal_reason`, surfaced by /runs/active). These runs died in
  * server-side handoff machinery where no richer error event may exist, so the
  * client owns the message. Keys are matched after stripping an optional
- * `error:` prefix (`terminalReasonForEvent` records `error:<code>`).
+ * `error:` prefix (`terminalReasonForEvent` records `error:<code>`). Keep this
+ * map scoped to terminal failures, including reasons that must override a
+ * mistakenly completed row.
  */
 const BACKGROUND_TERMINAL_REASON_MESSAGES: Record<string, string> = {
   background_worker_never_started:
@@ -166,6 +194,8 @@ const BACKGROUND_TERMINAL_REASON_MESSAGES: Record<string, string> = {
     "The agent's background worker could not hand off the next step of this run. Retry to continue from the preserved context.",
   dispatch_payload_missing:
     "The agent's background run lost its saved request data and could not continue. Retry to start a fresh run.",
+  missing_api_key: LLM_MISSING_CREDENTIALS_MESSAGE,
+  missing_credentials: LLM_MISSING_CREDENTIALS_MESSAGE,
   turn_continuation_budget_exhausted:
     "This request needed more automatic continuations than allowed and was stopped. Try breaking it into smaller steps.",
 };
@@ -1761,6 +1791,11 @@ export function createAgentChatAdapter(
         nextRunId: string,
         previousRunId: string | null,
       ) => {
+        if (previousRunId !== nextRunId) {
+          lastAutoContinueReason = null;
+          lastRecoverableRunError = null;
+          lastActivityTrail = [];
+        }
         const rememberedSeq = seenRunSeqs.get(nextRunId);
         if (rememberedSeq !== undefined) {
           lastSeq = rememberedSeq;
@@ -2132,6 +2167,9 @@ export function createAgentChatAdapter(
             ...(runId ? { runId } : {}),
           };
           if (typeof window !== "undefined") {
+            if (args.errorCode === LLM_MISSING_CREDENTIALS_ERROR_CODE) {
+              dispatchMissingApiKey();
+            }
             window.dispatchEvent(
               new CustomEvent("agent-chat:run-error", {
                 detail: { ...runError, tabId },
@@ -2169,7 +2207,46 @@ export function createAgentChatAdapter(
               : "";
           // terminal_reason is either a bare reason ("dispatch_payload_missing")
           // or "error:<errorCode>" when derived from a terminal error event.
+          const hasErrorTerminalReason = rawTerminalReason.startsWith("error:");
           const terminalReason = rawTerminalReason.replace(/^error:/, "");
+          const mappedMessage = terminalReason
+            ? BACKGROUND_TERMINAL_REASON_MESSAGES[terminalReason]
+            : undefined;
+          const mappedErrorCode =
+            terminalReason === "missing_api_key" ||
+            terminalReason === LLM_MISSING_CREDENTIALS_ERROR_CODE
+              ? LLM_MISSING_CREDENTIALS_ERROR_CODE
+              : terminalReason;
+
+          if (mappedMessage) {
+            yield* emitBackgroundTerminalError({
+              message: mappedMessage,
+              errorCode: mappedErrorCode,
+              details: `terminal_reason: ${rawTerminalReason}`,
+            });
+            return;
+          }
+
+          if (hasErrorTerminalReason) {
+            if (lastRecoverableRunError) {
+              yield* emitBackgroundTerminalError({
+                message: lastRecoverableRunError.message,
+                errorCode:
+                  lastRecoverableRunError.errorCode ||
+                  mappedErrorCode ||
+                  "background_run_failed",
+                details: lastRecoverableRunError.details,
+              });
+              return;
+            }
+            yield* emitBackgroundTerminalError({
+              message:
+                "The agent's background run failed before its final response could be recovered. You can retry from the preserved chat context.",
+              errorCode: mappedErrorCode || "background_run_failed",
+              details: `terminal_reason: ${rawTerminalReason}`,
+            });
+            return;
+          }
 
           if (status === "completed") {
             // The turn finished server-side; the events we managed to fold are
@@ -2186,17 +2263,6 @@ export function createAgentChatAdapter(
             return;
           }
 
-          const mappedMessage = terminalReason
-            ? BACKGROUND_TERMINAL_REASON_MESSAGES[terminalReason]
-            : undefined;
-          if (mappedMessage) {
-            yield* emitBackgroundTerminalError({
-              message: mappedMessage,
-              errorCode: terminalReason,
-              details: `terminal_reason: ${rawTerminalReason}`,
-            });
-            return;
-          }
           if (lastRecoverableRunError) {
             // A replayed terminal error event already carried the real
             // message (recoverable errors replay as auto-continue signals
@@ -2411,10 +2477,24 @@ export function createAgentChatAdapter(
               if (isTerminal) {
                 replayedTerminalRunIds.add(activeRunId);
               }
-              if (attach === "detached") {
+              // Server-authoritative "silently deferred, recovery in
+              // progress" signal (see `awaitingRedispatch` on
+              // `getActiveRunForThreadAsync`, run-manager.ts): a
+              // `chainServerDrivenContinuation` successor still inside
+              // `UNCLAIMED_BACKGROUND_RUN_REDISPATCH_BOUND_MS`, being
+              // redispatched by the server's fast/slow sweeps. This is known
+              // to demonstrably exist — same as a "detached" attach — so
+              // treat it identically and never accumulate idle time against
+              // it. Once the server's own bound is exceeded (or the row is
+              // claimed/terminal) this flips false and normal idle accounting
+              // resumes, so a truly stuck deferral still fails loud via the
+              // existing timeout below.
+              const awaitingRedispatch = active?.awaitingRedispatch === true;
+              if (attach === "detached" || awaitingRedispatch) {
                 // We really attached to a live stream (chunk boundary or
-                // transport blip) — the run demonstrably exists; keep
-                // following with a fresh idle window.
+                // transport blip), or the server told us recovery is
+                // in-flight — the run demonstrably exists; keep following
+                // with a fresh idle window.
                 idleSince = null;
               } else {
                 // "gone": /runs/active reported the run but its event stream
@@ -2859,7 +2939,20 @@ export function createAgentChatAdapter(
                     recoverable: true,
                     runId: activeRunId,
                   };
+                  // This is a terminal outcome for the attempted turn. Settle
+                  // both real in-flight calls and activity-only placeholders
+                  // before yielding the error; otherwise a prior "Preparing
+                  // run-code" event remains an unresolved tool card and the UI
+                  // keeps showing a spinner beside an already-terminal error.
+                  settleInterruptedToolCalls(content, undefined, {
+                    includeActivity: true,
+                  });
                   if (typeof window !== "undefined") {
+                    window.dispatchEvent(
+                      new CustomEvent("agent-chat:activity-clear", {
+                        detail: { tabId },
+                      }),
+                    );
                     window.dispatchEvent(
                       new CustomEvent("agent-chat:run-error", {
                         detail: { ...runError, tabId },

package/corpus/core/src/client/automation.ts

@@ -0,0 +1,22 @@
+import type { AutomationInvocationResult } from "../automation/index.js";
+import { callAction } from "./use-action.js";
+
+export interface InvokeConfiguredAutomationWorkflowInput {
+  readonly workflowId: string;
+  readonly input: Record<string, unknown>;
+  readonly idempotencyKey?: string;
+}
+
+/**
+ * Invoke an app-registered automation action without hand-writing a browser
+ * request. Apps may choose a custom action name when registering the runtime.
+ */
+export async function invokeConfiguredAutomationWorkflow(
+  input: InvokeConfiguredAutomationWorkflowInput,
+  options: { readonly actionName?: string } = {},
+): Promise<AutomationInvocationResult> {
+  return callAction<AutomationInvocationResult>(
+    options.actionName ?? "invoke-automation-workflow",
+    input,
+  );
+}

package/corpus/core/src/client/chat/run-recovery.tsx

@@ -10,7 +10,6 @@ import {
   IconX,
   IconChevronDown,
   IconExternalLink,
-  IconKey,
   IconGitFork,
   IconGauge,
   IconSettings,
@@ -318,8 +317,7 @@ export function ApiKeyConnect({ onConnected }: { onConnected?: () => void }) {
 
   return (
     <div className="rounded-md border border-border bg-background/60 p-3">
-      <div className="mb-2 flex items-center gap-1.5 text-[11px] font-medium text-foreground">
-        <IconKey size={12} strokeWidth={1.9} />
+      <div className="mb-2 text-[11px] font-medium text-foreground">
         Use your own API key
       </div>
       <p className="mb-2.5 text-[11px] leading-relaxed text-muted-foreground">
@@ -400,6 +398,71 @@ export function ApiKeyConnect({ onConnected }: { onConnected?: () => void }) {
 
 export type BuilderSetupCardLayout = "default" | "sidebar";
 
+export function BuilderSetupContent({
+  onConnected,
+  layout = "default",
+}: {
+  onConnected?: () => void;
+  layout?: BuilderSetupCardLayout;
+}) {
+  const [keyOpen, setKeyOpen] = useState(false);
+  const sidebarLayout = layout === "sidebar";
+
+  return (
+    <div
+      className={cn(
+        "agent-builder-setup-content",
+        sidebarLayout && "agent-builder-setup-card--sidebar",
+      )}
+    >
+      <div
+        className={cn(
+          "agent-builder-setup-card__content flex flex-col sm:flex-row sm:items-center sm:justify-between",
+          sidebarLayout ? "gap-2" : "gap-3",
+        )}
+      >
+        <div className="agent-builder-setup-card__copy min-w-0">
+          <h3 className="text-[13px] font-medium text-foreground">
+            Connect AI
+          </h3>
+          <p className="mt-0.5 text-[11px] leading-relaxed text-muted-foreground">
+            Use Builder.io (free credits), or add an Anthropic/OpenAI key.
+          </p>
+        </div>
+        <div
+          className={cn(
+            "agent-builder-setup-card__actions flex shrink-0",
+            sidebarLayout
+              ? "flex-col items-start gap-1 sm:items-center"
+              : "flex-nowrap items-center gap-2",
+          )}
+        >
+          <BuilderConnectCta variant="compact" onConnected={onConnected} />
+          <button
+            type="button"
+            onClick={() => setKeyOpen((open) => !open)}
+            className={cn(
+              "agent-builder-setup-card__key-button inline-flex shrink-0 items-center whitespace-nowrap rounded-md text-[11px] font-medium",
+              sidebarLayout
+                ? "h-7 border-0 bg-transparent px-0 text-muted-foreground hover:bg-transparent hover:text-foreground"
+                : "h-8 border border-border bg-background px-3 text-foreground hover:bg-accent",
+            )}
+            aria-expanded={keyOpen}
+          >
+            Use API key
+          </button>
+        </div>
+      </div>
+
+      {keyOpen ? (
+        <div className="mt-3">
+          <ApiKeyConnect onConnected={onConnected} />
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
 export function BuilderSetupCard({
   onConnected,
   bouncePulse,
@@ -411,9 +474,6 @@ export function BuilderSetupCard({
   fullWidth?: boolean;
   layout?: BuilderSetupCardLayout;
 }) {
-  // Progressive disclosure: the card leads with one-click Builder connect while
-  // keeping the bring-your-own-key path close by.
-  const [keyOpen, setKeyOpen] = useState(false);
   const sidebarLayout = layout === "sidebar";
 
   const cardRef = useRef<HTMLDivElement>(null);
@@ -448,50 +508,7 @@ export function BuilderSetupCard({
           sidebarLayout ? "p-2.5" : "p-3",
         )}
       >
-        <div
-          className={cn(
-            "agent-builder-setup-card__content flex flex-col sm:flex-row sm:items-center sm:justify-between",
-            sidebarLayout ? "gap-2" : "gap-3",
-          )}
-        >
-          <div className="agent-builder-setup-card__copy min-w-0">
-            <h3 className="text-[13px] font-medium text-foreground">
-              Connect AI
-            </h3>
-            <p className="mt-0.5 text-[11px] leading-relaxed text-muted-foreground">
-              Use Builder.io (free credits), or add an Anthropic/OpenAI key.
-            </p>
-          </div>
-          <div
-            className={cn(
-              "agent-builder-setup-card__actions flex shrink-0",
-              sidebarLayout
-                ? "flex-col items-start gap-1 sm:items-center"
-                : "flex-nowrap items-center gap-2",
-            )}
-          >
-            <BuilderConnectCta variant="compact" onConnected={onConnected} />
-            <button
-              type="button"
-              onClick={() => setKeyOpen((open) => !open)}
-              className={cn(
-                "agent-builder-setup-card__key-button inline-flex shrink-0 items-center whitespace-nowrap rounded-md text-[11px] font-medium",
-                sidebarLayout
-                  ? "h-7 border-0 bg-transparent px-0 text-muted-foreground hover:bg-transparent hover:text-foreground"
-                  : "h-8 border border-border bg-background px-3 text-foreground hover:bg-accent",
-              )}
-              aria-expanded={keyOpen}
-            >
-              Use API key
-            </button>
-          </div>
-        </div>
-
-        {keyOpen ? (
-          <div className="mt-3">
-            <ApiKeyConnect onConnected={onConnected} />
-          </div>
-        ) : null}
+        <BuilderSetupContent onConnected={onConnected} layout={layout} />
       </div>
     </div>
   );

package/corpus/core/src/client/composer/TiptapComposer.tsx

@@ -1677,6 +1677,14 @@ export function TiptapComposer({
     },
   });
 
+  // A tab can stay mounted while becoming the active composer later. Publish
+  // its existing draft when the host starts observing it so contextual UI is
+  // correct immediately after a tab switch, not only after the next keystroke.
+  useEffect(() => {
+    if (!editor || !onTextChange) return;
+    onTextChange(editor.state.doc.textContent.trim());
+  }, [editor, onTextChange]);
+
   const insertReference = useCallback(
     (ref: AgentComposerReference) => {
       const normalized = normalizeAgentComposerReference(ref);

package/corpus/core/src/client/index.ts

@@ -895,6 +895,36 @@ export {
   type ProviderReadinessBadgeProps,
   type SetupConnectionsPageProps,
 } from "./setup-connections/index.js";
+export {
+  listIntegrationEnvStatuses,
+  listIntegrationStatuses,
+  saveIntegrationEnvVars,
+  setIntegrationEnabled,
+  setupIntegration,
+  disconnectManagedIntegrationInstallation,
+  listManagedIntegrationInstallations,
+  managedIntegrationOAuthUrl,
+  managedSlackAgentManifestUrl,
+  listManagedIntegrationScopes,
+  saveManagedIntegrationScope,
+  listManagedIntegrationBudgets,
+  listManagedIntegrationMemory,
+  forgetManagedIntegrationMemory,
+  saveManagedIntegrationBudget,
+  testManagedIntegrationInstallation,
+  IntegrationClientError,
+  type ClientIntegrationInstallation,
+  type ClientIntegrationScope,
+  type ClientIntegrationUsageBudget,
+  type ClientIntegrationMemory,
+  type ClientIntegrationStatus,
+  type IntegrationEnvStatus,
+  type SavedEnvVarsResult,
+} from "./integrations/index.js";
+export {
+  invokeConfiguredAutomationWorkflow,
+  type InvokeConfiguredAutomationWorkflowInput,
+} from "./automation.js";
 export {
   ChangelogDialog,
   ChangelogSettingsCard,