@agent-native/core 0.222.0-nightly-20261029004912 → 0.222.0

package/dist/agent/production-agent.js

@@ -5417,6 +5417,7 @@ export async function runAgentLoop(opts) {
     const blockedA2ATargets = new Map();
     let finalGuardRetries = 0;
     let emptyFinalResponseRetries = 0;
+    let followUpOnlyTurns = 0;
     let preserveReasoningEffortForEmptyResponseRetries = false;
     let consecutiveMaxTokensContinuations = 0;
     let truncatedToolCallRetries = 0;
@@ -6201,14 +6202,20 @@ export async function runAgentLoop(opts) {
             else {
                 consecutiveMaxTokensContinuations = 0;
             }
-            if (followUpResults.length > 0 && terminalStopReason === "tool_use") {
-                if (streamedAssistantText)
-                    send({ type: "clear" });
-                continue;
-            }
+            // Only a follow-up call with no reply asks again. A reply sent beside
+            // its follow-ups is the final answer: clearing it to ask again leaves
+            // the model recapping a reply the user no longer sees.
+            // Past the cap, an empty turn takes the bounded empty-response retries
+            // below instead of asking again until the loop's iteration limit.
             if (followUpResults.length > 0 &&
                 hasEmptyFinalResponse &&
-                terminalStopReason !== "max_tokens") {
+                terminalStopReason !== "max_tokens" &&
+                followUpOnlyTurns < EMPTY_FINAL_RESPONSE_RETRY_LIMIT) {
+                followUpOnlyTurns += 1;
+                // Whitespace the model streamed before its follow-ups is not a reply,
+                // and the next turn's answer would land after it.
+                if (streamedAssistantText)
+                    await send({ type: "clear" });
                 flushUnstreamedAssistantText();
                 continue;
             }
@@ -6306,7 +6313,7 @@ export async function runAgentLoop(opts) {
                 flushUnstreamedAssistantText();
                 if (followUpRunId &&
                     completedFollowUpSuggestions === undefined &&
-                    terminalStopReason === "end_turn") {
+                    (terminalStopReason === "end_turn" || followUpResults.length > 0)) {
                     completingFollowUpSuggestions = true;
                     followUpStartedAt = Date.now();
                     followUpCompletionContext = buildFollowUpCompletionMessages({
@@ -6328,6 +6335,7 @@ export async function runAgentLoop(opts) {
         }
         finalGuardRetries = 0;
         emptyFinalResponseRetries = 0;
+        followUpOnlyTurns = 0;
         preserveReasoningEffortForEmptyResponseRetries = false;
         consecutiveMaxTokensContinuations = 0;
         const toolCallTruncatedByOutputCap = terminalStopReason === "max_tokens";
@@ -9374,6 +9382,8 @@ export async function chainServerDrivenContinuation(opts) {
     // Approval selectors apply only to the request that consumes their one-shot grants.
     delete continuationBody.approvedToolCalls;
     delete continuationBody.approvedToolCallAskIds;
+    // The initial admission consumed this one-time queued-message claim.
+    delete continuationBody.queuedMessageClaimId;
     delete continuationBody[AGENT_CHAT_BACKGROUND_RUN_FIELD];
     const markRunsAbortedOrThrow = async (...runIds) => {
         const results = await Promise.allSettled(runIds.map(async (targetRunId) => {
@@ -11528,12 +11538,15 @@ export function createProductionAgentHandler(options) {
         let durableDispatchPayload;
         if (dispatchToBackground) {
             try {
-                durableDispatchPayload = serializeDurableDispatchPayload({
+                const dispatchBody = {
                     ...body,
                     ...(Array.isArray(attachments) || requestAttachments.length > 0
                         ? { attachments: requestAttachments }
                         : {}),
-                });
+                };
+                // This one-time claim authorizes only the request that consumes it.
+                delete dispatchBody.queuedMessageClaimId;
+                durableDispatchPayload = serializeDurableDispatchPayload(dispatchBody);
             }
             catch (error) {
                 if (!(error instanceof DurableAttachmentReferenceRequiredError)) {

package/dist/agent/run-store.d.ts

@@ -317,7 +317,15 @@ export declare const RUN_DIAG_STAGE: {
     readonly staleRunReaped: "stale_run_reaped";
 };
 export type RunDiagStage = (typeof RUN_DIAG_STAGE)[keyof typeof RUN_DIAG_STAGE];
-export declare function recordRunDiagnostic(runId: string, stage: RunDiagStage, detail?: string): Promise<void>;
+export interface RouteFailureDiagnosticEvidence {
+    format: "route_failure_v1";
+    errorMetadata?: "unreadable";
+    errorName?: string;
+    errorCode?: string;
+    httpStatus?: string;
+    causeName?: string;
+}
+export declare function recordRunDiagnostic(runId: string, stage: RunDiagStage, detail?: string, evidence?: RouteFailureDiagnosticEvidence): Promise<void>;
 export declare function updateRunHeartbeat(runId: string): Promise<void>;
 export declare function bumpRunProgress(runId: string): Promise<boolean>;
 /**

package/dist/agent/run-store.js

@@ -2058,16 +2058,39 @@ export const RUN_DIAG_STAGE = {
     runBoundaryReached: "run_boundary_reached",
     staleRunReaped: "stale_run_reaped",
 };
-export async function recordRunDiagnostic(runId, stage, detail) {
+export async function recordRunDiagnostic(runId, stage, detail, evidence) {
     if (!runId)
         return;
     try {
         await ensureRunTables();
-        const payload = JSON.stringify({
+        // raw-sql-ok: diagnostic JSON is passed only as a bound SQL value.
+        const payloadFields = {
             stage,
             ...(detail ? { detail: detail.slice(0, 1500) } : {}),
+            ...(stage === RUN_DIAG_STAGE.routeThrew && evidence ? { evidence } : {}),
             at: Date.now(),
-        }).slice(0, 2000);
+        };
+        // raw-sql-ok: diagnostic JSON is passed only as a bound SQL value.
+        let payload = JSON.stringify(payloadFields);
+        if (payload.length > 2000 && typeof payloadFields.detail === "string") {
+            const fullDetail = payloadFields.detail;
+            let low = 0;
+            let high = fullDetail.length;
+            while (low < high) {
+                const middle = Math.ceil((low + high) / 2);
+                payloadFields.detail = fullDetail.slice(0, middle);
+                if (JSON.stringify(payloadFields).length <= 2000)
+                    low = middle;
+                else
+                    high = middle - 1;
+            }
+            if (low === 0)
+                delete payloadFields.detail;
+            else
+                payloadFields.detail = fullDetail.slice(0, low);
+            // raw-sql-ok: diagnostic JSON is passed only as a bound SQL value.
+            payload = JSON.stringify(payloadFields);
+        }
         const isWorkerStage = stage === RUN_DIAG_STAGE.workerSetupStep ||
             stage === RUN_DIAG_STAGE.workerStarted;
         if (isWorkerStage) {

package/dist/cli/code-agent-mcp-config.js

@@ -132,7 +132,12 @@ function codeAgentHttpMcpServers(config, environment) {
     // its credential headers) silently replace another. Reject that instead.
     const idsByKey = new Map();
     return Object.entries(servers).flatMap(([serverId, server]) => {
-        if (server.type !== "http" || !server.url || server.configurationError)
+        // A workspace-connection server's bearer is resolved per request inside
+        // this process, so a CLI copy would have no credentials.
+        if (server.type !== "http" ||
+            !server.url ||
+            server.configurationError ||
+            server.workspaceConnection)
             return [];
         const key = codexConfigKey(serverId);
         const existing = idsByKey.get(key);

package/dist/client/chat/agentkit-agent-native.js

@@ -978,8 +978,6 @@ function reconcileDurableMessages(messages, durable, events, runs, toolCalls) {
             snapshotReply.id !== durableReply.id &&
             eventMessageIds?.size === 1 &&
             eventMessageIds.has(snapshotReply.id) &&
-            snapshotReply.parts.length > 0 &&
-            snapshotReply.parts.every((part) => part.type === "text") &&
             snapshotText.length > 0 &&
             durableText.length > 0 &&
             snapshotText !== durableText &&
@@ -4221,6 +4219,7 @@ export function createAgentNativeAgentKitTransport(options = {}) {
                     switch (sourceEvent.type) {
                         case "message.created":
                         case "message.completed":
+                        case "message.replaced":
                             if (sourceEvent.message.role === "assistant") {
                                 const messageId = foldedMessageIdFor(sourceEvent.message.id);
                                 if (messageId && messageId !== sourceEvent.message.id) {

package/dist/client/chat/agentkit-protocol.js

@@ -2026,6 +2026,20 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     },
                     ...attachPendingWidgets(event.messageId),
                 ];
+            case "message-replace":
+                run.activeMessageId = event.message.id;
+                run.activeMessageRole = event.message.role;
+                run.activeMessageCompleted = false;
+                return [
+                    {
+                        type: "message.replaced",
+                        ...(base.occurredAt === undefined
+                            ? {}
+                            : { occurredAt: base.occurredAt }),
+                        ...(base.metadata === undefined ? {} : { metadata: base.metadata }),
+                        message: runtimeMessageToProtocolMessage(event.message, textFormat),
+                    },
+                ];
             case "message-done":
                 run.activeMessageId = event.message.id;
                 run.activeMessageRole = event.message.role;

package/dist/client/chat/runtime.d.ts

@@ -307,6 +307,10 @@ export interface AgentChatRuntimeMessageDeltaEvent extends AgentChatRuntimeEvent
 export interface AgentChatRuntimeMessageDoneEvent extends AgentChatRuntimeEventBase<"message-done"> {
     readonly message: AgentChatRuntimeMessage;
 }
+/** Replaces a streaming message's content without finishing it. */
+export interface AgentChatRuntimeMessageReplaceEvent extends AgentChatRuntimeEventBase<"message-replace"> {
+    readonly message: AgentChatRuntimeMessage;
+}
 export interface AgentChatRuntimeToolStartEvent extends AgentChatRuntimeEventBase<"tool-start"> {
     readonly toolCall: AgentChatRuntimeToolCall;
 }
@@ -546,7 +550,7 @@ export interface AgentChatRuntimeDoneEvent extends AgentChatRuntimeEventBase<"do
 export interface AgentChatRuntimeCustomEvent extends AgentChatRuntimeEventBase {
     readonly [key: string]: unknown;
 }
-export type AgentChatRuntimeKnownEvent = AgentChatRuntimeMessageStartEvent | AgentChatRuntimeMessageDeltaEvent | AgentChatRuntimeMessageDoneEvent | AgentChatRuntimeToolStartEvent | AgentChatRuntimeToolDeltaEvent | AgentChatRuntimeToolDoneEvent | AgentChatRuntimeApprovalRequestEvent | AgentChatRuntimeApprovalResolvedEvent | AgentChatRuntimeConnectionRequestEvent | AgentChatRuntimeStatusEvent | AgentChatRuntimeSuggestionsEvent | AgentChatRuntimeAnnotationEvent | AgentChatRuntimeWidgetEvent | AgentChatRuntimeParticipantEvent | AgentChatRuntimeInteractionEvent | AgentChatRuntimeActivityEvent | AgentChatRuntimeTaskEvent | AgentChatRuntimeTaskGroupEvent | AgentChatRuntimeUploadProgressEvent | AgentChatRuntimeClientEffectEvent | AgentChatRuntimeExtensionEvent | AgentChatRuntimeArtifactEvent | AgentChatRuntimeFileEvent | AgentChatRuntimeUsageEvent | AgentChatRuntimeErrorEvent | AgentChatRuntimeContinuationEvent | AgentChatRuntimeDoneEvent;
+export type AgentChatRuntimeKnownEvent = AgentChatRuntimeMessageStartEvent | AgentChatRuntimeMessageDeltaEvent | AgentChatRuntimeMessageDoneEvent | AgentChatRuntimeMessageReplaceEvent | AgentChatRuntimeToolStartEvent | AgentChatRuntimeToolDeltaEvent | AgentChatRuntimeToolDoneEvent | AgentChatRuntimeApprovalRequestEvent | AgentChatRuntimeApprovalResolvedEvent | AgentChatRuntimeConnectionRequestEvent | AgentChatRuntimeStatusEvent | AgentChatRuntimeSuggestionsEvent | AgentChatRuntimeAnnotationEvent | AgentChatRuntimeWidgetEvent | AgentChatRuntimeParticipantEvent | AgentChatRuntimeInteractionEvent | AgentChatRuntimeActivityEvent | AgentChatRuntimeTaskEvent | AgentChatRuntimeTaskGroupEvent | AgentChatRuntimeUploadProgressEvent | AgentChatRuntimeClientEffectEvent | AgentChatRuntimeExtensionEvent | AgentChatRuntimeArtifactEvent | AgentChatRuntimeFileEvent | AgentChatRuntimeUsageEvent | AgentChatRuntimeErrorEvent | AgentChatRuntimeContinuationEvent | AgentChatRuntimeDoneEvent;
 export type AgentChatRuntimeEvent<TCustomEvent extends AgentChatRuntimeCustomEvent = never> = AgentChatRuntimeKnownEvent | TCustomEvent;
 export interface AgentChatRuntimeTurn<TEvent extends AgentChatRuntimeEventBase = AgentChatRuntimeKnownEvent> {
     readonly id?: AgentChatRuntimeTurnId;

package/dist/client/chat/runtime.js

@@ -6,7 +6,7 @@ import { agentEngineStatusUrlForChatApi, requireAgentEngineConfiguredForDispatch
 import { getOrCreateAnalyticsSessionId } from "../analytics-session.js";
 import { agentChatStreamingUrl, agentNativePath } from "../api-path.js";
 import { CHAT_REQUEST_TOO_LARGE_MESSAGE } from "../error-format.js";
-import { appendMissingFinalResponseWarning, findApprovalToolCallIndex, } from "../sse-event-processor.js";
+import { appendMissingFinalResponseWarning, clearAssistantDraftContent, findApprovalToolCallIndex, } from "../sse-event-processor.js";
 import { runOutcomeForCode } from "./run-outcome.js";
 import { acceptedPromptForMetadata, DEFAULT_TURN_SURFACE, } from "./turn-submitted.js";
 export const AGENT_NATIVE_RUN_RESUME_STATE_METADATA_KEY = "agentNativeRunResumeState";
@@ -2417,6 +2417,28 @@ function mapAgentNativeEvent(raw, input) {
     if (ev.type === "auto_continue") {
         return [{ type: "continuation", ...base }];
     }
+    // Skipping this leaves the saved reply as a suffix of the live one, and
+    // reload renders it as a second reply.
+    if (ev.type === "clear") {
+        clearAssistantDraftContent(input.message.content);
+        if (!input.message.started)
+            return [];
+        const content = input.message.content
+            .filter((part) => part.type === "text" || part.type === "reasoning")
+            .map((part) => ({ ...part }));
+        // Text the retry writes after a kept tool call is a new paragraph. The
+        // replacement carries no tool calls, so an empty part marks that break.
+        if (input.message.content.at(-1)?.type === "tool-call") {
+            content.push({ type: "text", text: "" });
+        }
+        return [
+            {
+                type: "message-replace",
+                ...base,
+                message: { id: input.messageId, role: "assistant", content },
+            },
+        ];
+    }
     if (ev.type === "text" || ev.type === "thinking" || ev.type === "reasoning") {
         const text = ev.text ?? "";
         const type = ev.type === "text" ? "text" : "reasoning";

package/dist/client/sse-event-processor.d.ts

@@ -354,6 +354,16 @@ export declare function processEvent(ev: SSEEvent, content: ContentPart[], toolC
         errorInfo?: AgentAutoContinueErrorInfo;
     };
 };
+/**
+ * Drop the draft the server is about to re-emit — the narration since the last
+ * completed tool, not the whole turn. A `clear` arrives on a final-answer-guard
+ * retry or a continuation, both of which resume AFTER the last completed tool
+ * call, so anything before that boundary is settled multi-step narration the
+ * retry will never re-send. Wiping it read to users as "it deleted its reply
+ * and started over", and `thread-data-builder` replays this same scoping on
+ * rebuild, so the loss survived a reload.
+ */
+export declare function clearAssistantDraftContent(content: ContentPart[]): void;
 /**
  * Read and process SSE events from a ReadableStream response body.
  * Yields Core-owned stream results for each meaningful event.

package/dist/client/sse-event-processor.js

@@ -1891,7 +1891,7 @@ export function processEvent(ev, content, toolCallCounter, tabId, state, context
  * and started over", and `thread-data-builder` replays this same scoping on
  * rebuild, so the loss survived a reload.
  */
-function clearAssistantDraftContent(content) {
+export function clearAssistantDraftContent(content) {
     for (let index = content.length - 1; index >= 0; index--) {
         const part = content[index];
         if (!part)

package/dist/collab/routes.d.ts

@@ -25,8 +25,8 @@ export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import
     ok: boolean;
 }>>;
 export declare const postCollabText: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    text?: undefined;
     ok?: undefined;
+    text?: undefined;
     error: string;
 } | {
     error?: undefined;

package/dist/collab/struct-routes.d.ts

@@ -13,9 +13,9 @@ export declare const postCollabPatch: import("h3").EventHandlerWithFetch<import(
     ok: boolean;
 }>>;
 export declare const getCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    data?: undefined;
     error: string;
     docId?: undefined;
-    data?: undefined;
 } | {
     error?: undefined;
     docId: string;

package/dist/connections/catalog.d.ts

@@ -280,7 +280,7 @@ export declare const WORKSPACE_CONNECTION_PROVIDERS: readonly [{
         readonly authorizationUrl: "https://app.hubspot.com/oauth/authorize";
         readonly tokenUrl: "https://api.hubapi.com/oauth/v3/token";
         readonly refreshUrl: "https://api.hubapi.com/oauth/v3/token";
-        readonly scopes: readonly ["oauth", "crm.objects.contacts.read", "crm.objects.companies.read", "crm.objects.deals.read", "crm.objects.tickets.read", "crm.schemas.contacts.read", "crm.schemas.companies.read", "crm.schemas.deals.read", "crm.schemas.tickets.read"];
+        readonly scopes: readonly [];
     };
     readonly capabilities: readonly ["search", "import", "crm"];
     readonly recommendedTemplateUses: readonly ["analytics", "brain", "crm", "mail", "dispatch"];

package/dist/connections/catalog.js

@@ -245,17 +245,10 @@ export const WORKSPACE_CONNECTION_PROVIDERS = [
             authorizationUrl: "https://app.hubspot.com/oauth/authorize",
             tokenUrl: "https://api.hubapi.com/oauth/v3/token",
             refreshUrl: "https://api.hubapi.com/oauth/v3/token",
-            scopes: [
-                "oauth",
-                "crm.objects.contacts.read",
-                "crm.objects.companies.read",
-                "crm.objects.deals.read",
-                "crm.objects.tickets.read",
-                "crm.schemas.contacts.read",
-                "crm.schemas.companies.read",
-                "crm.schemas.deals.read",
-                "crm.schemas.tickets.read",
-            ],
+            // HubSpot grants the scopes configured on the HubSpot app itself, so the
+            // app's config is the source of truth. Sending no scope list keeps the
+            // two from drifting; the granted scopes are recorded from the token.
+            scopes: [],
         },
         capabilities: ["search", "import", "crm"],
         recommendedTemplateUses: ["analytics", "brain", "crm", "mail", "dispatch"],

package/dist/mcp-client/config.d.ts

@@ -1,3 +1,4 @@
+import type { McpWorkspaceConnectionAuth } from "./workspace-connection-servers.js";
 export interface McpStdioServerConfig {
     type?: "stdio";
     command: string;
@@ -21,6 +22,11 @@ export interface McpHttpServerConfig {
     firstPartyAppId?: string;
     firstPartyOrgId?: string;
     description?: string;
+    /**
+     * Authenticate each request with this owner's workspace connection instead
+     * of stored headers. Holds identifiers only; the token is never stored here.
+     */
+    workspaceConnection?: McpWorkspaceConnectionAuth;
 }
 export type McpServerConfig = McpStdioServerConfig | McpHttpServerConfig;
 export interface McpConfig {

package/dist/mcp-client/manager.js

@@ -4,6 +4,7 @@ import { plainJsonSnapshot, UnusableSchemaError, } from "../json-schema/unusable
 import { assertUsableSchema } from "../json-schema/usable-schema.js";
 import { formatMcpConnectError, httpStatusFromError } from "./errors.js";
 import { isFirstPartyRemoteEndpointTrusted, parseMergedKey, } from "./remote-store.js";
+import { isWorkspaceConnectionMcpServer, resolveWorkspaceConnectionMcpBearer, } from "./workspace-connection-servers.js";
 export const MCP_TOOL_PREFIX = "mcp__";
 /**
  * Why a listed tool cannot be offered to the model, or null when it can. A
@@ -106,7 +107,9 @@ function sameServerConfig(a, b) {
                 errorIdentity(b.configurationError) &&
             a.firstParty === b.firstParty &&
             a.firstPartyAppId === b.firstPartyAppId &&
-            a.firstPartyOrgId === b.firstPartyOrgId);
+            a.firstPartyOrgId === b.firstPartyOrgId &&
+            JSON.stringify(a.workspaceConnection ?? null) ===
+                JSON.stringify(b.workspaceConnection ?? null));
     }
     if (a.type !== "http" && b.type !== "http") {
         return (a.command === b.command &&
@@ -334,7 +337,16 @@ export class McpClientManager {
             const requestInit = {};
             const staticHeaders = { ...(cfg.headers ?? {}) };
             const transportOptions = { requestInit };
-            if (this.shouldInjectFirstPartyIdentity(entry)) {
+            if (isWorkspaceConnectionMcpServer(cfg)) {
+                removeAuthorizationHeaders(staticHeaders);
+                if (Object.keys(staticHeaders).length > 0) {
+                    requestInit.headers = staticHeaders;
+                }
+                const auth = cfg.workspaceConnection;
+                const nativeFetch = fetch.bind(globalThis);
+                transportOptions.fetch = async (input, init) => nativeFetch(input, await buildWorkspaceConnectionRequestInit(staticHeaders, init, auth));
+            }
+            else if (this.shouldInjectFirstPartyIdentity(entry)) {
                 const baselineHeaders = { ...staticHeaders };
                 removeAuthorizationHeaders(baselineHeaders);
                 if (Object.keys(baselineHeaders).length > 0) {
@@ -857,6 +869,17 @@ function headersToRecord(value) {
     }
     return {};
 }
+async function buildWorkspaceConnectionRequestInit(staticHeaders, rawInit, auth) {
+    const init = rawInit && typeof rawInit === "object" ? rawInit : {};
+    const headers = {
+        ...headersToRecord(staticHeaders),
+        ...headersToRecord(init.headers),
+    };
+    removeAuthorizationHeaders(headers);
+    // Resolved per request so a refreshed token is used as soon as it exists.
+    headers.Authorization = `Bearer ${await resolveWorkspaceConnectionMcpBearer(auth)}`;
+    return { ...init, headers };
+}
 async function buildFirstPartyRequestInit(staticHeaders, rawInit, trust) {
     const init = rawInit && typeof rawInit === "object" ? rawInit : {};
     const headers = {

package/dist/mcp-client/routes.js

@@ -38,6 +38,7 @@ import { mountMcpOAuthRoutes } from "./oauth-routes.js";
 import { normalizeMcpPrincipal, resolveMcpPrincipalForEvent, } from "./principal.js";
 import { InvalidMcpHeaderConfigurationError, McpHeaderSecretUnavailableError, addRemoteServer, listRemoteServers, mergedConfigKey, removeRemoteServer, toHttpServerConfigAsync, validateRemoteUrl, } from "./remote-store.js";
 import { isMcpToolAllowedForRequest } from "./visibility.js";
+import { addWorkspaceConnectionMcpServers } from "./workspace-connection-servers.js";
 import { loadWorkspaceMcpServers } from "./workspace-servers.js";
 const getOrgContext = (...args) => import("../org/context.js").then(({ getOrgContext }) => getOrgContext(...args));
 export { formatMcpConnectError } from "./errors.js";
@@ -219,6 +220,7 @@ export async function buildMergedConfig(rawPrincipal) {
     for (const [mergedKey, cfg] of Object.entries(workspaceServers)) {
         servers[mergedKey] = cfg;
     }
+    await addWorkspaceConnectionMcpServers(servers, principal);
     // Hub-consume: if this app is configured to consume from a remote hub
     // (AGENT_NATIVE_MCP_HUB_URL + AGENT_NATIVE_MCP_HUB_TOKEN), pull its
     // org-scope servers and merge. Hub entries use `hub_<orgId>_<name>` so

package/dist/mcp-client/workspace-connection-servers.d.ts

@@ -0,0 +1,30 @@
+import type { ProviderApiId } from "../provider-api/index.js";
+import type { McpHttpServerConfig, McpServerConfig } from "./config.js";
+import type { McpPrincipal } from "./principal.js";
+export interface McpWorkspaceConnectionAuth {
+    provider: ProviderApiId;
+    connectionId: string;
+    /** The connection owner, who is also the MCP principal. */
+    ownerEmail: string;
+    orgId: string | null;
+    appId: string;
+}
+/**
+ * Add one MCP server per provider for which the principal has a connected
+ * personal workspace connection granted to this app. Organization- and
+ * app-scoped connections never qualify, even ones the principal created: they
+ * may have been authorized as another provider user, and an MCP call must act
+ * as the caller. A server already configured for the same endpoint wins, so
+ * tools are not duplicated.
+ */
+export declare function addWorkspaceConnectionMcpServers(servers: Record<string, McpServerConfig>, principal: McpPrincipal): Promise<void>;
+/**
+ * Resolve the bearer for one MCP request from the owner's workspace
+ * connection, refreshing it through the connection's own refresh path. The
+ * token is sent to the provider's MCP endpoint only; it is never persisted on
+ * the server config or shown to the agent.
+ */
+export declare function resolveWorkspaceConnectionMcpBearer(auth: McpWorkspaceConnectionAuth): Promise<string>;
+export declare function isWorkspaceConnectionMcpServer(config: McpServerConfig): config is McpHttpServerConfig & {
+    workspaceConnection: McpWorkspaceConnectionAuth;
+};

package/dist/mcp-client/workspace-connection-servers.js

@@ -0,0 +1,119 @@
+/**
+ * Remote MCP servers that authenticate with a workspace connection the user
+ * already has, so one provider sign-in covers both its REST API and its MCP
+ * server. HubSpot is the only verified provider: a token from the HubSpot app
+ * behind the workspace connection is accepted by mcp.hubspot.com.
+ */
+import { getAppConfig } from "../app-config/index.js";
+import { runWithRequestContext } from "../server/request-context.js";
+import { normalizeMcpUrl } from "../shared/mcp-provider-hosts.js";
+import { mergedConfigKey } from "./remote-store.js";
+const WORKSPACE_CONNECTION_MCP_SERVERS = [["hubspot", "https://mcp.hubspot.com"]];
+// Same order as the agent-chat runtime app id, so MCP sees the grants the
+// app's own actions see.
+function currentAppId() {
+    const app = getAppConfig().app;
+    const value = (app.id ?? app.template ?? app.workspaceId ?? app.packageName)
+        ?.trim()
+        .toLowerCase();
+    return value || null;
+}
+/**
+ * Add one MCP server per provider for which the principal has a connected
+ * personal workspace connection granted to this app. Organization- and
+ * app-scoped connections never qualify, even ones the principal created: they
+ * may have been authorized as another provider user, and an MCP call must act
+ * as the caller. A server already configured for the same endpoint wins, so
+ * tools are not duplicated.
+ */
+export async function addWorkspaceConnectionMcpServers(servers, principal) {
+    const appId = currentAppId();
+    if (!appId)
+        return;
+    const { resolveWorkspaceConnectionsForApp } = await import("../workspace-connections/store.js");
+    const caller = principal.userEmail.trim().toLowerCase();
+    for (const [provider, url] of WORKSPACE_CONNECTION_MCP_SERVERS) {
+        const alreadyConfigured = Object.values(servers).some((server) => server.type === "http" &&
+            normalizeMcpUrl(server.url) === normalizeMcpUrl(url));
+        if (alreadyConfigured)
+            continue;
+        const key = mergedConfigKey("user", {
+            id: `workspace_connection_${provider}`,
+            name: provider,
+            url,
+            createdAt: 0,
+        }, principal.userEmail);
+        const description = `${provider} through your ${provider} workspace connection`;
+        let connectionIds;
+        try {
+            const connections = await runWithRequestContext({
+                userEmail: principal.userEmail,
+                ...(principal.orgId ? { orgId: principal.orgId } : {}),
+            }, () => resolveWorkspaceConnectionsForApp({ appId, provider }));
+            connectionIds = connections
+                .filter((connection) => connection.status === "connected" &&
+                connection.ownerEmail.trim().toLowerCase() === caller &&
+                connection.config.workspaceConnectionScope === "user")
+                .map((connection) => connection.id);
+        }
+        catch (error) {
+            // Keep other MCP servers working, but report this one as unreadable
+            // rather than as an absent connection.
+            servers[key] = {
+                type: "http",
+                url,
+                description,
+                configurationError: new Error(`The ${provider} workspace connection could not be read.`, { cause: error }),
+            };
+            continue;
+        }
+        // The server has no account selector, so with two personal connections
+        // (e.g. a sandbox and a production portal) any pick could write to the
+        // wrong account.
+        if (connectionIds.length > 1) {
+            servers[key] = {
+                type: "http",
+                url,
+                description,
+                configurationError: new Error(`You have ${connectionIds.length} personal ${provider} connections for this app, so the ${provider} MCP server can't tell which account to use. Disconnect the extra ones, or add the ${provider} MCP server yourself.`),
+            };
+            continue;
+        }
+        const connectionId = connectionIds[0];
+        if (!connectionId)
+            continue;
+        servers[key] = {
+            type: "http",
+            url,
+            description,
+            workspaceConnection: {
+                provider,
+                connectionId,
+                ownerEmail: principal.userEmail,
+                orgId: principal.orgId,
+                appId,
+            },
+        };
+    }
+}
+/**
+ * Resolve the bearer for one MCP request from the owner's workspace
+ * connection, refreshing it through the connection's own refresh path. The
+ * token is sent to the provider's MCP endpoint only; it is never persisted on
+ * the server config or shown to the agent.
+ */
+export async function resolveWorkspaceConnectionMcpBearer(auth) {
+    const { createProviderApiRuntime } = await import("../provider-api/index.js");
+    const runtime = createProviderApiRuntime({ appId: auth.appId });
+    const token = await runWithRequestContext({
+        userEmail: auth.ownerEmail,
+        ...(auth.orgId ? { orgId: auth.orgId } : {}),
+    }, () => runtime.resolveOAuthAccessToken({
+        provider: auth.provider,
+        connectionId: auth.connectionId,
+    }));
+    return token.accessToken;
+}
+export function isWorkspaceConnectionMcpServer(config) {
+    return config.type === "http" && !!config.workspaceConnection;
+}

package/dist/notifications/routes.d.ts

@@ -1,18 +1,18 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
     error?: undefined;
-    ok?: undefined;
     count: number;
     updated?: undefined;
+    ok?: undefined;
 } | {
     error?: undefined;
-    ok?: undefined;
     count?: undefined;
     updated: number;
-} | {
     ok?: undefined;
+} | {
     count?: undefined;
     updated?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     count?: undefined;