@salesforce/sfdx-agent-harness-mastra 0.89.0 → 0.91.0

package/CHANGELOG.md

@@ -3,6 +3,19 @@
 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.91.0] - 2026-09-24
+
+### Features
+- **agent-sdk,harness-mastra,harness-openai,harness-claude**: stable chatId across compaction — compact in place, never rotate the thread id @W-24153851@ ([#840](https://github.com/forcedotcom/agentic-dx/pull/840))
+
+## [0.90.0] - 2026-09-23
+
+### Fixes
+- **harness-mastra**: emit full llm-request body in wire-communication events (remove 256KB truncation) @W-24280587@ ([#839](https://github.com/forcedotcom/agentic-dx/pull/839))
+
+### Chores
+- **deps**: bump @ai-sdk/provider from 4.0.4 to 4.0.14 ([#838](https://github.com/forcedotcom/agentic-dx/pull/838))
+
 ## [0.89.0] - 2026-09-21
 
 ### Features

package/dist/mastra-harness.d.ts

@@ -464,17 +464,17 @@ export declare class MastraHarness implements MastraAgentHarness {
     /**
      * @requirements
      * - MUST throw an error if the specified `agentId` is not found in `activeAgents`.
-     * - MUST create a new thread seeded with an LLM-generated summary.
+     * - MUST compact the thread IN PLACE, keeping the same `threadId` (a SQLite
+     *   row PK) so `getId()` never changes across compaction (W-24153851).
      * - MUST chunk-summarize transcripts that exceed `MAX_TRANSCRIPT_CHARS`
      *   to keep any single model call inside the context window.
-     * - MUST surface summarization or seeding failures as `AgentSDKError`
-     *   with type `COMPACTION_FAILED` and leave the source thread intact on
-     *   failure.
-     * - MUST destroy the source thread on success so it no longer appears in
-     *   `getThreadIds()`. Cleanup of the source thread is best-effort: if the
-     *   delete fails the new thread is still returned, since the user's data
-     *   has already been persisted there. An orphaned source thread is
-     *   hygiene, not correctness.
+     * - MUST surface summarization or commit failures as `AgentSDKError`
+     *   with type `COMPACTION_FAILED` and leave the transcript intact on failure.
+     * - MUST be fail-closed: summarize FIRST (read-only), then
+     *   append-the-summary-then-delete-the-originals (append-then-delete-by-
+     *   captured-id, NOT a re-recall). LibSQL has no atomic multi-row swap, so a
+     *   crash after the append leaves BOTH the summary and the originals
+     *   (retryable, larger-but-valid) — never an empty thread.
      * - MUST seed the summary as a user/assistant turn pair where the user
      *   turn carries the summary content and the assistant turn is a brief
      *   acknowledgment. Storing the summary as an assistant turn (even with
@@ -483,7 +483,7 @@ export declare class MastraHarness implements MastraAgentHarness {
      *   it as fabricated, refusing to use the facts on follow-up turns.
      *   User turns are treated as authoritative input.
      */
-    compactThread(agentId: string, threadId: string): Promise<string>;
+    compactThread(agentId: string, threadId: string): Promise<void>;
     /**
      * Best-effort wrapper around `destroyThread`: swallows the error so the
      * caller's outer flow isn't aborted by a teardown blip, but logs the

package/dist/mastra-harness.js

@@ -1429,17 +1429,17 @@ export class MastraHarness {
     /**
      * @requirements
      * - MUST throw an error if the specified `agentId` is not found in `activeAgents`.
-     * - MUST create a new thread seeded with an LLM-generated summary.
+     * - MUST compact the thread IN PLACE, keeping the same `threadId` (a SQLite
+     *   row PK) so `getId()` never changes across compaction (W-24153851).
      * - MUST chunk-summarize transcripts that exceed `MAX_TRANSCRIPT_CHARS`
      *   to keep any single model call inside the context window.
-     * - MUST surface summarization or seeding failures as `AgentSDKError`
-     *   with type `COMPACTION_FAILED` and leave the source thread intact on
-     *   failure.
-     * - MUST destroy the source thread on success so it no longer appears in
-     *   `getThreadIds()`. Cleanup of the source thread is best-effort: if the
-     *   delete fails the new thread is still returned, since the user's data
-     *   has already been persisted there. An orphaned source thread is
-     *   hygiene, not correctness.
+     * - MUST surface summarization or commit failures as `AgentSDKError`
+     *   with type `COMPACTION_FAILED` and leave the transcript intact on failure.
+     * - MUST be fail-closed: summarize FIRST (read-only), then
+     *   append-the-summary-then-delete-the-originals (append-then-delete-by-
+     *   captured-id, NOT a re-recall). LibSQL has no atomic multi-row swap, so a
+     *   crash after the append leaves BOTH the summary and the originals
+     *   (retryable, larger-but-valid) — never an empty thread.
      * - MUST seed the summary as a user/assistant turn pair where the user
      *   turn carries the summary content and the assistant turn is a brief
      *   acknowledgment. Storing the summary as an assistant turn (even with
@@ -1449,49 +1449,54 @@ export class MastraHarness {
      *   User turns are treated as authoritative input.
      */
     async compactThread(agentId, threadId) {
-        this.getAgentStateOrThrow(agentId);
-        const messages = await this.getMessages(agentId, threadId);
-        if (messages.length === 0) {
-            const newThreadId = await this.createThread(agentId);
-            // An empty transcript can still carry session context (it's set
-            // independently of messages), so carry it forward here too — before
-            // the source is retired, and fail-closed (source left intact on a
-            // copy failure) to match the main path's COMPACTION_FAILED contract.
-            try {
-                await this.carrySessionContextForward(agentId, threadId, newThreadId);
-            }
-            catch (err) {
-                // The new thread was already created; a carry-forward failure
-                // orphans it (never returned, never retired). Delete it before
-                // surfacing COMPACTION_FAILED so a failed compaction leaves no
-                // trace beyond the still-intact source thread.
-                await this.destroyThreadBestEffort(agentId, newThreadId);
-                throw new AgentSDKError(`Failed to compact thread "${threadId}" for agent "${agentId}": ${getErrorMessage(err)}`, AgentSDKErrorType.COMPACTION_FAILED, { cause: err });
-            }
-            // Empty source still gets compacted away — leaving it attached
-            // would be a leak. Mirrors the non-empty path's destroyThread
-            // call below; both paths exit with the source detached.
-            await this.destroyThreadBestEffort(agentId, threadId);
-            return newThreadId;
+        const agentState = this.getAgentStateOrThrow(agentId);
+        // Defense-in-depth against a direct-SDK caller: refuse to rewrite the
+        // transcript out from under an in-flight turn. The SDK's one-turn guard
+        // (auto path) and the service's 409 on an explicit /compact during a turn
+        // already exclude this upstream. Fail fast rather than dispose a live
+        // coordinator (that surfaces a spurious DISPOSED — W-24044572). Mirrors
+        // stream()'s guard.
+        const priorCoordinator = agentState.coordinators.get(threadId);
+        if (priorCoordinator && !priorCoordinator.isSettled()) {
+            throw new AgentSDKError(`A turn is already in progress for thread "${threadId}" on agent "${agentId}". ` +
+                'Compaction cannot run while a turn is active; await the in-flight turn first.', AgentSDKErrorType.SESSION_BUSY);
         }
+        const messages = await this.getMessages(agentId, threadId);
+        // Empty source: nothing to compact. In-place keeps the same threadId and
+        // its (physically-disjoint) session-context store, so this is a no-op.
+        if (messages.length === 0)
+            return;
         const transcript = messages
             .map((m) => {
             const text = typeof m.content === 'string' ? m.content : m.content.map((p) => partToTranscriptText(p)).join(' ');
             return `${m.role}: ${text}`;
         })
             .join('\n');
-        // `undefined` until `createThread` succeeds, so the catch can tell a
-        // pre-create failure (nothing to clean up) from a post-create failure
-        // (the new thread is orphaned and must be deleted).
-        let newThreadId;
         try {
+            // Capture the ORIGINAL persisted (raw) message ids to delete after
+            // the summary is appended. Raw recall ids — not `getMessages()`'s
+            // post-mapped ids, which split a tool call into two SDK messages —
+            // are what `memory.deleteMessages` keys on. Captured before the
+            // append so the summary pair's freshly-minted ids are never in the
+            // delete set.
+            const memory = await this.getMemoryOrThrow(agentId);
+            const { messages: rawMessages } = await memory.recall({
+                threadId,
+                resourceId: this.agentResourceId(agentId),
+                perPage: false,
+            });
+            const originalIds = rawMessages.map((m) => m.id);
+            // Summarize FIRST (read-only). No mutation has happened yet, so a
+            // summary failure leaves the transcript fully intact.
             const summaryText = transcript.length <= MAX_TRANSCRIPT_CHARS
                 ? await this.summarize(agentId, buildSummaryPrompt(transcript))
                 : await this.summarizeInChunks(agentId, transcript);
-            newThreadId = await this.createThread(agentId);
+            // Append the summary pair to the SAME thread, THEN delete the
+            // originals by captured id. A crash between the two leaves both
+            // (retryable), never an empty thread.
             const userTs = this.clock.now();
             const assistantTs = this.clock.nextAfter(userTs);
-            await this.addMessages(agentId, newThreadId, [
+            await this.addMessages(agentId, threadId, [
                 {
                     id: this.idGenerator.getUniqueId(),
                     role: 'user',
@@ -1505,26 +1510,18 @@ export class MastraHarness {
                     createdAt: assistantTs,
                 },
             ]);
-            // Carry the source thread's session context onto the compacted thread
-            // before the source is retired. Inside the try so a copy failure is
-            // fail-closed (surfaces as COMPACTION_FAILED, source left intact).
-            await this.carrySessionContextForward(agentId, threadId, newThreadId);
+            if (originalIds.length > 0) {
+                await memory.deleteMessages(originalIds);
+            }
         }
         catch (err) {
-            // If the failure came after `createThread`, the new thread is
-            // orphaned (never returned to the caller, source not yet retired).
-            // Delete it so a failed compaction leaves no trace beyond the
-            // still-intact source thread.
-            if (newThreadId !== undefined) {
-                await this.destroyThreadBestEffort(agentId, newThreadId);
-            }
             throw new AgentSDKError(`Failed to compact thread "${threadId}" for agent "${agentId}": ${getErrorMessage(err)}`, AgentSDKErrorType.COMPACTION_FAILED, { cause: err });
         }
-        // Source-thread cleanup is best-effort. The user's data is already
-        // safely seeded into newThreadId; a failed delete leaves an orphan
-        // but does not invalidate the compaction outcome.
-        await this.destroyThreadBestEffort(agentId, threadId);
-        return newThreadId;
+        // Reset the per-thread consumer-tool retry counter — the rotation-based
+        // compaction used to get this for free via destroyThread; an in-place
+        // compaction keeps the thread, so reset it explicitly. The transcript the
+        // counts described is gone.
+        this.toolArgsRetryCounts.get(agentId)?.delete(threadId);
     }
     /**
      * Best-effort wrapper around `destroyThread`: swallows the error so the

package/dist/v3-stream-mapping.d.ts

@@ -280,11 +280,13 @@ export type GatewayFetchWireHooks = {
  * fetch resolution to HTTP-body terminality: an owned tee branch observes only
  * recognized assistant text deltas without blocking the provider SDK's branch.
  * Wire-communication events are best-effort: a failed body decode does NOT
- * prevent the call from completing. Body capture is
- * intentionally bounded — only requests with a JSON body shorter than 256 KB
- * are decoded; longer bodies are recorded as `{ truncated: true, byteLength:
- * <n> }` so wire-communication captures don't blow the consumer's log file
- * budget.
+ * prevent the call from completing. When a subscriber is present the request
+ * body is captured in full with no size cap (W-24280587) — the channel is
+ * opt-in and diagnostic, so fidelity wins; with no subscriber the decode is
+ * skipped entirely (the event is dropped by the wire bus anyway), so a
+ * subscriber-less production process pays no full-body parse on the hot path.
+ * (The streaming *response* observer separately bounds its in-memory text
+ * capture at `TRACE_BODY_BYTE_BUDGET`.)
  */
 export declare function createGatewayFetch(getHeaders: () => Record<string, string> | Promise<Record<string, string>>, wireHooks?: GatewayFetchWireHooks, innerFetch?: typeof fetch, 
 /**

package/dist/v3-stream-mapping.js

@@ -353,11 +353,13 @@ export function mapOpenAIUsage(usage) {
  * fetch resolution to HTTP-body terminality: an owned tee branch observes only
  * recognized assistant text deltas without blocking the provider SDK's branch.
  * Wire-communication events are best-effort: a failed body decode does NOT
- * prevent the call from completing. Body capture is
- * intentionally bounded — only requests with a JSON body shorter than 256 KB
- * are decoded; longer bodies are recorded as `{ truncated: true, byteLength:
- * <n> }` so wire-communication captures don't blow the consumer's log file
- * budget.
+ * prevent the call from completing. When a subscriber is present the request
+ * body is captured in full with no size cap (W-24280587) — the channel is
+ * opt-in and diagnostic, so fidelity wins; with no subscriber the decode is
+ * skipped entirely (the event is dropped by the wire bus anyway), so a
+ * subscriber-less production process pays no full-body parse on the hot path.
+ * (The streaming *response* observer separately bounds its in-memory text
+ * capture at `TRACE_BODY_BYTE_BUDGET`.)
  */
 export function createGatewayFetch(getHeaders, wireHooks, innerFetch = globalThis.fetch, 
 /**
@@ -411,6 +413,13 @@ logBus) {
         const startedAt = clock.now();
         const correlationId = (wireHooks.idGenerator ?? new UUIDGenerator()).getUniqueId();
         const requestStart = performance.now();
+        // Decode the (now uncapped) request body ONLY when a subscriber is
+        // listening — mirroring the response-observer gating below. In production
+        // `wireHooks` is always supplied but subscribers are usually absent, and a
+        // real turn's body is large, so an unconditional full-body JSON.parse would
+        // be pure hot-path waste for a subscriber-less process (the event is dropped
+        // by the wire bus anyway). Fidelity for actual subscribers is unchanged.
+        const hasWireSubscribers = wireHooks.hasWireCommunicationSubscribers?.() ?? true;
         wireHooks.emitWireCommunication({
             type: 'llm-request',
             timestamp: startedAt,
@@ -418,7 +427,7 @@ logBus) {
             method,
             model,
             correlationId,
-            body: tryDecodeBody(finalInit.body),
+            body: hasWireSubscribers ? tryDecodeBody(finalInit.body) : undefined,
         });
         try {
             const response = await innerFetch(input, finalInit);
@@ -791,10 +800,11 @@ function tryDecodeBody(body) {
         return undefined;
     if (typeof body !== 'string')
         return undefined; // Streams / FormData / Blob: skip.
-    const byteLength = Buffer.byteLength(body, 'utf8');
-    if (byteLength > TRACE_BODY_BYTE_BUDGET) {
-        return { truncated: true, byteLength };
-    }
+    // No size cap: the wire-communication channel is opt-in, subscriber-gated, and
+    // purely diagnostic — its whole point is fidelity, so emit the full request body
+    // (system / messages / tools) verbatim. (W-24280587; a 256 KB cap here used to
+    // replace large bodies with a `{ truncated, byteLength }` stub, hiding exactly
+    // the fields the channel exists to show.)
     try {
         const parsed = JSON.parse(body);
         return typeof parsed === 'object' && parsed !== null ? parsed : { value: parsed };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/sfdx-agent-harness-mastra",
-  "version": "0.89.0",
+  "version": "0.91.0",
   "description": "Mastra-backed AgentHarness implementation for @salesforce/sfdx-agent-sdk",
   "type": "module",
   "main": "dist/index.js",
@@ -29,7 +29,7 @@
     "LICENSE.txt"
   ],
   "dependencies": {
-    "@ai-sdk/provider": "4.0.4",
+    "@ai-sdk/provider": "4.0.14",
     "@anthropic-ai/bedrock-sdk": "^0.33.6",
     "@anthropic-ai/sdk": "^0.126.0",
     "@mastra/core": "^1.67.0",
@@ -42,12 +42,12 @@
     "openai": "^7.17.0"
   },
   "peerDependencies": {
-    "@salesforce/sfdx-agent-sdk": "0.90.0"
+    "@salesforce/sfdx-agent-sdk": "0.92.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@salesforce/harness-conformance": "0.0.1",
-    "@salesforce/sfdx-agent-sdk": "0.90.0",
+    "@salesforce/sfdx-agent-sdk": "0.92.0",
     "@types/node": "^22.20.1",
     "@vitest/coverage-istanbul": "^5.0.1",
     "@vitest/eslint-plugin": "^1.6.27",