@salesforce/sfdx-agent-harness-mastra 0.26.0 → 0.27.0

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to `@salesforce/sfdx-agent-harness-mastra` are documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.27.0] - 2026-06-30
+
+### Features
+- **sdk,harness-mastra,harness-claude**: add bareToolName to MCP tool events for remember matcher @W-23090030 ([#634](https://github.com/forcedotcom/agentic-dx/pull/634))
+
+### Fixes
+- **harness-mastra**: recover discarded remote-MCP HTTP error body so consumers can classify org_not_enabled @W-23231658 ([#633](https://github.com/forcedotcom/agentic-dx/pull/633))
+
+### Chores
+- **deps**: bump the mastra group across 1 directory with 4 updates ([#630](https://github.com/forcedotcom/agentic-dx/pull/630))
+- **deps**: bump @anthropic-ai/sdk from 0.105.0 to 0.106.0 ([#632](https://github.com/forcedotcom/agentic-dx/pull/632))
+- **deps-dev**: bump the eslint group across 1 directory with 2 updates ([#629](https://github.com/forcedotcom/agentic-dx/pull/629))
+- **deps-dev**: bump prettier from 3.8.4 to 3.9.0 in the dev-dependencies group ([#628](https://github.com/forcedotcom/agentic-dx/pull/628))
+
 ## [0.26.0] - 2026-06-29
 
 _No changes — released alongside dependent packages._

package/dist/mastra-approval-coordinator.js

@@ -759,11 +759,16 @@ export class MastraApprovalCoordinator {
         const invocation = this.buildToolInvocation(toolName);
         // No serverName ⇒ built-in / consumer tool ⇒ nothing to stamp. The
         // event keeps its Mastra-namespaced display `toolName`; enrichment only
-        // adds `serverName` / `annotations`.
+        // adds `serverName` / `annotations` / `bareToolName`.
         if (invocation.serverName === undefined)
             return event;
+        // The display `toolName` stays Mastra-namespaced (`${server}_${tool}`);
+        // `bareToolName` carries the un-namespaced leaf so the SDK can build a
+        // matching `mcp` policy matcher (the AG-UI "Allow always" / remember flow)
+        // without string-splitting the display name.
         const fields = {
             serverName: invocation.serverName,
+            bareToolName: invocation.toolName,
             ...(invocation.annotations ? { annotations: invocation.annotations } : {}),
         };
         if (event.type === 'tool-call') {

package/dist/mastra-harness.d.ts

@@ -4,6 +4,7 @@ import { MCPClient } from '@mastra/mcp';
 import { McpServerStatus, type AgentHarness, type WithAgentConfig, type ChatStreamResult, type HarnessAgentConfig, type MCPConfiguration, type McpServerErrorDetail, type McpServerInfo, type Message, type MessagePart, type ModelConnectivityInfo, type StreamOptions, type TelemetryEventCallback, type ToolResultInfo, type WireCommunicationEventCallback } from '@salesforce/sfdx-agent-sdk';
 import { type AgentHooks } from '@salesforce/sfdx-agent-sdk/harness';
 import { MastraApprovalCoordinator } from './mastra-approval-coordinator.js';
+import { type HttpErrorCapture } from './mcp-config-mapper.js';
 import { type MastraAgentConfig, type SkillSearchHandle, type ToolSearchHandle } from './tool-search.js';
 import { type MultimodalFile } from '@salesforce/sfdx-agent-sdk';
 import { Clock, type LogRecord, type UniqueIDGenerator, type Unsubscribe } from '@salesforce/agentic-common';
@@ -51,6 +52,15 @@ interface McpServerState {
      * on (tool merging, alwaysActive expansion, MCP-tool metadata lookup).
      */
     tools: ToolsInput;
+    /**
+     * HTTP-error capture slot for remote servers (W-23231658). The remote
+     * transport fetch (built by `mapToMastraMCPServers`) writes the latest
+     * non-2xx `{ status, body }` here; the discovery / reconnect catch reads
+     * `latest` to recover the HTTP status `@mastra/mcp` discards when a
+     * fallback-eligible connect fails. `undefined` for stdio servers and for
+     * remote servers when no capture map was threaded in.
+     */
+    httpErrorCapture?: HttpErrorCapture;
 }
 /**
  * Internal state for a single agent. Holds Mastra-specific instances so the

package/dist/mastra-harness.js

@@ -20,7 +20,7 @@ import { mapMastraToMessage, mapMessageToMastra, partToTranscriptText } from './
 import { isStandardSchemaWithJSON, standardSchemaToJSONSchema } from '@mastra/schema-compat';
 import { mapToolDefinitionsToMastraTools } from './mastra-tool-mapper.js';
 import { hasEnabledServers, mapToMastraMCPServers } from './mcp-config-mapper.js';
-import { buildMcpErrorDetail, sanitizeMcpErrorMessage } from './mcp-error-classifier.js';
+import { buildMcpErrorDetail, sanitizeMcpErrorMessage, synthesizeHttpTransportError } from './mcp-error-classifier.js';
 import { partitionPool, resolveAlwaysActive, } from './tool-search.js';
 import { validateMultimodalFiles } from '@salesforce/sfdx-agent-sdk';
 import { buildAnthropicDirectLanguageModel, buildAnthropicLanguageModel } from './pass-through-anthropic.js';
@@ -490,7 +490,11 @@ export class MastraHarness {
         const mcpServerStates = new Map();
         if (hasEnabledServers(config.mcpServers)) {
             options?.abortSignal?.throwIfAborted();
-            const enabledServers = mapToMastraMCPServers(config.mcpServers, config.orgJwt, this.innerFetch);
+            // Empty capture map; the mapper creates a per-remote-server capture
+            // object and stores it here so we can attach each to its
+            // McpServerState below (W-23231658).
+            const httpErrorCaptures = new Map();
+            const enabledServers = mapToMastraMCPServers(config.mcpServers, config.orgJwt, this.innerFetch, httpErrorCaptures);
             for (const [serverName, serverDef] of Object.entries(enabledServers)) {
                 const client = new MCPClient({
                     id: `${agentId}:${serverName}`,
@@ -508,6 +512,7 @@ export class MastraHarness {
                     ready: Promise.resolve(),
                     settled: false,
                     tools: {},
+                    httpErrorCapture: httpErrorCaptures.get(serverName),
                 };
                 mcpServerStates.set(serverName, entry);
                 entry.ready = this.runMcpDiscovery(agentId, serverName, client, mcpServerStates, 0, options?.abortSignal);
@@ -815,6 +820,11 @@ export class MastraHarness {
             agentId,
             serverName,
         });
+        // W-23231658: clear any stale HTTP-error capture so a prior failure's
+        // status can't be mistaken for this reconnect's. The wrapper repopulates
+        // `latest` only if this reconnect's connect sees a non-2xx response.
+        if (serverState.httpErrorCapture)
+            serverState.httpErrorCapture.latest = undefined;
         // Transport-level reconnect can throw (stdio spawn failure, remote handshake
         // failure). Record on serverState and emit only `failed` (not started+failed
         // — `started` already fired above). This keeps the public contract
@@ -826,8 +836,13 @@ export class MastraHarness {
             // Drop telemetry + state writes if a newer epoch has superseded us.
             if (state.mcpServers.get(serverName)?.epoch !== epoch)
                 return;
-            const message = sanitizeMcpErrorMessage(err);
-            const errorDetail = buildMcpErrorDetail(err);
+            // Prefer the captured HTTP status + body over the bodyless generic
+            // error `@mastra/mcp` rethrows on a fallback-eligible connect
+            // failure (W-23231658); same recovery as the discovery catch.
+            const captured = serverState.httpErrorCapture?.latest;
+            const effectiveError = captured ? synthesizeHttpTransportError(captured.status, captured.body, err) : err;
+            const message = sanitizeMcpErrorMessage(effectiveError);
+            const errorDetail = buildMcpErrorDetail(effectiveError);
             serverState.error = message;
             serverState.errorDetail = errorDetail;
             serverState.settled = true;
@@ -844,7 +859,7 @@ export class MastraHarness {
                     agentId,
                     serverName,
                     durationMs: this.clock.now().getTime() - startTime,
-                    error: err instanceof Error ? err : new Error(message),
+                    error: effectiveError instanceof Error ? effectiveError : new Error(message),
                     errorDetail,
                 });
             }
@@ -932,8 +947,9 @@ export class MastraHarness {
         const prevConfig = state.mcpConfig ?? {};
         const nextConfig = config.mcpServers ?? {};
         const allNames = new Set([...Object.keys(prevConfig), ...Object.keys(nextConfig)]);
+        const nextHttpErrorCaptures = new Map();
         const nextEnabledServers = hasEnabledServers(nextConfig)
-            ? mapToMastraMCPServers(nextConfig, config.orgJwt, this.innerFetch)
+            ? mapToMastraMCPServers(nextConfig, config.orgJwt, this.innerFetch, nextHttpErrorCaptures)
             : {};
         for (const name of allNames) {
             const prev = prevConfig[name];
@@ -965,6 +981,7 @@ export class MastraHarness {
                         ready: Promise.resolve(),
                         settled: false,
                         tools: {},
+                        httpErrorCapture: nextHttpErrorCaptures.get(name),
                     };
                     state.mcpServers.set(name, entry);
                     entry.ready = this.runMcpDiscovery(agentId, name, client, state.mcpServers, 0, options?.abortSignal);
@@ -1824,6 +1841,13 @@ export class MastraHarness {
             const s = serverStates.get(serverName);
             return s && s.epoch === epoch ? s : undefined;
         };
+        // W-23231658: clear any HTTP-error capture left from a prior discovery
+        // run on this (reused) client/capture so a stale status can't bleed into
+        // this run's failure classification. The wrapper repopulates `latest`
+        // only if a non-2xx response actually occurs during this connect.
+        const captureSlot = serverStates.get(serverName)?.httpErrorCapture;
+        if (captureSlot)
+            captureSlot.latest = undefined;
         return makeAbortable(client.listToolsetsWithErrors(), abortSignal)
             .then(({ toolsets, errors }) => {
             const serverError = errors[serverName];
@@ -1877,8 +1901,20 @@ export class MastraHarness {
                 // Flip `settled` AND `currentStatus` BEFORE emitting any
                 // terminal telemetry — see the matching comment in the
                 // success path above (issue #373).
-                const errorMessage = sanitizeMcpErrorMessage(err);
-                const errorDetail = buildMcpErrorDetail(err);
+                //
+                // W-23231658: when the remote transport captured a non-2xx
+                // HTTP response, prefer it over the bodyless generic error
+                // `@mastra/mcp` rethrows. The capture is only ever populated
+                // when a real HTTP error occurred on this server's transport,
+                // so by construction it IS the (or a) cause of this failure;
+                // the original `err` rides along as `cause` so its stack is
+                // preserved on the failed event.
+                const captured = s.httpErrorCapture?.latest;
+                const effectiveError = captured
+                    ? synthesizeHttpTransportError(captured.status, captured.body, err)
+                    : err;
+                const errorMessage = sanitizeMcpErrorMessage(effectiveError);
+                const errorDetail = buildMcpErrorDetail(effectiveError);
                 s.error = errorMessage;
                 s.errorDetail = errorDetail;
                 s.settled = true;
@@ -1895,7 +1931,7 @@ export class MastraHarness {
                         agentId,
                         serverName,
                         durationMs: this.clock.now().getTime() - startTime,
-                        error: err instanceof Error ? err : new Error(String(err)),
+                        error: effectiveError instanceof Error ? effectiveError : new Error(String(effectiveError)),
                         errorDetail,
                     });
                 }

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

@@ -6,6 +6,23 @@ import { type MCPConfiguration } from '@salesforce/sfdx-agent-sdk';
  * A server is considered enabled when its `enabled` property is `true` or absent.
  */
 export declare function hasEnabledServers(config: MCPConfiguration | undefined): config is MCPConfiguration;
+/** A captured non-2xx HTTP response from a remote MCP transport request. */
+export type CapturedHttpError = {
+    status: number;
+    body: string;
+};
+/**
+ * Per-server mutable slot the remote-MCP fetch wrapper writes the latest
+ * non-2xx response into. The harness reads `latest` in its discovery /
+ * reconnect catch blocks to recover the HTTP status + body that
+ * `@mastra/mcp`'s `connectHttp` discards when a fallback-eligible status
+ * (`400` / `404` / `405`) triggers the SSE fallback and both transports fail —
+ * the thrown `Error("Could not connect to server with any available HTTP
+ * transport")` carries no status, no body, and no `cause` (W-23231658, #617).
+ */
+export type HttpErrorCapture = {
+    latest?: CapturedHttpError;
+};
 /**
  * Converts our {@link MCPConfiguration} into the `servers` map expected by Mastra's `MCPClient`.
  *
@@ -31,4 +48,13 @@ export declare function mapToMastraMCPServers(config: MCPConfiguration, orgJwt?:
  * here so MCP remote transports honor `HTTPS_PROXY` without `globalThis`
  * mutation. Stdio transports ignore it (they're child processes).
  */
-innerFetch?: typeof fetch): Record<string, MastraMCPServerDefinition>;
+innerFetch?: typeof fetch, 
+/**
+ * Optional per-server HTTP-error capture map. When supplied, every remote
+ * server's transport fetch is wrapped so the latest non-2xx `{ status, body }`
+ * is recorded into `captures.get(serverName)`. The harness reads this in its
+ * discovery / reconnect catch to recover the status `@mastra/mcp` discards
+ * (W-23231658). Stdio servers contribute no entry. Omitted in call sites
+ * that don't need recovery (e.g. unit tests of the mapping shape).
+ */
+captures?: Map<string, HttpErrorCapture>): Record<string, MastraMCPServerDefinition>;

package/dist/mcp-config-mapper.js

@@ -12,6 +12,13 @@ export function hasEnabledServers(config) {
         return false;
     return Object.values(config).some((s) => s.enabled !== false);
 }
+/**
+ * Cap on the captured error-body text. A connect-error body is a small JSON
+ * envelope (e.g. `{"error":{"code":404,"message":"..."}}`); the slice guards
+ * against an unexpectedly large body bloating the `McpServerInfo.error` string
+ * and telemetry payloads.
+ */
+const MAX_CAPTURED_BODY_CHARS = 8192;
 /**
  * MCP SDK's built-in `StreamableHTTPReconnectionOptions` defaults. Mirrored
  * here so partial `MCPRemoteServerConfig.reconnectionOptions` inputs merge
@@ -51,7 +58,16 @@ export function mapToMastraMCPServers(config, orgJwt,
  * here so MCP remote transports honor `HTTPS_PROXY` without `globalThis`
  * mutation. Stdio transports ignore it (they're child processes).
  */
-innerFetch = globalThis.fetch) {
+innerFetch = globalThis.fetch, 
+/**
+ * Optional per-server HTTP-error capture map. When supplied, every remote
+ * server's transport fetch is wrapped so the latest non-2xx `{ status, body }`
+ * is recorded into `captures.get(serverName)`. The harness reads this in its
+ * discovery / reconnect catch to recover the status `@mastra/mcp` discards
+ * (W-23231658). Stdio servers contribute no entry. Omitted in call sites
+ * that don't need recovery (e.g. unit tests of the mapping shape).
+ */
+captures) {
     const result = {};
     for (const [name, serverConfig] of Object.entries(config)) {
         if (serverConfig.enabled === false) {
@@ -75,12 +91,34 @@ innerFetch = globalThis.fetch) {
         }
         else if (serverConfig.type === 'remote') {
             const url = serverConfig.url instanceof URL ? serverConfig.url : new URL(serverConfig.url);
+            // Base transport fetch: auth-injecting when an orgJwt is present,
+            // otherwise the bare inner (proxy-aware) fetch.
+            const baseFetch = orgJwt
+                ? createAuthFetch(serverConfig.url, orgJwt, innerFetch, serverConfig.headers)
+                : innerFetch;
+            // Wrap with HTTP-error capture when the harness asked for it, so a
+            // non-2xx connect response's status + body survive the error
+            // `@mastra/mcp` discards (W-23231658). The mapper owns the capture
+            // object's creation and stores it on the supplied map keyed by
+            // server name so the caller can read `latest` back from the matching
+            // `McpServerState`. When no capture map is supplied (e.g.
+            // mapping-shape unit tests) and there's no orgJwt, the def omits
+            // `fetch` entirely — preserving prior behavior.
+            let transportFetch;
+            if (captures) {
+                const capture = {};
+                captures.set(name, capture);
+                transportFetch = wrapFetchWithErrorCapture(baseFetch, capture);
+            }
+            else {
+                transportFetch = orgJwt ? baseFetch : undefined;
+            }
             const def = {
                 url,
                 ...(serverConfig.headers !== undefined && {
                     requestInit: { headers: serverConfig.headers },
                 }),
-                ...(orgJwt && { fetch: createAuthFetch(serverConfig.url, orgJwt, innerFetch, serverConfig.headers) }),
+                ...(transportFetch && { fetch: transportFetch }),
                 ...(serverConfig.timeout !== undefined && {
                     timeout: serverConfig.timeout,
                     connectTimeout: serverConfig.timeout,
@@ -116,4 +154,34 @@ function createAuthFetch(serverUrl, orgJwt, innerFetch, existingHeaders) {
         return innerFetch(url, { ...init, headers: merged });
     };
 }
+/**
+ * Wrap a transport fetch so every non-2xx response's status + body is recorded
+ * into `capture.latest` before the response is handed back to `@mastra/mcp`.
+ * This is the only point where the connect-error body still exists: when the
+ * Streamable-HTTP transport sees a fallback-eligible status it throws a
+ * `StreamableHTTPError(status, ...)`, but `connectHttp` then discards it on the
+ * SSE-fallback path and the harness only ever sees the bodyless generic
+ * `Error("Could not connect...")` (W-23231658, #617).
+ *
+ * The body is read from a clone so the original response stream stays intact for
+ * the transport. A clone-read failure (already-consumed body, network hiccup) is
+ * swallowed — capture is best-effort and must never perturb the real request.
+ */
+function wrapFetchWithErrorCapture(baseFetch, capture) {
+    return async (input, init) => {
+        const response = await baseFetch(input, init);
+        if (!response.ok) {
+            try {
+                const body = await response.clone().text();
+                capture.latest = { status: response.status, body: body.slice(0, MAX_CAPTURED_BODY_CHARS) };
+            }
+            catch {
+                // Body unreadable (already consumed / stream error). Record the
+                // status alone so classification still has the HTTP code.
+                capture.latest = { status: response.status, body: '' };
+            }
+        }
+        return response;
+    };
+}
 //# sourceMappingURL=mcp-config-mapper.js.map

package/dist/mcp-error-classifier.d.ts

@@ -18,13 +18,34 @@ export declare function sanitizeMcpErrorMessage(err: unknown): string;
  *  1. `DOMException` `AbortError` and Node's `code === 'ABORT_ERR'` map to
  *     `'aborted'` regardless of the `.message`.
  *  2. MCP-shaped errors (an `Error` carrying a numeric `code`, see
- *     {@link isMcpErrorLike}) match by JSON-RPC 2.0 code (`-32001` etc.).
+ *     {@link isMcpErrorLike}) match by code: a positive code in `[100, 599]` is
+ *     an HTTP status (see {@link categoryForHttpStatus}); a negative code is a
+ *     JSON-RPC 2.0 error (`-32001` etc.).
  *  3. Free-form `.message` text is matched against substrings the underlying
  *     transports surface (`401`, `403`, `5xx`, `ECONNREFUSED`, etc.). This is
  *     intentionally a small lookup — categories are stable, message shapes
  *     are not, so the heuristic stays narrow and falls back to `'unknown'`.
  */
 export declare function classifyMcpError(err: unknown): McpServerErrorCategory;
+/**
+ * Synthesize an MCP-shaped error (`Error & { code: number }`) from a captured
+ * non-2xx HTTP transport response. `@mastra/mcp`'s `connectHttp` discards the
+ * underlying `StreamableHTTPError` (which carries the HTTP status on `code`)
+ * when the SSE-fallback path also fails, throwing a bodyless generic error
+ * instead. The harness's remote-transport fetch wrapper records the
+ * `{ status, body }` it saw; this rebuilds the shape `classifyMcpError` /
+ * {@link buildMcpErrorDetail} need so the status survives to `McpServerInfo`
+ * and the `mcp-server-discovery-failed` event (W-23231658, #617).
+ *
+ * The resulting message mirrors the MCP SDK's own `StreamableHTTPError` text
+ * (`Streamable HTTP error: ...`) so message-substring consumers see a familiar
+ * shape, and `code` carries the HTTP status so the layered classifier routes it
+ * to `http-4xx` / `http-5xx` / `http-401` / `http-403`. The original generic
+ * error is attached as `cause` so its stack is preserved on the failed event.
+ */
+export declare function synthesizeHttpTransportError(status: number, body: string, cause?: unknown): Error & {
+    code: number;
+};
 /**
  * Build the SDK-side {@link McpServerErrorDetail} from a caught error. The
  * underlying JSON-RPC `code` (when the error is MCP-shaped, see

package/dist/mcp-error-classifier.js

@@ -47,6 +47,27 @@ export function sanitizeMcpErrorMessage(err) {
     // All lines were stack frames — fall back to the raw single-line input.
     return lines[0]?.trim() ?? '';
 }
+/**
+ * Map an HTTP status code to the SDK's stable {@link McpServerErrorCategory}.
+ * HTTP status codes are positive (100–599); JSON-RPC error codes are negative,
+ * so the two never collide on the numeric `code` field. The MCP SDK's
+ * `StreamableHTTPError` carries the HTTP status verbatim on `code`
+ * (`@modelcontextprotocol/sdk` `streamableHttp.js`), and the harness synthesizes
+ * the same shape from a captured remote-transport error body (W-23231658), so a
+ * 404 "org not enabled" surfaces as `http-4xx` + `code: 404` rather than
+ * collapsing to `unknown`.
+ */
+function categoryForHttpStatus(status) {
+    if (status === 401)
+        return 'http-401';
+    if (status === 403)
+        return 'http-403';
+    if (status >= 400 && status <= 499)
+        return 'http-4xx';
+    if (status >= 500 && status <= 599)
+        return 'http-5xx';
+    return 'unknown';
+}
 /**
  * Map a caught error to the SDK's stable {@link McpServerErrorCategory}. The
  * lookup is layered:
@@ -54,7 +75,9 @@ export function sanitizeMcpErrorMessage(err) {
  *  1. `DOMException` `AbortError` and Node's `code === 'ABORT_ERR'` map to
  *     `'aborted'` regardless of the `.message`.
  *  2. MCP-shaped errors (an `Error` carrying a numeric `code`, see
- *     {@link isMcpErrorLike}) match by JSON-RPC 2.0 code (`-32001` etc.).
+ *     {@link isMcpErrorLike}) match by code: a positive code in `[100, 599]` is
+ *     an HTTP status (see {@link categoryForHttpStatus}); a negative code is a
+ *     JSON-RPC 2.0 error (`-32001` etc.).
  *  3. Free-form `.message` text is matched against substrings the underlying
  *     transports surface (`401`, `403`, `5xx`, `ECONNREFUSED`, etc.). This is
  *     intentionally a small lookup — categories are stable, message shapes
@@ -64,6 +87,12 @@ export function classifyMcpError(err) {
     if (isAbortError(err))
         return 'aborted';
     if (isMcpErrorLike(err)) {
+        // HTTP status (positive, 100–599) before the JSON-RPC switch — the two
+        // code spaces are disjoint (JSON-RPC codes are negative), so an HTTP
+        // 404 no longer falls through the JSON-RPC `default` to `unknown`.
+        if (err.code >= 100 && err.code <= 599) {
+            return categoryForHttpStatus(err.code);
+        }
         switch (err.code) {
             case -32001: // RequestTimeout
                 return 'connect-timeout';
@@ -111,6 +140,28 @@ function isCategoryRetriable(category) {
             return true;
     }
 }
+/**
+ * Synthesize an MCP-shaped error (`Error & { code: number }`) from a captured
+ * non-2xx HTTP transport response. `@mastra/mcp`'s `connectHttp` discards the
+ * underlying `StreamableHTTPError` (which carries the HTTP status on `code`)
+ * when the SSE-fallback path also fails, throwing a bodyless generic error
+ * instead. The harness's remote-transport fetch wrapper records the
+ * `{ status, body }` it saw; this rebuilds the shape `classifyMcpError` /
+ * {@link buildMcpErrorDetail} need so the status survives to `McpServerInfo`
+ * and the `mcp-server-discovery-failed` event (W-23231658, #617).
+ *
+ * The resulting message mirrors the MCP SDK's own `StreamableHTTPError` text
+ * (`Streamable HTTP error: ...`) so message-substring consumers see a familiar
+ * shape, and `code` carries the HTTP status so the layered classifier routes it
+ * to `http-4xx` / `http-5xx` / `http-401` / `http-403`. The original generic
+ * error is attached as `cause` so its stack is preserved on the failed event.
+ */
+export function synthesizeHttpTransportError(status, body, cause) {
+    const suffix = body ? `: ${body}` : '';
+    const err = new Error(`Streamable HTTP error: HTTP ${status}${suffix}`, cause !== undefined ? { cause } : undefined);
+    err.code = status;
+    return err;
+}
 /**
  * Build the SDK-side {@link McpServerErrorDetail} from a caught error. The
  * underlying JSON-RPC `code` (when the error is MCP-shaped, see

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/sfdx-agent-harness-mastra",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "Mastra-backed AgentHarness implementation for @salesforce/sfdx-agent-sdk",
   "type": "module",
   "main": "dist/index.js",
@@ -30,32 +30,32 @@
   "dependencies": {
     "@ai-sdk/provider": "^3.0.10",
     "@anthropic-ai/bedrock-sdk": "^0.31.0",
-    "@anthropic-ai/sdk": "^0.105.0",
-    "@mastra/core": "^1.42.0",
-    "@mastra/libsql": "^1.13.0",
+    "@anthropic-ai/sdk": "^0.106.0",
+    "@mastra/core": "^1.47.0",
+    "@mastra/libsql": "^1.14.2",
     "@mastra/mcp": "^1.10.0",
-    "@mastra/memory": "^1.20.3",
+    "@mastra/memory": "^1.21.2",
     "@mastra/schema-compat": "^1.2.11",
     "@salesforce/agentic-common": "0.13.0",
     "openai": "^6.0.0"
   },
   "peerDependencies": {
-    "@salesforce/sfdx-agent-sdk": "0.27.0"
+    "@salesforce/sfdx-agent-sdk": "0.28.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@salesforce/sfdx-agent-sdk": "0.27.0",
+    "@salesforce/sfdx-agent-sdk": "0.28.0",
     "@types/node": "^22.20.0",
     "@vitest/coverage-istanbul": "^4.1.8",
     "@vitest/eslint-plugin": "^1.6.20",
-    "eslint": "^10.5.0",
+    "eslint": "^10.6.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-n": "^18.1.0",
+    "eslint-plugin-n": "^18.2.1",
     "globals": "^17.6.0",
     "lint-staged": "^17.0.7",
-    "prettier": "^3.8.4",
+    "prettier": "^3.9.0",
     "rimraf": "^6.1.3",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",