@agent-native/core 0.98.17 → 0.99.1

package/corpus/core/src/cli/skills.ts

@@ -11,6 +11,10 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
+import {
+  MCP_LEGACY_ROUTE_PREFIX,
+  MCP_PUBLIC_ROUTE_PREFIX,
+} from "../mcp/route-paths.js";
 import {
   buildAppSkillPack,
   ensureAppSkill,
@@ -72,7 +76,7 @@ export const BUILT_IN_APP_SKILLS = {
         "Create, search, select, and export brand image and video assets from the Assets app.",
       hosted: {
         url: "https://assets.agent-native.com",
-        mcpUrl: "https://assets.agent-native.com/_agent-native/mcp",
+        mcpUrl: "https://assets.agent-native.com/mcp",
       },
       mcp: { serverName: "agent-native-assets" },
       auth: {
@@ -118,7 +122,7 @@ export const BUILT_IN_APP_SKILLS = {
         "Edit docs, blogs, resources, and MDX content through the Content app, including repo-backed Local File Mode.",
       hosted: {
         url: "https://content.agent-native.com",
-        mcpUrl: "https://content.agent-native.com/_agent-native/mcp",
+        mcpUrl: "https://content.agent-native.com/mcp",
       },
       mcp: { serverName: "agent-native-content" },
       auth: {
@@ -170,7 +174,7 @@ export const BUILT_IN_APP_SKILLS = {
         "Explore, compare, iterate, and export interactive UI design prototypes from the Design app.",
       hosted: {
         url: "https://design.agent-native.com",
-        mcpUrl: "https://design.agent-native.com/_agent-native/mcp",
+        mcpUrl: "https://design.agent-native.com/mcp",
       },
       mcp: { serverName: "agent-native-design" },
       auth: {
@@ -247,7 +251,7 @@ export const BUILT_IN_APP_SKILLS = {
         "Create rich interactive visual plans, recaps, and repo-native visual docs with diagrams, file maps, annotated code and diffs, API/schema summaries, feedback, and HTML export.",
       hosted: {
         url: "https://plan.agent-native.com",
-        mcpUrl: "https://plan.agent-native.com/_agent-native/mcp",
+        mcpUrl: "https://plan.agent-native.com/mcp",
       },
       mcp: { serverName: "plan", aliases: ["agent-native-plans"] },
       auth: {
@@ -317,7 +321,7 @@ export const BUILT_IN_APP_SKILLS = {
         "Visualize local Codex and Claude Code context usage with warnings and optimization tips.",
       hosted: {
         url: "https://context-xray.agent-native.com",
-        mcpUrl: "https://context-xray.agent-native.com/_agent-native/mcp",
+        mcpUrl: "https://context-xray.agent-native.com/mcp",
       },
       mcp: { serverName: "agent-native-context-xray" },
       auth: { mode: "none" },
@@ -2771,8 +2775,11 @@ function preserveMcpUrlAppPathOverride(
     return target;
   }
   const trimmedPath = parsed.pathname.replace(/\/+$/, "");
-  const appPath = trimmedPath.endsWith("/_agent-native/mcp")
-    ? trimmedPath.slice(0, -"/_agent-native/mcp".length).replace(/\/+$/, "")
+  const mcpSuffix = [MCP_LEGACY_ROUTE_PREFIX, MCP_PUBLIC_ROUTE_PREFIX].find(
+    (suffix) => trimmedPath === suffix || trimmedPath.endsWith(suffix),
+  );
+  const appPath = mcpSuffix
+    ? trimmedPath.slice(0, -mcpSuffix.length).replace(/\/+$/, "")
     : trimmedPath;
   if (!appPath) return target;
   const url = `${parsed.origin}${appPath}`;
@@ -2782,7 +2789,7 @@ function preserveMcpUrlAppPathOverride(
       ...target.loaded,
       manifest: {
         ...target.loaded.manifest,
-        hosted: { url, mcpUrl: `${url}/_agent-native/mcp` },
+        hosted: { url, mcpUrl: `${url}${MCP_PUBLIC_ROUTE_PREFIX}` },
       },
     },
   };
@@ -2870,7 +2877,8 @@ async function runCommand(
 /**
  * Resolve a `--mcp-url` override into the `{ url, mcpUrl }` pair the manifest
  * expects. Accepts a bare origin (`https://x.ngrok-free.dev`) — appending the
- * standard `/_agent-native/mcp` path — or a full MCP URL already ending in it.
+ * standard `/mcp` path — or a full MCP URL already ending in `/mcp` or the
+ * legacy `/_agent-native/mcp` path.
  */
 function resolveMcpUrlOverride(input: string): { url: string; mcpUrl: string } {
   let parsed: URL;
@@ -2884,9 +2892,12 @@ function resolveMcpUrlOverride(input: string): { url: string; mcpUrl: string } {
   }
   const origin = parsed.origin;
   const trimmedPath = parsed.pathname.replace(/\/+$/, "");
-  const mcpUrl = trimmedPath.endsWith("/_agent-native/mcp")
-    ? `${origin}${trimmedPath}`
-    : `${origin}/_agent-native/mcp`;
+  const mcpSuffix = [MCP_LEGACY_ROUTE_PREFIX, MCP_PUBLIC_ROUTE_PREFIX].find(
+    (suffix) => trimmedPath === suffix || trimmedPath.endsWith(suffix),
+  );
+  const mcpUrl = mcpSuffix
+    ? `${origin}${trimmedPath.slice(0, -mcpSuffix.length)}${MCP_PUBLIC_ROUTE_PREFIX}`
+    : `${origin}${MCP_PUBLIC_ROUTE_PREFIX}`;
   return { url: origin, mcpUrl };
 }
 

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

@@ -646,6 +646,19 @@ function shouldDropBrowserSentryNoise(event: Sentry.Event): boolean {
     typeof event.tags?.url === "string" ? event.tags.url : undefined;
   const requestUrl = (event.request?.url ?? taggedUrl ?? "").toLowerCase();
   const isDocsPage = isAgentNativeDocsUrl(requestUrl);
+  // A server-owned run can emit an expected run_timeout while handing off to
+  // its continuation. AssistantChat retries these transitions automatically;
+  // only locally timed-out or ultimately unrecoverable runs should create a
+  // Sentry issue. Keep this scoped to the explicit chat tags so real provider
+  // and network timeout errors remain visible.
+  if (
+    event.tags?.context === "agent-native-chat" &&
+    event.tags?.errorCode === "run_timeout" &&
+    event.tags?.reconnectTimedOut === "false" &&
+    event.tags?.reconnectTerminalReason === "run_timeout"
+  ) {
+    return true;
+  }
   // rrweb 2.1.0 replays recorded media interactions with `void media.play()`.
   // Browsers may reject that promise when the recorded media was unmuted and
   // no user activation is still active, which becomes a source-less unhandled

package/corpus/core/src/client/resources/McpIntegrationDialog.tsx

@@ -447,6 +447,11 @@ export function McpIntegrationDialog({
             <div className="min-h-0 flex-1 overflow-y-auto px-7 py-5">
               <div className="space-y-3">
                 {renderScopeSelector()}
+                {selected?.setupNoteKey && (
+                  <div className="rounded-md border border-amber-500/20 bg-amber-500/5 px-3 py-2 text-[11px] leading-relaxed text-amber-700 dark:text-amber-300">
+                    {t(selected.setupNoteKey)}
+                  </div>
+                )}
                 {selected?.authMode === "oauth" && (
                   <div className="rounded-md border border-blue-500/20 bg-blue-500/5 px-3 py-2 text-[11px] leading-relaxed text-blue-700 dark:text-blue-300">
                     {t("mcpIntegrations.oauthNotice")}

package/corpus/core/src/client/resources/mcp-integration-catalog.ts

@@ -21,6 +21,7 @@ export interface DefaultMcpIntegration {
   url: string;
   authMode: McpIntegrationAuthMode;
   docsUrl?: string;
+  setupNoteKey?: string;
   headerPlaceholder?: string;
   keywords: string[];
 }
@@ -99,6 +100,22 @@ export const DEFAULT_MCP_INTEGRATIONS: DefaultMcpIntegration[] = [
     docsUrl: "https://www.builder.io/c/docs/fusion-connect-to-linear",
     keywords: ["issues", "tickets", "planning", "project management"],
   },
+  {
+    id: "atlassian",
+    name: "Atlassian",
+    provider: "atlassian",
+    description: "Read and write Jira issues and Confluence content.",
+    descriptionKey: "mcpIntegrations.catalog.atlassian.description",
+    useCase:
+      "project management, issue tracking, documentation, team collaboration",
+    useCaseKey: "mcpIntegrations.catalog.atlassian.useCase",
+    url: "https://mcp.atlassian.com/v1/mcp/authv2",
+    authMode: "oauth",
+    docsUrl:
+      "https://developer.atlassian.com/cloud/rovo-mcp/guides/getting-started/",
+    setupNoteKey: "mcpIntegrations.catalog.atlassian.setupNote",
+    keywords: ["atlassian", "jira", "confluence", "issues", "tickets"],
+  },
   {
     id: "supabase",
     name: "Supabase",

package/corpus/core/src/embedding/agent.ts

@@ -39,17 +39,19 @@ function trimEndpointPath(pathname: string, suffix: string): string | null {
   return normalized.slice(0, -suffix.length) || "/";
 }
 
+const MCP_PUBLIC_PATH = "/mcp";
+const MCP_LEGACY_PATH = "/_agent-native/mcp";
+
 export function getMcpUrl(
   url: string,
   options: AgentEndpointOptions = {},
 ): string {
   const parsed = appUrl(url, options);
-  const trimmed = trimEndpointPath(parsed.pathname, "/_agent-native/mcp");
-  if (trimmed !== null) {
-    parsed.pathname = `${trimmed.replace(/\/$/, "")}/_agent-native/mcp`;
-  } else {
-    parsed.pathname = `${parsed.pathname.replace(/\/$/, "")}/_agent-native/mcp`;
-  }
+  const trimmed =
+    trimEndpointPath(parsed.pathname, MCP_LEGACY_PATH) ??
+    trimEndpointPath(parsed.pathname, MCP_PUBLIC_PATH);
+  const basePath = (trimmed ?? parsed.pathname).replace(/\/$/, "");
+  parsed.pathname = `${basePath}${MCP_PUBLIC_PATH}`;
   parsed.search = "";
   parsed.hash = "";
   return parsed.toString();

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

@@ -620,6 +620,13 @@ const messages = {
         description: "Manage payments, subscriptions, and customers.",
         useCase: "Payments, subscriptions, invoicing, customer management",
       },
+      atlassian: {
+        description: "Read and write Jira issues and Confluence content.",
+        useCase:
+          "Project management, issue tracking, documentation, team collaboration",
+        setupNote:
+          "Your Atlassian organization admin may need to allow this app's domain and enable the required Rovo MCP permissions before OAuth can complete.",
+      },
     },
     auth: {
       none: "No auth",

package/corpus/core/src/mcp/ask-app-inline-tasks.ts

@@ -0,0 +1,125 @@
+/**
+ * Process-local fallback task tracker for `ask_app` (and the legacy
+ * `ask-agent` meta-tool) for the one case where no app origin is derivable
+ * from the MCP request — `selfA2AEndpointUrl(requestMeta)` returns null in
+ * `builtin-tools.ts`. Without an origin there is no `/_agent-native/a2a`
+ * endpoint to submit a durable task to, so `config.askAgent(message)` used
+ * to be awaited unbounded, which can hold a hosted MCP request open past a
+ * serverless gateway's inactivity timeout. This gives that path the same
+ * bounded "return a taskId, keep working in the background" contract as the
+ * durable A2A path, without needing a database.
+ *
+ * Entries are **process-local, not durable** — they live only in this
+ * server instance's memory and are lost on restart or if a different
+ * instance handles the poll. That is an acceptable trade-off here: this
+ * fallback only exists because no app origin was derivable in the first
+ * place, so there was never a reachable endpoint another instance could
+ * have polled anyway.
+ *
+ * Eviction is lazy (checked on each map access) instead of timer-based, so
+ * this stays serverless-safe — nothing keeps the process alive to sweep.
+ */
+
+type AskAppInlineTaskStatus = "working" | "completed" | "failed";
+
+interface AskAppInlineTaskEntry {
+  status: AskAppInlineTaskStatus;
+  response?: string;
+  error?: string;
+  createdAt: number;
+  settledAt?: number;
+}
+
+export interface AskAppInlineTaskSnapshot {
+  taskId: string;
+  status: AskAppInlineTaskStatus;
+  response?: string;
+  error?: string;
+}
+
+const SETTLED_TASK_TTL_MS = 10 * 60_000;
+const UNSETTLED_TASK_TTL_MS = 30 * 60_000;
+
+const inlineTasks = new Map<string, AskAppInlineTaskEntry>();
+
+function evictStaleInlineTasks(now: number): void {
+  for (const [taskId, entry] of inlineTasks) {
+    const ttlMs =
+      entry.settledAt != null ? SETTLED_TASK_TTL_MS : UNSETTLED_TASK_TTL_MS;
+    const anchor = entry.settledAt ?? entry.createdAt;
+    if (now - anchor > ttlMs) inlineTasks.delete(taskId);
+  }
+}
+
+function toSnapshot(
+  taskId: string,
+  entry: AskAppInlineTaskEntry,
+): AskAppInlineTaskSnapshot {
+  return {
+    taskId,
+    status: entry.status,
+    ...(entry.response !== undefined ? { response: entry.response } : {}),
+    ...(entry.error !== undefined ? { error: entry.error } : {}),
+  };
+}
+
+/**
+ * Start `askAgent(message)` under a fresh process-local taskId and wait up
+ * to `maxWaitMs` for it to settle. The map entry is written synchronously
+ * before the async work starts, so a poll racing this call can never see a
+ * missing taskId. Returns the settled snapshot when it finishes in time, or
+ * a `"working"` snapshot once `maxWaitMs` elapses — the caller can hand that
+ * taskId back to `getAskAppInlineTask` later to pick up the final result.
+ */
+export async function startAskAppInlineTask(
+  askAgent: (message: string) => Promise<string>,
+  message: string,
+  maxWaitMs: number,
+): Promise<AskAppInlineTaskSnapshot> {
+  const now = Date.now();
+  evictStaleInlineTasks(now);
+
+  const taskId = globalThis.crypto.randomUUID();
+  const entry: AskAppInlineTaskEntry = { status: "working", createdAt: now };
+  inlineTasks.set(taskId, entry);
+
+  const settled = askAgent(message).then(
+    (response) => {
+      entry.status = "completed";
+      entry.response = response;
+      entry.settledAt = Date.now();
+    },
+    (err) => {
+      entry.status = "failed";
+      entry.error =
+        err instanceof Error
+          ? err.message
+          : String(err ?? "ask_app task failed.");
+      entry.settledAt = Date.now();
+    },
+  );
+
+  if (maxWaitMs > 0) {
+    await Promise.race([
+      settled,
+      new Promise<void>((resolve) => setTimeout(resolve, maxWaitMs)),
+    ]);
+  }
+
+  return toSnapshot(taskId, entry);
+}
+
+/**
+ * Look up a process-local inline task started by `startAskAppInlineTask`.
+ * Returns `undefined` when the id is unknown — never started here, already
+ * evicted, or (in a multi-instance deployment) started on a different
+ * instance. Callers should fall through to the normal A2A HTTP status path
+ * in that case.
+ */
+export function getAskAppInlineTask(
+  taskId: string,
+): AskAppInlineTaskSnapshot | undefined {
+  evictStaleInlineTasks(Date.now());
+  const entry = inlineTasks.get(taskId);
+  return entry ? toSnapshot(taskId, entry) : undefined;
+}

package/corpus/core/src/mcp/build-server.ts

@@ -204,6 +204,35 @@ export interface MCPRequestMeta {
   inlineMcpApps?: boolean;
 }
 
+const ASK_AGENT_DEFAULT_INLINE_WAIT_MS = 20_000;
+const ASK_AGENT_MAX_INLINE_WAIT_MS = 25_000;
+
+function boundedAskAgentWaitMs(raw: unknown): number {
+  if (raw == null || raw === "") return ASK_AGENT_DEFAULT_INLINE_WAIT_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) return ASK_AGENT_DEFAULT_INLINE_WAIT_MS;
+  return Math.max(
+    0,
+    Math.min(ASK_AGENT_MAX_INLINE_WAIT_MS, Math.trunc(parsed)),
+  );
+}
+
+function isExplicitAsyncAskAgent(raw: unknown): boolean {
+  return raw === true || raw === "true" || raw === 1 || raw === "1";
+}
+
+function formatAskAgentResult(result: unknown): string {
+  if (typeof result === "string") return result;
+  if (result && typeof result === "object") {
+    const record = result as Record<string, unknown>;
+    if (record.status === "completed" && typeof record.response === "string") {
+      return record.response;
+    }
+  }
+  const serialized = JSON.stringify(result);
+  return serialized === undefined ? String(result) : serialized;
+}
+
 /**
  * Deploy-toggleable kill switch for inline MCP App embeds — the `ui://`
  * resource reference hosts like Codex / Cursor / ChatGPT render in a sandboxed
@@ -1618,7 +1647,9 @@ export async function createMCPServerForRequest(
           description:
             "Send a natural-language message to the app's AI agent and get a response. " +
             "Use this for complex, multi-step tasks that require the agent's reasoning " +
-            "and full context about the app.",
+            "and full context about the app. On hosted MCP, the server waits briefly " +
+            "for fast completions and returns a taskId plus ask_app_status polling " +
+            "instructions when the agent needs longer.",
           inputSchema: {
             type: "object" as const,
             properties: {
@@ -1626,6 +1657,16 @@ export async function createMCPServerForRequest(
                 type: "string",
                 description: "The message to send to the agent",
               },
+              async: {
+                type: "boolean",
+                description:
+                  "Start a durable task and return immediately with a taskId.",
+              },
+              maxWaitMs: {
+                type: "number",
+                description:
+                  "Maximum inline wait in milliseconds. Hosted MCP clamps this to 25000ms.",
+              },
             },
             required: ["message"],
           },
@@ -1668,8 +1709,29 @@ export async function createMCPServerForRequest(
         }
         const message = args?.message ?? "";
         try {
-          const result = await config.askAgent(message);
-          return { content: [{ type: "text", text: result }] };
+          // Keep the legacy meta-tool compatible for local callers, but use
+          // the same durable A2A submission path as ask_app whenever this is
+          // an HTTP/hosted request. A full agent loop must never be held open
+          // for minutes behind one MCP tools/call request. Always route
+          // through ask_app's own run() — even with no request origin, since
+          // it now bounds that case too via its process-local inline-task
+          // fallback (ask-app-inline-tasks.ts) instead of us awaiting
+          // config.askAgent() here unbounded. This is the shared helper: no
+          // second task map to keep in sync.
+          const hostedAskApp = getBuiltinCrossAppTools(
+            config,
+            requestMeta,
+          ).ask_app;
+          const result = await hostedAskApp.run({
+            message,
+            async: isExplicitAsyncAskAgent(args?.async),
+            maxWaitMs: isExplicitAsyncAskAgent(args?.async)
+              ? 0
+              : boundedAskAgentWaitMs(args?.maxWaitMs),
+          });
+          return {
+            content: [{ type: "text", text: formatAskAgentResult(result) }],
+          };
         } catch (err: any) {
           return {
             content: [{ type: "text", text: `Error: ${err.message}` }],