@salesforce/sfdx-agent-harness-mastra 0.83.0 → 0.85.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 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.85.0] - 2026-09-16
+
+### Features
+- **harness-mastra**: wire Claude extended thinking through the Anthropic pass-through @W-24074389@ ([#825](https://github.com/forcedotcom/agentic-dx/pull/825))
+
+## [0.84.0] - 2026-09-16
+
+### Fixes
+- **harness-mastra**: carry toolName on tool-call-delta so AG-UI TOOL_CALL_START isn't blank @W-23954558@ ([#826](https://github.com/forcedotcom/agentic-dx/pull/826))
+
 ## [0.83.0] - 2026-09-16
 
 _No changes — released alongside dependent packages._

package/dist/mastra-event-adapter.d.ts

@@ -56,6 +56,7 @@ import type { ChatEvent } from '@salesforce/sfdx-agent-sdk';
 export declare class MastraEventAdapter {
     private readonly logBus?;
     private stepIndex;
+    private readonly toolNamesByCallId;
     /**
      * @param logBus - Optional structured-log sink. When supplied, the adapter emits a `debug`
      *   log for every chunk it intentionally drops — informational lifecycle events, known-but-

package/dist/mastra-event-adapter.js

@@ -60,6 +60,12 @@ import { isClassifiedStreamError } from './stream-errors.js';
 export class MastraEventAdapter {
     logBus;
     stepIndex = 0;
+    // `toolCallId → toolName`, populated from each `tool-call-input-streaming-start`
+    // chunk. Mastra omits `toolName` from the `tool-call-delta` chunks that follow
+    // (it rides only on the streaming-start), so this lets `tool-call-delta` recover
+    // it — see the `tool-call-delta` case. Per-stream instance, so it never grows
+    // unbounded or leaks across turns.
+    toolNamesByCallId = new Map();
     /**
      * @param logBus - Optional structured-log sink. When supplied, the adapter emits a `debug`
      *   log for every chunk it intentionally drops — informational lifecycle events, known-but-
@@ -208,26 +214,46 @@ export class MastraEventAdapter {
                     toolName: chunk.payload.toolName ?? 'unknown',
                     output: chunk.payload.output,
                 };
-            case 'tool-call-delta':
+            case 'tool-call-delta': {
+                // Mastra drops `toolName` from this chunk — it carries it only on the
+                // preceding `tool-call-input-streaming-start` — so recover it from the
+                // per-stream map. Downstream AG-UI opens its TOOL_CALL_START off the
+                // first delta and can't correct a blank name from the terminal
+                // `tool-call`, so a missing name here surfaces as a blank tool name.
+                // Strict `!== undefined` (not truthy) so an empty-string toolName is
+                // forwarded honestly instead of silently swallowed.
+                const toolName = chunk.payload.toolName ?? this.toolNamesByCallId.get(chunk.payload.toolCallId);
                 return {
                     type: 'tool-call-delta',
                     toolCallId: chunk.payload.toolCallId,
-                    // Strict `!== undefined` (not truthy) so an empty-string
-                    // toolName from upstream — unlikely but possible — is
-                    // forwarded honestly instead of silently swallowed.
-                    ...(chunk.payload.toolName !== undefined ? { toolName: chunk.payload.toolName } : {}),
+                    ...(toolName !== undefined ? { toolName } : {}),
                     argsTextDelta: chunk.payload.argsTextDelta,
                 };
+            }
             // Known harness chunk types not yet supported in the SDK's ChatEvent
             // model. Silently dropped to avoid leaking harness internals onto the
             // public stream. Candidates for future ChatEvent variants when the
             // corresponding features (citations, file generation, tool input
             // lifecycle bookends, tool suspension, structured output) are
             // supported.
-            case 'source':
-            case 'file':
             case 'tool-call-input-streaming-start':
+                // Not surfaced on the public stream, but its `toolName` is the only
+                // place Mastra carries it for the streamed args — stash it so the
+                // following `tool-call-delta` chunks can recover it (see that case).
+                if (chunk.payload.toolName !== undefined) {
+                    this.toolNamesByCallId.set(chunk.payload.toolCallId, chunk.payload.toolName);
+                }
+                this.logBus?.debug('Skipping unsupported Mastra chunk type', { chunkType: chunk.type });
+                return undefined;
             case 'tool-call-input-streaming-end':
+                // End of the streamed-args span: no more deltas for this id will
+                // arrive, and the terminal `tool-call` carries its own name, so drop
+                // the tracked entry to keep the map bounded within a long stream.
+                this.toolNamesByCallId.delete(chunk.payload.toolCallId);
+                this.logBus?.debug('Skipping unsupported Mastra chunk type', { chunkType: chunk.type });
+                return undefined;
+            case 'source':
+            case 'file':
             case 'tool-call-suspended':
             case 'object':
                 this.logBus?.debug('Skipping unsupported Mastra chunk type', { chunkType: chunk.type });

package/dist/pass-through-anthropic.js

@@ -5,7 +5,7 @@
 import { AnthropicBedrock } from '@anthropic-ai/bedrock-sdk';
 import Anthropic from '@anthropic-ai/sdk';
 import { EmptyStreamError, NetworkStreamError, isStreamTransportError, recognizeBedrockValidationError, } from './stream-errors.js';
-import { TextSpanLifecycle, ToolInputSpanLifecycle, buildValidatedToolCallChunk, createGatewayFetch, isEmptyUsage, isParameterExcluded, mapAnthropicFinishReason, mapAnthropicUsage, toolResultOutputToString, } from './v3-stream-mapping.js';
+import { SpanLifecycle, ToolInputSpanLifecycle, buildValidatedToolCallChunk, createGatewayFetch, isEmptyUsage, isParameterExcluded, mapAnthropicFinishReason, mapAnthropicUsage, toolResultOutputToString, } from './v3-stream-mapping.js';
 /**
  * Builds the in-process `LanguageModelV3` impl for the Salesforce LLM Gateway's
  * `/invoke-with-response-stream` (Bedrock-Anthropic pass-through) endpoint.
@@ -170,9 +170,17 @@ async function buildAnthropicRequest(ctx, options) {
         commonParams.system = system;
     if (tools.length > 0)
         commonParams.tools = tools;
+    // Request extended thinking for Claude models that declare a thinking shape
+    // (`Model.thinkingMode`), so the model's planning narration streams back as
+    // `thinking` blocks the response path maps to `reasoning-delta` — reaching
+    // parity with the Claude harness, which drives the same per-model shape.
+    const thinkingEngaged = applyThinkingConfig(commonParams, info.model, info.providerHint);
     // The gateway deprecated `temperature` for Claude Opus 4.7+ and rejects the
-    // request if it's present; drop it when the bound model excludes it.
-    if (options.temperature !== undefined && !isParameterExcluded(info.model, 'temperature')) {
+    // request if it's present; drop it when the bound model excludes it. Anthropic
+    // also rejects a non-default `temperature` whenever extended thinking is on, so
+    // drop it there too (the `enabled`/`adaptive` models that don't already exclude
+    // it — Claude 4.5/4.6 — would otherwise 400 the moment thinking is requested).
+    if (options.temperature !== undefined && !thinkingEngaged && !isParameterExcluded(info.model, 'temperature')) {
         commonParams.temperature = options.temperature;
     }
     if (options.stopSequences !== undefined)
@@ -247,6 +255,57 @@ export function applyCacheBreakpoints(commonParams) {
         }
     }
 }
+/** Reasoning-effort directive paired with the adaptive `thinking` block; the
+ * gateway's Bedrock backend only emits thinking content for Claude 4.6+ when it
+ * is present. `'high'` matches the Claude Agent SDK's own default effort the
+ * Claude harness inherits, so both harnesses drive the same reasoning depth. The
+ * single seam for a future configurable reasoning-effort knob — see ARCHITECTURE.md. */
+const DEFAULT_ADAPTIVE_THINKING_EFFORT = 'high';
+/** Extended-thinking token budget for models on the legacy `enabled` shape
+ * (Claude 4.5). Anthropic requires `budget_tokens` ≥ 1024 and `< max_tokens`;
+ * the value is clamped against the request's `max_tokens` so the answer keeps
+ * room. */
+const DEFAULT_THINKING_BUDGET_TOKENS = 4096;
+const MIN_THINKING_BUDGET_TOKENS = 1024;
+/**
+ * Requests extended thinking on `commonParams` per the bound model's
+ * `Model.thinkingMode`, mirroring the Claude harness's `mapThinkingMode` (which
+ * drives the same per-model shape onto the Claude CLI). Returns whether thinking
+ * was engaged so the caller can suppress `temperature` — Anthropic rejects a
+ * non-default temperature when extended thinking is on.
+ *
+ * The two Anthropic thinking shapes are NOT interchangeable across model
+ * generations, so the shape is a per-model fact carried on `thinkingMode`:
+ * - `'adaptive'` (Claude 4.6+): `{ type: 'adaptive' }` + `output_config.effort`.
+ * - `'enabled'` (Claude 4.5): `{ type: 'enabled', budget_tokens }`, budget
+ *   clamped to `[1024, max_tokens)`; skipped when `max_tokens` can't fit the floor.
+ * - `'disabled'` / `undefined`: no thinking config — the request omits it.
+ *
+ * **Bedrock-only.** Thinking is requested only on the `bedrock-anthropic` gateway
+ * path. The direct first-party `anthropic` path is skipped: it enforces
+ * thinking-block echo-back on tool-use continuations, but `translatePromptToAnthropic`
+ * can't faithfully re-send a prior thinking block (no re-sendable signature in the
+ * summarized reasoning we surface, and Mastra's `reasoning` MessagePart has no slot
+ * to persist one), so enabling it there would 400 multi-turn tool use. Bedrock does
+ * not enforce that rule (verified on `orgfarm-e2e`).
+ */
+function applyThinkingConfig(params, model, providerHint) {
+    if (providerHint !== 'bedrock-anthropic')
+        return false;
+    const mode = model.thinkingMode;
+    if (mode === undefined || mode === 'disabled')
+        return false;
+    if (mode === 'adaptive') {
+        params.thinking = { type: 'adaptive', display: 'summarized' };
+        params.output_config = { ...params.output_config, effort: DEFAULT_ADAPTIVE_THINKING_EFFORT };
+        return true;
+    }
+    const budget = Math.max(MIN_THINKING_BUDGET_TOKENS, Math.min(DEFAULT_THINKING_BUDGET_TOKENS, params.max_tokens - MIN_THINKING_BUDGET_TOKENS));
+    if (budget >= params.max_tokens)
+        return false;
+    params.thinking = { type: 'enabled', budget_tokens: budget };
+    return true;
+}
 async function doGenerate(ctx, options) {
     const { client, commonParams, toolSchemas } = await buildAnthropicRequest(ctx, options);
     // Forward the turn's AbortSignal into the SDK's RequestOptions so firing the
@@ -266,13 +325,16 @@ async function doGenerate(ctx, options) {
         if (block.type === 'text') {
             content.push({ type: 'text', text: block.text });
         }
+        else if (block.type === 'thinking') {
+            content.push({ type: 'reasoning', text: block.thinking });
+        }
         else if (block.type === 'tool_use') {
             sawToolCalls = true;
             const argsBuffer = typeof block.input === 'string' ? block.input : JSON.stringify(block.input ?? {});
             content.push(...buildValidatedToolCallChunk(block.id, block.name, argsBuffer, toolSchemas.get(block.name), ctx.getConsumerToolNames().has(block.name), { retryCounts: ctx.getToolArgsRetryCounts(options), logBus: ctx.logBus }));
         }
-        // Other block types (thinking, server-tool-result, etc.) are not in
-        // the V3 ChatEvent surface — same posture as doStream.
+        // Other block types (redacted_thinking, server-tool-result, etc.) are
+        // not in the V3 ChatEvent surface — same posture as doStream.
     }
     const finishReason = mapAnthropicFinishReason(message.stop_reason, sawToolCalls);
     const usage = mapAnthropicUsage(message.usage);
@@ -321,7 +383,14 @@ async function doStream(ctx, options) {
     }
     const stream = new ReadableStream({
         start: async (controller) => {
-            const textSpan = new TextSpanLifecycle();
+            const textSpan = new SpanLifecycle();
+            // Extended-thinking narration streams on its own V3 reasoning span,
+            // so it surfaces as `reasoning-delta` (→ AG-UI REASONING_MESSAGE_CONTENT)
+            // rather than bleeding into the answer's `text-delta`.
+            const reasoningSpan = new SpanLifecycle('reasoning');
+            // Content-block indexes currently carrying a `thinking` block, so the
+            // matching `content_block_stop` closes the reasoning span.
+            const thinkingIndexes = new Set();
             // Per-content-block buffers — Anthropic streams tool_use input as a
             // sequence of input_json_delta strings on a single content block.
             const toolUseByIndex = new Map();
@@ -353,9 +422,18 @@ async function doStream(ctx, options) {
                                 // (or after a tool_use rotated us forward).
                                 textSpan.openIfNeeded(controller);
                             }
+                            else if (block.type === 'thinking') {
+                                // Thinking blocks precede text/tool_use in the stream; open a
+                                // reasoning span that the matching content_block_stop closes.
+                                thinkingIndexes.add(event.index);
+                                reasoningSpan.openIfNeeded(controller);
+                            }
                             else if (block.type === 'tool_use') {
-                                // A tool_use block follows any open text — close that span and
-                                // bump the id so post-tool text lands in a fresh span.
+                                // A tool_use block follows any open text/reasoning — close those
+                                // spans and bump the text id so post-tool text lands in a fresh
+                                // span. Reasoning normally closes on its own content_block_stop;
+                                // this covers a (non-conformant) interleaved thinking → tool_use.
+                                reasoningSpan.rotate(controller);
                                 textSpan.rotate(controller);
                                 // Stream incremental tool-call arg deltas alongside the
                                 // unchanged terminal `tool-call` (W-23954558); see
@@ -367,8 +445,8 @@ async function doStream(ctx, options) {
                                     input: new ToolInputSpanLifecycle(block.id, block.name, ctx.logBus),
                                 });
                             }
-                            // Other block types (thinking, server-tool result, etc.) are
-                            // intentionally ignored — they're not in the V3 ChatEvent surface.
+                            // Other block types (redacted_thinking, server-tool result, etc.)
+                            // are intentionally ignored — they're not in the V3 ChatEvent surface.
                             break;
                         }
                         case 'content_block_delta': {
@@ -377,6 +455,10 @@ async function doStream(ctx, options) {
                                 textSpan.delta(controller, delta.text);
                                 sawContentOrUsage = true;
                             }
+                            else if (delta.type === 'thinking_delta') {
+                                reasoningSpan.delta(controller, delta.thinking);
+                                sawContentOrUsage = true;
+                            }
                             else if (delta.type === 'input_json_delta') {
                                 const tu = toolUseByIndex.get(event.index);
                                 if (tu) {
@@ -384,12 +466,18 @@ async function doStream(ctx, options) {
                                     tu.input.delta(controller, delta.partial_json);
                                 }
                             }
-                            // thinking_delta / signature_delta / citations_delta are not
-                            // currently surfaced — Mastra has no V3 stream-part for them in
-                            // the chat-generations path either.
+                            // signature_delta / citations_delta are not surfaced — the
+                            // encrypted thinking signature has no V3 stream-part and no
+                            // consumer surface (AG-UI ReasoningEncryptedValue is deferred).
                             break;
                         }
                         case 'content_block_stop': {
+                            if (thinkingIndexes.delete(event.index)) {
+                                // rotate (close + bump id) so a later thinking block in the
+                                // same response opens a fresh reasoning span rather than
+                                // reusing this one's id.
+                                reasoningSpan.rotate(controller);
+                            }
                             const tu = toolUseByIndex.get(event.index);
                             if (tu) {
                                 sawToolCalls = true;
@@ -411,6 +499,7 @@ async function doStream(ctx, options) {
                             break;
                         }
                         case 'message_stop': {
+                            reasoningSpan.closeIfOpen(controller);
                             textSpan.closeIfOpen(controller);
                             const finishReason = mapAnthropicFinishReason(finishRaw, sawToolCalls);
                             const usage = finalizeUsage(mergedUsage, ctx, finishReason.raw);
@@ -430,6 +519,7 @@ async function doStream(ctx, options) {
                 // swallows the abort), and its terminal event is the coordinator's
                 // teardown, not an empty-stream error.
                 if (!terminalEmitted) {
+                    reasoningSpan.closeIfOpen(controller);
                     textSpan.closeIfOpen(controller);
                     if (!sawContentOrUsage && !options.abortSignal?.aborted) {
                         controller.enqueue({
@@ -520,6 +610,15 @@ export function translatePromptToAnthropic(prompt) {
                         input: parseToolInput(tc.input),
                     });
                 }
+                // `reasoning` parts are intentionally NOT re-sent as `thinking` blocks.
+                // Anthropic's first-party API requires a tool-use turn's preceding
+                // thinking block (with its signature) to be echoed back, but the
+                // gateway's Bedrock adaptive path does not enforce this — multi-step
+                // MCP tool loops run green with thinking enabled (orgfarm-e2e). A faithful
+                // echo isn't achievable here anyway: the summarized reasoning we surface
+                // carries no re-sendable signature, and Mastra's `reasoning` MessagePart
+                // has no signature slot to persist one across turns. Emitting a thinking
+                // block without a valid signature would 400 — strictly worse than dropping it.
             }
             if (blocks.length > 0)
                 messages.push({ role: 'assistant', content: blocks });

package/dist/pass-through-openai-chat-completions.js

@@ -4,7 +4,7 @@
  */
 import OpenAI from 'openai';
 import { EmptyStreamError } from './stream-errors.js';
-import { TextSpanLifecycle, ToolInputSpanLifecycle, buildValidatedToolCallChunk, createGatewayFetch, isEmptyUsage, isParameterExcluded, mapOpenAIUsage, toolResultOutputToString, } from './v3-stream-mapping.js';
+import { SpanLifecycle, ToolInputSpanLifecycle, buildValidatedToolCallChunk, createGatewayFetch, isEmptyUsage, isParameterExcluded, mapOpenAIUsage, toolResultOutputToString, } from './v3-stream-mapping.js';
 /**
  * Builds the in-process `LanguageModelV3` impl that drives the `openai` SDK's
  * `chat.completions.create({ stream: true })` against an OpenAI-compatible
@@ -137,7 +137,7 @@ async function doStream(ctx, options) {
     const sdkStream = await client.chat.completions.create(params, { signal: options.abortSignal });
     const stream = new ReadableStream({
         start: async (controller) => {
-            const textSpan = new TextSpanLifecycle();
+            const textSpan = new SpanLifecycle();
             // Tool calls accumulate across delta chunks. Chat Completions delivers
             // them keyed by `index` on the delta; the upstream may also report `id`
             // and `function.name` on the first delta and only `function.arguments`

package/dist/pass-through-openai.js

@@ -4,7 +4,7 @@
  */
 import OpenAI from 'openai';
 import { EmptyStreamError, GatewayResponseError } from './stream-errors.js';
-import { TextSpanLifecycle, ToolInputSpanLifecycle, buildValidatedToolCallChunk, createGatewayFetch, isEmptyUsage, isParameterExcluded, mapOpenAIFinishReason, mapOpenAIUsage, toolResultOutputToString, } from './v3-stream-mapping.js';
+import { SpanLifecycle, ToolInputSpanLifecycle, buildValidatedToolCallChunk, createGatewayFetch, isEmptyUsage, isParameterExcluded, mapOpenAIFinishReason, mapOpenAIUsage, toolResultOutputToString, } from './v3-stream-mapping.js';
 /**
  * Builds the in-process `LanguageModelV3` impl that drives the `openai` SDK's
  * `responses.create({ stream: true })` against the Salesforce LLM Gateway's
@@ -120,7 +120,7 @@ async function doStream(ctx, options) {
     const sdkStream = await client.responses.create(params, { signal: options.abortSignal });
     const stream = new ReadableStream({
         start: async (controller) => {
-            const textSpan = new TextSpanLifecycle();
+            const textSpan = new SpanLifecycle();
             // Tool-call output_items, keyed by their `item_id`. Populated on
             // `output_item.added(type=function_call)`, args buffered on
             // `function_call_arguments.delta`, finalized on `output_item.done`.

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

@@ -27,25 +27,32 @@ import type { Model } from '@salesforce/sfdx-agent-sdk';
  * deprecated parameter declare `excludedParameters`.
  */
 export declare function isParameterExcluded(model: Model, parameter: string): boolean;
+/** The AI SDK V3 span kinds this lifecycle drives — `text` for assistant
+ * answer text, `reasoning` for extended-thinking narration. Both share the
+ * identical `${kind}-start` / `${kind}-delta` / `${kind}-end` shape. */
+export type SpanKind = 'text' | 'reasoning';
 /**
- * Encodes the AI SDK V3 text-span lifecycle (`text-start` / `text-delta` /
- * `text-end`) and the rotation that must happen around tool calls.
+ * Encodes an AI SDK V3 content-span lifecycle (`${kind}-start` /
+ * `${kind}-delta` / `${kind}-end`) and the rotation that must happen around
+ * tool calls.
  *
- * V3 requires every `text-delta` to sit between a matching `text-start` /
- * `text-end` pair sharing the same `id`. When tool calls land mid-stream the
+ * V3 requires every `${kind}-delta` to sit between a matching `${kind}-start` /
+ * `${kind}-end` pair sharing the same `id`. When tool calls land mid-stream the
  * current span MUST be closed before the tool-call parts land, and the next
- * text delta MUST open a fresh span with a new id. This class owns the
- * `open` / `id` state machine so every `LanguageModelV3` impl shares one
- * encoding.
+ * delta MUST open a fresh span with a new id. This class owns the `open` / `id`
+ * state machine so every `LanguageModelV3` impl shares one encoding for both
+ * assistant text and reasoning (Anthropic `thinking`) spans.
  */
-export declare class TextSpanLifecycle {
+export declare class SpanLifecycle {
+    private readonly kind;
     private open;
     private id;
+    constructor(kind?: SpanKind);
     /** Open a span if none is open. No-op when a span is already open. */
     openIfNeeded(controller: {
         enqueue: (part: LanguageModelV3StreamPart) => void;
     }): void;
-    /** Emit a `text-delta`. Opens a span first if none is open. */
+    /** Emit a `${kind}-delta`. Opens a span first if none is open. */
     delta(controller: {
         enqueue: (part: LanguageModelV3StreamPart) => void;
     }, text: string): void;

package/dist/v3-stream-mapping.js

@@ -36,36 +36,41 @@ export function isParameterExcluded(model, parameter) {
     return model.excludedParameters?.includes(parameter) ?? false;
 }
 /**
- * Encodes the AI SDK V3 text-span lifecycle (`text-start` / `text-delta` /
- * `text-end`) and the rotation that must happen around tool calls.
+ * Encodes an AI SDK V3 content-span lifecycle (`${kind}-start` /
+ * `${kind}-delta` / `${kind}-end`) and the rotation that must happen around
+ * tool calls.
  *
- * V3 requires every `text-delta` to sit between a matching `text-start` /
- * `text-end` pair sharing the same `id`. When tool calls land mid-stream the
+ * V3 requires every `${kind}-delta` to sit between a matching `${kind}-start` /
+ * `${kind}-end` pair sharing the same `id`. When tool calls land mid-stream the
  * current span MUST be closed before the tool-call parts land, and the next
- * text delta MUST open a fresh span with a new id. This class owns the
- * `open` / `id` state machine so every `LanguageModelV3` impl shares one
- * encoding.
+ * delta MUST open a fresh span with a new id. This class owns the `open` / `id`
+ * state machine so every `LanguageModelV3` impl shares one encoding for both
+ * assistant text and reasoning (Anthropic `thinking`) spans.
  */
-export class TextSpanLifecycle {
+export class SpanLifecycle {
+    kind;
     open = false;
     id = 0;
+    constructor(kind = 'text') {
+        this.kind = kind;
+    }
     /** Open a span if none is open. No-op when a span is already open. */
     openIfNeeded(controller) {
         if (this.open)
             return;
-        controller.enqueue({ type: 'text-start', id: this.spanId() });
+        controller.enqueue({ type: `${this.kind}-start`, id: this.spanId() });
         this.open = true;
     }
-    /** Emit a `text-delta`. Opens a span first if none is open. */
+    /** Emit a `${kind}-delta`. Opens a span first if none is open. */
     delta(controller, text) {
         this.openIfNeeded(controller);
-        controller.enqueue({ type: 'text-delta', delta: text, id: this.spanId() });
+        controller.enqueue({ type: `${this.kind}-delta`, delta: text, id: this.spanId() });
     }
     /** Close the open span (if any). No-op when no span is open. */
     closeIfOpen(controller) {
         if (!this.open)
             return;
-        controller.enqueue({ type: 'text-end', id: this.spanId() });
+        controller.enqueue({ type: `${this.kind}-end`, id: this.spanId() });
         this.open = false;
     }
     /**
@@ -78,7 +83,7 @@ export class TextSpanLifecycle {
         this.id++;
     }
     spanId() {
-        return `text-${this.id}`;
+        return `${this.kind}-${this.id}`;
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/sfdx-agent-harness-mastra",
-  "version": "0.83.0",
+  "version": "0.85.0",
   "description": "Mastra-backed AgentHarness implementation for @salesforce/sfdx-agent-sdk",
   "type": "module",
   "main": "dist/index.js",
@@ -42,12 +42,12 @@
     "openai": "^7.0.0"
   },
   "peerDependencies": {
-    "@salesforce/sfdx-agent-sdk": "0.84.0"
+    "@salesforce/sfdx-agent-sdk": "0.86.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@salesforce/harness-conformance": "0.0.1",
-    "@salesforce/sfdx-agent-sdk": "0.84.0",
+    "@salesforce/sfdx-agent-sdk": "0.86.0",
     "@types/node": "^22.20.1",
     "@vitest/coverage-istanbul": "^4.1.11",
     "@vitest/eslint-plugin": "^1.6.27",