@salesforce/sfdx-agent-harness-mastra 0.42.0 → 0.43.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 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.43.0] - 2026-08-05
+
+### Tests
+- **agent-sdk,harness-mastra**: e2e suite health — harness matrix, per-harness default model, AWS-eventstream wire parsing @W-23716382@ ([#736](https://github.com/forcedotcom/agentic-dx/pull/736))
+
+### Chores
+- **deps-dev**: bump @types/node from 22.20.0 to 22.20.1 in the dev-dependencies group across 1 directory ([#735](https://github.com/forcedotcom/agentic-dx/pull/735))
+
 ## [0.42.0] - 2026-08-04
 
 ### Chores

package/dist/v3-stream-mapping.js

@@ -3,6 +3,7 @@
  * See LICENSE.txt for license terms.
  */
 import { RealClock, UUIDGenerator } from '@salesforce/agentic-common';
+import { EventStreamCodec } from '@smithy/eventstream-codec';
 /**
  * Shared V3 helpers for the Mastra harness's `LanguageModelV3` implementations
  * — stream-shaping primitives, finish-reason / usage mappers, prompt-translation
@@ -360,6 +361,15 @@ async function observeResponseBody(options) {
     let firstTokenAt;
     let sawOutputText = false;
     let sseBuffer = '';
+    // The Salesforce gateway streams the Bedrock-Anthropic path as AWS binary
+    // event-stream framing, not line-based SSE — the raw `sseBuffer` / `data:`
+    // parser recognizes zero text deltas there (W-23528008 follow-up, #734). A
+    // codec is constructed lazily only for that content-type; every other path
+    // keeps the text-SSE loop untouched.
+    const isAwsEventStream = options.contentType?.toLowerCase().includes('application/vnd.amazon.eventstream') ?? false;
+    const eventStreamCodec = isAwsEventStream
+        ? new EventStreamCodec((buf) => decoder.decode(buf), (str) => new TextEncoder().encode(str))
+        : undefined;
     let cancelled = false;
     let resolveCancelled;
     const cancellation = new Promise((resolve) => {
@@ -397,22 +407,33 @@ async function observeResponseBody(options) {
                 break;
             }
             rawBytes += next.value.byteLength;
-            sseBuffer += decoder.decode(next.value, { stream: true });
-            const parsed = takeSseEvents(sseBuffer);
-            sseBuffer = parsed.remaining;
-            for (const event of parsed.events) {
-                const delta = outputTextDelta(options.providerHint, options.contentType, event);
-                if (delta === undefined)
-                    continue;
+            let deltas;
+            if (eventStreamCodec) {
+                deltas = decodeEventStreamTextDeltas(eventStreamCodec, next.value, options.providerHint);
+            }
+            else {
+                sseBuffer += decoder.decode(next.value, { stream: true });
+                const parsed = takeSseEvents(sseBuffer);
+                sseBuffer = parsed.remaining;
+                deltas = parsed.events
+                    .map((event) => outputTextDelta(options.providerHint, options.contentType, event))
+                    .filter((d) => d !== undefined);
+            }
+            let budgetExceeded = false;
+            for (const delta of deltas) {
                 const deltaBytes = Buffer.byteLength(delta, 'utf8');
                 if (textBytes + deltaBytes > TRACE_BODY_BYTE_BUDGET) {
-                    cancel();
+                    budgetExceeded = true;
                     break;
                 }
                 sawOutputText = true;
                 text.push(delta);
                 textBytes += deltaBytes;
             }
+            if (budgetExceeded) {
+                cancel();
+                break;
+            }
         }
     }
     catch {
@@ -460,6 +481,16 @@ function outputTextDelta(providerHint, contentType, event) {
     if (!contentType?.toLowerCase().includes('text/event-stream') || typeof event !== 'object' || event === null) {
         return undefined;
     }
+    return outputTextDeltaFromEvent(providerHint, event);
+}
+/**
+ * Extract the assistant output-text delta from an already-parsed streaming
+ * event object, without the SSE content-type gate. Shared by the text SSE path
+ * (`outputTextDelta`) and the AWS eventstream path (`observeResponseBody`),
+ * whose decoded chunk payloads are Anthropic events but arrive under
+ * `application/vnd.amazon.eventstream`, not `text/event-stream`.
+ */
+function outputTextDeltaFromEvent(providerHint, event) {
     const candidate = event;
     if (providerHint === 'anthropic' || providerHint === 'bedrock-anthropic') {
         const delta = candidate.delta;
@@ -480,6 +511,48 @@ function outputTextDelta(providerHint, contentType, event) {
     }
     return undefined;
 }
+/**
+ * Drain every complete AWS event-stream frame the codec can now assemble from
+ * `chunk` and return the assistant text deltas within.
+ *
+ * Bedrock's `rest-json1` wire nests two layers inside each binary frame: the
+ * frame body is JSON `{ "bytes": "<base64>" }`, and that base64 decodes to the
+ * Anthropic streaming event (`content_block_delta` / `text_delta`). Non-`chunk`
+ * frames (exceptions, keep-alives) and any frame that fails to decode are
+ * skipped — wire observation is best-effort and must never throw into the
+ * fetch path. The codec verifies prelude + message CRC32 internally and buffers
+ * partial frames across chunk boundaries via `feed()`.
+ */
+function decodeEventStreamTextDeltas(codec, chunk, providerHint) {
+    const deltas = [];
+    try {
+        codec.feed(chunk);
+        const available = codec.getAvailableMessages().getMessages();
+        for (const message of available) {
+            const eventType = message.headers[':event-type'];
+            if (eventType?.type !== 'string' || eventType.value !== 'chunk')
+                continue;
+            try {
+                const envelope = JSON.parse(new TextDecoder().decode(message.body));
+                if (typeof envelope.bytes !== 'string')
+                    continue;
+                const payload = JSON.parse(Buffer.from(envelope.bytes, 'base64').toString('utf8'));
+                if (typeof payload !== 'object' || payload === null)
+                    continue;
+                const delta = outputTextDeltaFromEvent(providerHint, payload);
+                if (delta !== undefined)
+                    deltas.push(delta);
+            }
+            catch {
+                // Unparseable frame payload: skip, don't fail the observation.
+            }
+        }
+    }
+    catch {
+        // Codec framing error (partial/corrupt bytes): skip this chunk.
+    }
+    return deltas;
+}
 function tryDecodeBody(body) {
     if (body === undefined || body === null)
         return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/sfdx-agent-harness-mastra",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "description": "Mastra-backed AgentHarness implementation for @salesforce/sfdx-agent-sdk",
   "type": "module",
   "main": "dist/index.js",
@@ -38,16 +38,17 @@
     "@mastra/memory": "^1.24.0",
     "@mastra/schema-compat": "^1.3.4",
     "@salesforce/agentic-common": "0.15.0",
+    "@smithy/eventstream-codec": "^2.2.0",
     "openai": "^7.0.0"
   },
   "peerDependencies": {
-    "@salesforce/sfdx-agent-sdk": "0.43.0"
+    "@salesforce/sfdx-agent-sdk": "0.44.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@salesforce/harness-conformance": "0.0.1",
-    "@salesforce/sfdx-agent-sdk": "0.43.0",
-    "@types/node": "^22.20.0",
+    "@salesforce/sfdx-agent-sdk": "0.44.0",
+    "@types/node": "^22.20.1",
     "@vitest/coverage-istanbul": "^4.1.10",
     "@vitest/eslint-plugin": "^1.6.26",
     "eslint": "^10.8.0",