@agent-native/core 0.106.3 → 0.107.1

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

@@ -38,7 +38,9 @@ import React, {
 import type { ReasoningEffort } from "../shared/reasoning-effort.js";
 import {
   ACTIVE_RUN_STATE_EVENT,
+  clearPendingTurnIfMatches,
   clearActiveRunIfMatches,
+  getPendingTurn,
   getActiveRunActivityTool,
   getActiveRun,
   resolveReconnectAfterSeq,
@@ -172,6 +174,7 @@ import {
   useGuidedQuestionFlow,
 } from "./guided-questions.js";
 import { useT } from "./i18n.js";
+import { McpConnectionSuggestion } from "./resources/McpConnectionSuggestion.js";
 import {
   AgentAutoContinueSignal,
   type ContentPart,
@@ -2239,6 +2242,14 @@ const AssistantChatInner = forwardRef<
   // (unsupported format, size cap, body-size rejection, drop errors).
   // Cleared on the next message send.
   const [composerError, setComposerError] = useState<string | null>(null);
+  const [composerText, setComposerText] = useState("");
+  const handleComposerTextChange = useCallback(
+    (text: string) => {
+      setComposerText(text);
+      onComposerTextChange?.(text);
+    },
+    [onComposerTextChange],
+  );
   const dropDepthRef = useRef(0);
   const handleChatDragEnter = useCallback((e: React.DragEvent) => {
     if (!Array.from(e.dataTransfer?.types ?? []).includes("Files")) return;
@@ -4272,6 +4283,7 @@ const AssistantChatInner = forwardRef<
       }
       const activeRun = getActiveRun();
       const runIdToAbort = reconnectRunIdRef.current ?? activeRun?.runId;
+      const pendingTurn = threadId ? getPendingTurn(threadId) : null;
       userStoppedRunRef.current = {
         at: Date.now(),
         ...(runIdToAbort ? { runId: runIdToAbort } : {}),
@@ -4283,6 +4295,16 @@ const AssistantChatInner = forwardRef<
         fetch(`${apiUrl}/runs/${encodeURIComponent(runIdToAbort)}/abort`, {
           method: "POST",
         }).catch(() => {});
+      } else if (pendingTurn && threadId) {
+        clearPendingTurnIfMatches(threadId, pendingTurn.turnId);
+        fetch(
+          `${apiUrl}/runs/turn/${encodeURIComponent(pendingTurn.turnId)}/abort`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ threadId }),
+          },
+        ).catch(() => {});
       }
       if (isReconnecting) {
         reconnectAbortRef.current?.abort();
@@ -5382,6 +5404,9 @@ const AssistantChatInner = forwardRef<
                 </MessageScrollerProvider>
 
                 {showComposerSlot ? composerSlot : null}
+                {isActiveComposer && (
+                  <McpConnectionSuggestion text={composerText} />
+                )}
                 {showCenteredEmptyThreadFooterSlot ? (
                   <div className="agent-thread-footer-slot agent-thread-footer-slot--centered-empty">
                     {resolvedThreadFooterSlot}
@@ -5488,7 +5513,7 @@ const AssistantChatInner = forwardRef<
                             focusRef={tiptapRef}
                             onTextChange={
                               isActiveComposer
-                                ? onComposerTextChange
+                                ? handleComposerTextChange
                                 : undefined
                             }
                             disabled={isComposerDisabled}

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

@@ -72,6 +72,11 @@ export function openAgentSettings(
   const normalizedSection =
     typeof section === "string" ? section : section?.section;
 
+  const secretHash = normalizedSection?.replace(/^#/, "");
+  if (secretHash?.toLowerCase().startsWith("secrets:")) {
+    window.location.hash = `#${secretHash}`;
+  }
+
   openAgentSidebar();
   // Voice mode unmounts the chat surface while its dock is collapsed, so its
   // settings listener does not exist until opening the sidebar remounts it.

package/corpus/core/src/client/active-run-state.ts

@@ -1,4 +1,5 @@
 const STORAGE_KEY = "agent-chat-active-run";
+const PENDING_TURN_STORAGE_KEY = "agent-chat-pending-turn";
 export const ACTIVE_RUN_STATE_EVENT = "agent-chat:active-run-state-change";
 
 export interface ActiveRunState {
@@ -8,6 +9,11 @@ export interface ActiveRunState {
   activityTool?: string | null;
 }
 
+export interface PendingTurnState {
+  threadId: string;
+  turnId: string;
+}
+
 function notifyActiveRunStateChanged(state: ActiveRunState | null): void {
   if (
     typeof window === "undefined" ||
@@ -88,6 +94,34 @@ export function clearActiveRunIfMatches(threadId: string, runId: string): void {
   clearActiveRun();
 }
 
+export function setPendingTurn(state: PendingTurnState): void {
+  try {
+    sessionStorage.setItem(PENDING_TURN_STORAGE_KEY, JSON.stringify(state));
+  } catch {}
+}
+
+export function getPendingTurn(threadId: string): PendingTurnState | null {
+  try {
+    const raw = sessionStorage.getItem(PENDING_TURN_STORAGE_KEY);
+    if (!raw) return null;
+    const state = JSON.parse(raw) as PendingTurnState;
+    return state.threadId === threadId && state.turnId ? state : null;
+  } catch {
+    return null;
+  }
+}
+
+export function clearPendingTurnIfMatches(
+  threadId: string,
+  turnId?: string,
+): void {
+  const state = getPendingTurn(threadId);
+  if (!state || (turnId && state.turnId !== turnId)) return;
+  try {
+    sessionStorage.removeItem(PENDING_TURN_STORAGE_KEY);
+  } catch {}
+}
+
 /** Resume reconnect SSE after the last seen event (0 = replay from the start). */
 export function resolveReconnectAfterSeq(
   threadId: string,

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

@@ -11,9 +11,11 @@ import type {
 } from "../agent/types.js";
 import type { ReasoningEffort } from "../shared/reasoning-effort.js";
 import {
+  clearPendingTurnIfMatches,
   setActiveRun,
   updateActiveRunSeq,
   clearActiveRun,
+  setPendingTurn,
 } from "./active-run-state.js";
 import { captureError } from "./analytics.js";
 import { agentNativePath } from "./api-path.js";
@@ -1634,6 +1636,7 @@ export function createAgentChatAdapter(
       const content: ContentPart[] = [];
       const toolCallCounter = { value: 0 };
       const turnId = generateTurnId();
+      if (threadId) setPendingTurn({ threadId, turnId });
       let runId: string | null = null;
       let lastSeq = -1;
       const seenRunSeqs = new Map<string, number>();
@@ -3279,6 +3282,7 @@ export function createAgentChatAdapter(
               attemptedRunIds.push(runId);
             }
             if (runId && threadId) {
+              clearPendingTurnIfMatches(threadId, turnId);
               setActiveRun({ threadId, runId, lastSeq: -1 });
             }
 

package/corpus/core/src/client/chat/message-components.tsx

@@ -62,6 +62,7 @@ import {
 import { isPastedTextAttachmentName } from "../composer/pasted-text.js";
 import { PastedTextChip } from "../composer/PastedTextChip.js";
 import { ThumbsFeedback } from "../observability/ThumbsFeedback.js";
+import { McpConnectionSuggestion } from "../resources/McpConnectionSuggestion.js";
 import type { ContentPart } from "../sse-event-processor.js";
 import { cn } from "../utils.js";
 import {
@@ -819,6 +820,37 @@ function assistantMessageStatusIsTerminal(message: {
   return statusType === "complete" || statusType === "incomplete";
 }
 
+function messageTextFromContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .flatMap((part) => {
+      if (!part || typeof part !== "object") return [];
+      const record = part as {
+        type?: unknown;
+        text?: unknown;
+        result?: unknown;
+      };
+      const values: string[] = [];
+      if (typeof record.text === "string") values.push(record.text);
+      if (record.type === "tool-call" && typeof record.result === "string") {
+        values.push(record.result);
+      }
+      return values;
+    })
+    .join("\n");
+}
+
+function latestUserMessageText(messages: readonly unknown[]): string {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!message || typeof message !== "object") continue;
+    const record = message as { role?: unknown; content?: unknown };
+    if (record.role === "user") return messageTextFromContent(record.content);
+  }
+  return "";
+}
+
 export function assistantMessageHasUnresolvedTool(content: unknown): boolean {
   if (!Array.isArray(content)) return false;
   return content.some((part): boolean => {
@@ -946,6 +978,8 @@ export function AssistantMessage() {
     thread.messages[thread.messages.length - 1].id === msg.id;
   const hasRenderableContent = assistantMessageHasRenderableContent(msg);
   const hasUnresolvedTool = assistantMessageHasUnresolvedTool(msg.content);
+  const responseConnectionText = messageTextFromContent(msg.content);
+  const responseConnectionContext = latestUserMessageText(thread.messages);
   const isComplete = shouldShowAssistantMessageFooter({
     isLast,
     chatRunning,
@@ -1104,6 +1138,13 @@ export function AssistantMessage() {
         {isComplete && hasCodeAgentTools && msgContent && (
           <FilesChangedSummary parts={msgContent} />
         )}
+        {isComplete && isLast && (
+          <McpConnectionSuggestion
+            text={responseConnectionText}
+            contextText={responseConnectionContext}
+            variant="response"
+          />
+        )}
         {isLast && hasUnresolvedTool && !chatRunning && (
           <RunningActivityStatus label="Thinking" />
         )}

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

@@ -110,6 +110,28 @@ export function canSubmitComposerContent(options: {
   );
 }
 
+const VOICE_TERMINAL_PUNCTUATION = /[.!?…。！？:;](?:["'”’»)\]}]*)$/;
+
+export function formatVoiceTranscriptForComposer(text: string): string {
+  const trimmed = text.trim();
+  if (!trimmed) return "";
+  return `${trimmed}${VOICE_TERMINAL_PUNCTUATION.test(trimmed) ? "" : "."} `;
+}
+
+export function canRemoveVoicePreview(options: {
+  documentSize: number;
+  anchor: number;
+  previewText: string;
+  currentText: string;
+}): boolean {
+  if (!options.previewText) return false;
+  if (options.anchor < 1) return false;
+  if (options.anchor + options.previewText.length > options.documentSize) {
+    return false;
+  }
+  return options.currentText === options.previewText;
+}
+
 export function resolveComposerPrimaryAction(options: {
   canSubmit: boolean;
   hasStopButton: boolean;
@@ -2082,15 +2104,16 @@ export function TiptapComposer({
     (text: string) => {
       const ed = editor;
       if (!isComposerEditorUsable(ed)) return;
+      const formattedText = formatVoiceTranscriptForComposer(text);
 
       const anchor = voiceAnchorRef.current;
       if (anchor != null) {
         const prevLen = prevVoiceInsertRef.current.length;
-        if (text) {
+        if (formattedText) {
           ed.chain()
             .focus()
             .deleteRange({ from: anchor, to: anchor + prevLen })
-            .insertContentAt(anchor, text + " ")
+            .insertContentAt(anchor, formattedText)
             .run();
         } else if (prevLen > 0) {
           ed.chain()
@@ -2099,14 +2122,14 @@ export function TiptapComposer({
         }
         voiceAnchorRef.current = null;
         prevVoiceInsertRef.current = "";
-      } else if (text) {
+      } else if (formattedText) {
         const { from } = ed.state.selection;
         const prevChar =
           from > 1 ? ed.state.doc.textBetween(from - 1, from) : "";
         const needsLead = prevChar && !/\s/.test(prevChar);
         ed.chain()
           .focus()
-          .insertContent((needsLead ? " " : "") + text + " ")
+          .insertContent((needsLead ? " " : "") + formattedText)
           .run();
       }
     },
@@ -2172,10 +2195,24 @@ export function TiptapComposer({
       const anchor = voiceAnchorRef.current;
       const prevLen = prevVoiceInsertRef.current.length;
       if (isComposerEditorUsable(editor) && prevLen > 0) {
-        editor
-          .chain()
-          .deleteRange({ from: anchor, to: anchor + prevLen })
-          .run();
+        const documentSize = editor.state.doc.content.size;
+        const currentText =
+          anchor >= 1 && anchor + prevLen <= documentSize
+            ? editor.state.doc.textBetween(anchor, anchor + prevLen, "", "\n")
+            : "";
+        if (
+          canRemoveVoicePreview({
+            documentSize,
+            anchor,
+            previewText: prevVoiceInsertRef.current,
+            currentText,
+          })
+        ) {
+          editor
+            .chain()
+            .deleteRange({ from: anchor, to: anchor + prevLen })
+            .run();
+        }
       }
       voiceAnchorRef.current = null;
       prevVoiceInsertRef.current = "";

package/corpus/core/src/client/integrations/IntegrationsPanel.tsx

@@ -14,6 +14,7 @@ import {
 } from "@tabler/icons-react";
 import React, { useState, useCallback, useEffect } from "react";
 
+import { AgentAskPopover } from "../AgentAskPopover.js";
 import { agentNativePath } from "../api-path.js";
 import {
   Tooltip,
@@ -511,6 +512,14 @@ export function IntegrationsPanel() {
         <div className="text-[10px] font-medium text-muted-foreground mb-1.5">
           {t("integrations.addChatIntegration")}
         </div>
+        <AgentAskPopover
+          label={t("integrations.addSomething")}
+          title={t("integrations.addSomethingTitle")}
+          placeholder={t("integrations.addSomethingPlaceholder")}
+          prompt=""
+          context="The user wants to add a chat or workspace integration that is not in the current directory. Research the provider's official OAuth or MCP setup, explain any app registration or allowlist requirements, and add a reusable integration preset when it is supported. Never ask the user to paste credentials into a prompt."
+          className="mb-2 h-7 w-full justify-center border-dashed px-2 text-[10px]"
+        />
         <AddIntegrationPicker
           connectedIds={connectedIds}
           onSelect={(p) => {
@@ -533,17 +542,27 @@ export function IntegrationsPanel() {
             {t("integrations.chatIntegrationsDescription")}
           </div>
         </div>
-        <Tooltip>
-          <TooltipTrigger asChild>
-            <button
-              onClick={() => setShowPicker(true)}
-              className="flex h-5 w-5 items-center justify-center rounded text-muted-foreground hover:text-foreground hover:bg-accent/50"
-            >
-              <IconPlus size={12} />
-            </button>
-          </TooltipTrigger>
-          <TooltipContent>{t("integrations.addIntegration")}</TooltipContent>
-        </Tooltip>
+        <div className="flex items-center gap-1">
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <button
+                onClick={() => setShowPicker(true)}
+                className="flex h-5 w-5 items-center justify-center rounded text-muted-foreground hover:bg-accent/50 hover:text-foreground"
+              >
+                <IconPlus size={12} />
+              </button>
+            </TooltipTrigger>
+            <TooltipContent>{t("integrations.addIntegration")}</TooltipContent>
+          </Tooltip>
+          <AgentAskPopover
+            label={t("integrations.addSomething")}
+            title={t("integrations.addSomethingTitle")}
+            placeholder={t("integrations.addSomethingPlaceholder")}
+            prompt=""
+            context="The user wants to add a chat or workspace integration that is not in the current directory. Research the provider's official OAuth or MCP setup, explain any app registration or allowlist requirements, and add a reusable integration preset when it is supported. Never ask the user to paste credentials into a prompt."
+            className="h-7 px-2 text-[10px]"
+          />
+        </div>
       </div>
 
       {loading ? (

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

@@ -0,0 +1,270 @@
+import {
+  IconArrowUpRight,
+  IconLoader2,
+  IconPlugConnected,
+  IconX,
+} from "@tabler/icons-react";
+import { useEffect, useMemo, useState } from "react";
+
+import { agentNativePath } from "../api-path.js";
+import { openAgentSettings } from "../CommandMenu.js";
+import { useT } from "../i18n.js";
+import {
+  buildMcpOAuthStartUrl,
+  findMcpIntegrationForText,
+  getMcpIntegrationApiFallback,
+  getDefaultMcpIntegrations,
+  isMcpConnectionFailureText,
+  type DefaultMcpIntegration,
+} from "./mcp-integration-catalog.js";
+import { McpIntegrationDialog } from "./McpIntegrationDialog.js";
+import {
+  useCreateMcpServer,
+  useMcpServers,
+  type McpServer,
+} from "./use-mcp-servers.js";
+
+export type McpConnectionSuggestionVariant = "composer" | "response";
+
+interface McpConnectionSuggestionProps {
+  text: string;
+  contextText?: string;
+  variant?: McpConnectionSuggestionVariant;
+}
+
+function compareUrl(value: string): string {
+  try {
+    const url = new URL(value.trim());
+    url.hash = "";
+    return url.toString().replace(/\/+$/, "");
+  } catch {
+    return value.trim().replace(/\/+$/, "");
+  }
+}
+
+function isConnected(
+  integration: DefaultMcpIntegration,
+  servers: McpServer[],
+): boolean {
+  const targetUrl = compareUrl(integration.url);
+  return servers.some(
+    (server) =>
+      server.status.state === "connected" &&
+      compareUrl(server.url) === targetUrl,
+  );
+}
+
+function returnUrl(): string {
+  if (typeof window === "undefined") return "/";
+  return (
+    window.location.pathname + window.location.search + window.location.hash
+  );
+}
+
+function canStartOAuth(integration: DefaultMcpIntegration): boolean {
+  return (
+    integration.authMode === "oauth" &&
+    integration.connectionMode === "oauth" &&
+    integration.availability === "ready"
+  );
+}
+
+function hasApiFallback(
+  apiFallback: DefaultMcpIntegration["apiFallback"] | null,
+): boolean {
+  return Boolean(apiFallback);
+}
+
+export function McpConnectionSuggestion({
+  text,
+  contextText = "",
+  variant = "composer",
+}: McpConnectionSuggestionProps) {
+  const t = useT();
+  const mcpServersQuery = useMcpServers();
+  const createMcpServer = useCreateMcpServer();
+  const [dialogOpen, setDialogOpen] = useState(false);
+  const [dismissedId, setDismissedId] = useState<string | null>(null);
+  const [connecting, setConnecting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const integrations = useMemo(() => getDefaultMcpIntegrations(), []);
+  const textIntegration = useMemo(
+    () => findMcpIntegrationForText(text, integrations),
+    [integrations, text],
+  );
+  const contextIntegration = useMemo(
+    () =>
+      contextText ? findMcpIntegrationForText(contextText, integrations) : null,
+    [contextText, integrations],
+  );
+  const integration =
+    variant === "response" &&
+    textIntegration &&
+    contextIntegration &&
+    textIntegration.id !== contextIntegration.id
+      ? null
+      : (textIntegration ?? contextIntegration);
+  const apiFallback = integration
+    ? getMcpIntegrationApiFallback(integration)
+    : null;
+  const servers = useMemo(
+    () => [
+      ...(mcpServersQuery.data?.user ?? []),
+      ...(mcpServersQuery.data?.org ?? []),
+    ],
+    [mcpServersQuery.data],
+  );
+  const connected = integration ? isConnected(integration, servers) : false;
+  const shouldSuggest =
+    mcpServersQuery.isSuccess &&
+    integration &&
+    !connected &&
+    dismissedId !== integration.id &&
+    (variant === "composer" || isMcpConnectionFailureText(text));
+
+  useEffect(() => {
+    setError(null);
+    setConnecting(false);
+  }, [integration?.id, variant]);
+
+  if (!shouldSuggest) return null;
+
+  const connect = async () => {
+    if (!integration || connecting) return;
+    setError(null);
+
+    if (apiFallback) {
+      openAgentSettings(`secrets:${apiFallback.secretKey}`);
+      return;
+    }
+
+    if (canStartOAuth(integration)) {
+      window.location.assign(
+        agentNativePath(
+          buildMcpOAuthStartUrl({
+            name: integration.name,
+            url: integration.url,
+            description: integration.description,
+            scope: "user",
+            returnUrl: returnUrl(),
+          }),
+        ),
+      );
+      return;
+    }
+
+    if (
+      integration.authMode === "none" &&
+      integration.connectionMode === "direct"
+    ) {
+      setConnecting(true);
+      try {
+        await createMcpServer.mutateAsync({
+          scope: "user",
+          name: integration.name,
+          url: integration.url,
+          description: integration.description,
+        });
+        setDismissedId(integration.id);
+      } catch (cause) {
+        setError(
+          cause instanceof Error ? cause.message : t("mcpIntegrations.failed"),
+        );
+      } finally {
+        setConnecting(false);
+      }
+      return;
+    }
+
+    setDialogOpen(true);
+  };
+
+  const actionLabel = hasApiFallback(apiFallback)
+    ? t("mcpIntegrations.useApiToken")
+    : canStartOAuth(integration)
+      ? t("mcpIntegrations.connectWithOAuth")
+      : integration.availability === "client-restricted" ||
+          integration.availability === "provider-setup"
+        ? t("mcpIntegrations.viewSetup")
+        : t("mcpIntegrations.connect");
+
+  return (
+    <>
+      <div
+        className={
+          variant === "response"
+            ? "mt-3 flex max-w-[520px] items-center gap-2 rounded-lg border border-primary/20 bg-primary/5 px-3 py-2 text-[12px]"
+            : "mx-auto mb-2 flex w-[min(100%,680px)] items-center gap-2 rounded-lg border border-primary/20 bg-primary/5 px-3 py-2 text-[12px]"
+        }
+        data-mcp-connection-suggestion={integration.id}
+      >
+        <div className="relative flex h-6 w-6 shrink-0 items-center justify-center overflow-hidden rounded-md border border-border bg-background text-[10px] font-semibold text-muted-foreground">
+          <span aria-hidden="true">{integration.name.slice(0, 1)}</span>
+          {integration.logoUrl && (
+            <img
+              src={integration.logoUrl}
+              alt=""
+              className="absolute h-5 w-5 object-contain"
+              onError={(event) => {
+                event.currentTarget.hidden = true;
+              }}
+            />
+          )}
+        </div>
+        <span className="min-w-0 flex-1 leading-snug text-foreground">
+          {t(
+            hasApiFallback(apiFallback)
+              ? "mcpIntegrations.connectSuggestionWithApiToken"
+              : "mcpIntegrations.connectSuggestion",
+            { name: integration.name },
+          )}
+        </span>
+        <button
+          type="button"
+          onClick={() => void connect()}
+          disabled={connecting}
+          className="inline-flex shrink-0 items-center gap-1 rounded-md bg-primary px-2.5 py-1.5 text-[11px] font-medium text-primary-foreground hover:bg-primary/90 disabled:pointer-events-none disabled:opacity-60"
+        >
+          {connecting && <IconLoader2 className="h-3 w-3 animate-spin" />}
+          {!connecting &&
+            canStartOAuth(integration) &&
+            !hasApiFallback(apiFallback) && (
+              <IconPlugConnected className="h-3 w-3" />
+            )}
+          {!connecting && hasApiFallback(apiFallback) && (
+            <IconPlugConnected className="h-3 w-3" />
+          )}
+          {actionLabel}
+          {!connecting &&
+            !canStartOAuth(integration) &&
+            !hasApiFallback(apiFallback) && (
+              <IconArrowUpRight className="h-3 w-3" />
+            )}
+        </button>
+        <button
+          type="button"
+          onClick={() => setDismissedId(integration.id)}
+          className="inline-flex h-6 w-6 shrink-0 items-center justify-center rounded text-muted-foreground hover:bg-background hover:text-foreground"
+          aria-label={t("mcpIntegrations.dismissSuggestion")}
+        >
+          <IconX className="h-3.5 w-3.5" />
+        </button>
+      </div>
+      {error && (
+        <div className="mx-auto mb-2 w-[min(100%,680px)] text-[11px] text-destructive">
+          {error}
+        </div>
+      )}
+      <McpIntegrationDialog
+        open={dialogOpen}
+        onOpenChange={setDialogOpen}
+        initialIntegrationId={integration.id}
+        defaultScope="user"
+        canCreateOrgMcp={false}
+        hasOrg={Boolean(mcpServersQuery.data?.orgId)}
+        onCreateMcpServer={(args) => createMcpServer.mutateAsync(args)}
+        onCreated={() => setDismissedId(integration.id)}
+      />
+    </>
+  );
+}