@dbx-tools/appkit-mastra 0.6.218 → 0.6.220

package/src/agents.ts

@@ -19,7 +19,12 @@ import { ConfigurationError } from "@databricks/appkit";
 import { plugin } from "@dbx-tools/appkit";
 import { fallback } from "@dbx-tools/model";
 import { log, object, string } from "@dbx-tools/shared-core";
-import type { AgentConfig, ToolsInput } from "@mastra/core/agent";
+import type {
+  AgentConfig,
+  AgentExecutionOptions,
+  AgentInstructions,
+  ToolsInput,
+} from "@mastra/core/agent";
 import { Agent } from "@mastra/core/agent";
 import { MASTRA_RESOURCE_ID_KEY } from "@mastra/core/request-context";
 import type { Tool } from "@mastra/core/tools";
@@ -32,7 +37,7 @@ import type { MastraPluginConfig } from "./config.ts";
 import { buildGenieToolkitProvider, resolveGenieSpaces } from "./genie.ts";
 import type { MemoryBuilder } from "./memory.ts";
 import { buildModel } from "./model.ts";
-import { ResultProcessor, stripStaleChartsProcessor } from "./processors.ts";
+import { stripStaleChartsProcessor } from "./processors.ts";
 import { TYPOGRAPHY_RULE } from "./style.ts";
 import { buildSummarizeTool } from "./summarize.ts";
 import { createWorkspace } from "./workspaces.ts";
@@ -155,7 +160,11 @@ function deriveToolId(description: string): string {
  * workspace carries Databricks skill mounts and Databricks Sandbox command
  * execution. An explicit workspace remains the caller's complete override.
  */
-export function createAgent<T extends MastraAgentDefinition>(def: T): T {
+export function createAgent<
+  TRequestContext extends Record<string, unknown> | unknown = unknown,
+  TDefinition extends MastraAgentDefinition<TRequestContext> =
+    MastraAgentDefinition<TRequestContext>,
+>(def: TDefinition): TDefinition {
   if (def.workspace) return { ...def };
   const workspace = createWorkspace();
   markDefaultWorkspace(workspace);
@@ -260,13 +269,27 @@ export type MastraAgentWorkspaceResolver = () => Workspace | undefined;
  * `config.agents` is the `agentId` the client streams against; `name`
  * is purely informational (defaults to the key).
  */
-export interface MastraAgentDefinition {
+export interface MastraAgentDefinition<
+  TRequestContext extends Record<string, unknown> | unknown = unknown,
+> {
   /** Display name used as `Agent.name`. Defaults to the registry key. */
   name?: string;
   /** Optional long-form description; surfaced as `Agent.description`. */
   description?: string;
-  /** System prompt body. */
-  instructions: string;
+  /** Static or request-context-aware system instructions. */
+  instructions: AgentConfig<string, ToolsInput, undefined, TRequestContext>["instructions"];
+  /** Native Mastra schema that validates and types application request context. */
+  requestContextSchema?: AgentConfig<
+    string,
+    ToolsInput,
+    undefined,
+    TRequestContext
+  >["requestContextSchema"];
+  /**
+   * Mastra-native per-call approval gate for this agent's tools. Supports an
+   * async Classifier-backed function; tool-level approval remains authoritative.
+   */
+  requireToolApproval?: AgentExecutionOptions["requireToolApproval"];
   /**
    * Per-agent model override.
    *
@@ -279,7 +302,7 @@ export interface MastraAgentDefinition {
    *   straight through to `Agent.model`. Use this when you need full
    *   control over auth or providerId.
    */
-  model?: AgentConfig["model"] | string;
+  model?: AgentConfig<string, ToolsInput, undefined, TRequestContext>["model"] | string;
   /**
    * Per-agent tool record. Either a plain map or a callback that
    * receives the typed {@link MastraPlugins} sibling-plugin index and
@@ -323,6 +346,9 @@ export interface MastraAgentDefinition {
   workspace?: Workspace | MastraAgentWorkspaceResolver;
 }
 
+/** Type-erased registry member; each definition retains typing at `createAgent`. */
+export type AnyMastraAgentDefinition = MastraAgentDefinition<any>;
+
 /**
  * Distributive `Omit` so unions in `PostgresStoreConfig` /
  * `PgVectorConfig` keep their discriminants after the override types
@@ -433,13 +459,47 @@ function resolveStyleInstructions(config: MastraPluginConfig): string | null {
   return DEFAULT_STYLE_INSTRUCTIONS;
 }
 
+/** Append the style block without narrowing Mastra's native instruction shapes. */
+function appendStyleInstructions(
+  instructions: AgentInstructions,
+  style: string | null,
+): AgentInstructions {
+  if (!style) return instructions;
+  if (typeof instructions === "string") {
+    return `${instructions.trimEnd()}\n\n${style}`;
+  }
+  if (Array.isArray(instructions)) {
+    if (instructions.every((instruction) => typeof instruction === "string")) {
+      return [...instructions, style] as AgentInstructions;
+    }
+    return [...instructions, { role: "system", content: style }] as AgentInstructions;
+  }
+  return [instructions, { role: "system", content: style }] as AgentInstructions;
+}
+
 /**
- * Join an agent's bespoke instructions with the resolved style block.
- * Returns the bespoke text unchanged when the style block is disabled.
+ * Compose static or request-context-aware instructions with the shared style
+ * policy while preserving Mastra's native generic inference.
  */
-function composeInstructions(agentInstructions: string, style: string | null): string {
-  if (!style) return agentInstructions;
-  return `${agentInstructions.trimEnd()}\n\n${style}`;
+function composeInstructions<TRequestContext extends Record<string, unknown> | unknown>(
+  agentInstructions: AgentConfig<string, ToolsInput, undefined, TRequestContext>["instructions"],
+  style: string | null,
+): AgentConfig<string, ToolsInput, undefined, TRequestContext>["instructions"] {
+  if (typeof agentInstructions !== "function") {
+    return appendStyleInstructions(agentInstructions, style) as AgentConfig<
+      string,
+      ToolsInput,
+      undefined,
+      TRequestContext
+    >["instructions"];
+  }
+  return (async (args) =>
+    appendStyleInstructions(await agentInstructions(args), style)) as AgentConfig<
+    string,
+    ToolsInput,
+    undefined,
+    TRequestContext
+  >["instructions"];
 }
 
 /**
@@ -502,7 +562,6 @@ export async function buildAgents(opts: {
   // chartIds from prior assistant tool results into the new
   // turn's `[chart:<id>]` markers. Opt out per-plugin via
   // `config.stripStaleCharts: false`.
-  const outputProcessors = [new ResultProcessor()];
   const inputProcessors = [
     ...(config.stripStaleCharts === false ? [] : [stripStaleChartsProcessor]),
   ];
@@ -536,15 +595,18 @@ export async function buildAgents(opts: {
       // omits it.
       description: def.description?.trim() || defaultAgentDescription(def.name ?? id),
       instructions: composeInstructions(def.instructions, style),
+      ...(def.requestContextSchema ? { requestContextSchema: def.requestContextSchema } : {}),
       model: resolveModel(config, def.model),
       defaultOptions: {
         maxSteps: config.agentMaxSteps ?? DEFAULT_AGENT_MAX_STEPS,
+        ...(def.requireToolApproval !== undefined
+          ? { requireToolApproval: def.requireToolApproval }
+          : {}),
       },
       tools,
       ...(memory ? { memory } : {}),
       ...(workspace ? { workspace } : {}),
       inputProcessors,
-      outputProcessors,
     });
     // Surface the effective default model per agent so operators can
     // see at a glance which endpoint each agent points at without
@@ -642,7 +704,10 @@ function assertApprovalGatedToolsHaveStorage(
  * overrides (`X-Mastra-Model` etc.) and the workspace-catalogue
  * fuzzy match are still applied at runtime.
  */
-function describeAgentDefaultModel(config: MastraPluginConfig, def: MastraAgentDefinition): string {
+function describeAgentDefaultModel(
+  config: MastraPluginConfig,
+  def: AnyMastraAgentDefinition,
+): string {
   const effective = def.model ?? config.defaultModel;
   if (typeof effective === "string") return effective;
   if (effective !== undefined) return "<dynamic>";
@@ -667,13 +732,13 @@ function describeAgentDefaultModel(config: MastraPluginConfig, def: MastraAgentD
  * Omitted or empty inputs fall back to a single built-in analyst so
  * the bare `mastra()` call still mounts a working chat route.
  */
-function resolveDefinitions(config: MastraPluginConfig): Record<string, MastraAgentDefinition> {
+function resolveDefinitions(config: MastraPluginConfig): Record<string, AnyMastraAgentDefinition> {
   const input = config.agents;
   if (!input) return fallbackDefinitions();
 
   if (Array.isArray(input)) {
     if (input.length === 0) return fallbackDefinitions();
-    const out: Record<string, MastraAgentDefinition> = {};
+    const out: Record<string, AnyMastraAgentDefinition> = {};
     input.forEach((def, i) => {
       const key = deriveAgentKey(def, i);
       if (out[key]) {
@@ -687,21 +752,21 @@ function resolveDefinitions(config: MastraPluginConfig): Record<string, MastraAg
     return out;
   }
 
-  // Single-definition shorthand: an agent always has `instructions: string`,
-  // a record-of-agents never has that field directly.
-  if (typeof (input as MastraAgentDefinition).instructions === "string") {
-    const def = input as MastraAgentDefinition;
+  // Single-definition shorthand: an agent owns the required `instructions`
+  // field (static or dynamic); a record-of-agents never owns it directly.
+  if ("instructions" in input) {
+    const def = input as AnyMastraAgentDefinition;
     const key = deriveAgentKey(def);
     return { [key]: def };
   }
 
-  const record = input as Record<string, MastraAgentDefinition>;
+  const record = input as Record<string, AnyMastraAgentDefinition>;
   if (Object.keys(record).length === 0) return fallbackDefinitions();
   return record;
 }
 
 /** Derive a registry id from a definition's `name`, with a fallback. */
-function deriveAgentKey(def: MastraAgentDefinition, index?: number): string {
+function deriveAgentKey(def: AnyMastraAgentDefinition, index?: number): string {
   if (def.name) {
     const slug = string.toIdentifier(def.name);
     if (slug) return slug;
@@ -710,7 +775,7 @@ function deriveAgentKey(def: MastraAgentDefinition, index?: number): string {
 }
 
 /** Built-in fallback registry used when `agents` is omitted / empty. */
-function fallbackDefinitions(): Record<string, MastraAgentDefinition> {
+function fallbackDefinitions(): Record<string, AnyMastraAgentDefinition> {
   return {
     [FALLBACK_AGENT_ID]: {
       name: "Default Agent",
@@ -738,7 +803,7 @@ function fallbackDefinitions(): Record<string, MastraAgentDefinition> {
  */
 function resolveModel(
   config: MastraPluginConfig,
-  override: MastraAgentDefinition["model"],
+  override: AnyMastraAgentDefinition["model"],
 ): AgentConfig["model"] {
   const effective = override ?? config.defaultModel;
   if (effective === undefined) {
@@ -758,7 +823,7 @@ function resolveModel(
  * survives - the caller already knows which agent was registering.
  */
 async function resolveTools(
-  defTools: MastraAgentDefinition["tools"],
+  defTools: AnyMastraAgentDefinition["tools"],
   plugins: MastraPlugins,
   ambientTools: MastraTools,
 ): Promise<MastraTools> {
@@ -768,7 +833,7 @@ async function resolveTools(
 }
 
 function resolveAgentWorkspace(
-  workspace: MastraAgentDefinition["workspace"],
+  workspace: AnyMastraAgentDefinition["workspace"],
 ): Workspace | undefined {
   if (!workspace) return undefined;
   return typeof workspace === "function" ? workspace() : workspace;

package/src/chat.ts

@@ -0,0 +1,20 @@
+/**
+ * Official Mastra AI SDK chat routes for browser-compatible UI streams.
+ *
+ * @module
+ */
+
+import { routes } from "@dbx-tools/shared-mastra";
+import { chatRoute } from "@mastra/ai-sdk";
+
+/** Register the official AI SDK chat stream plus its approval continuation. */
+export function agentChatRoutes() {
+  const path = `${routes.MASTRA_ROUTES.chat}/:agentId` as `${string}:agentId`;
+  return [
+    chatRoute({
+      path,
+      sendReasoning: true,
+      sendSources: true,
+    }),
+  ];
+}

package/src/config.ts

@@ -22,7 +22,7 @@ import type { RequestContext } from "@mastra/core/request-context";
 import { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY } from "@mastra/core/request-context";
 import type { PgVectorConfig, PostgresStoreConfig } from "@mastra/pg";
 
-import type { MastraAgentDefinition, MastraTools } from "./agents.ts";
+import type { AnyMastraAgentDefinition, MastraTools } from "./agents.ts";
 import type { GenieSpacesConfig } from "./genie.ts";
 import { IDENTITY_MODES, type MastraIdentityMode } from "./identity.ts";
 import type { RemoteSkillsOption } from "./remote-skills.ts";
@@ -252,7 +252,10 @@ export interface MastraPluginConfig extends BasePluginConfig {
    * });
    * ```
    */
-  agents?: Record<string, MastraAgentDefinition> | MastraAgentDefinition | MastraAgentDefinition[];
+  agents?:
+    | Record<string, AnyMastraAgentDefinition>
+    | AnyMastraAgentDefinition
+    | AnyMastraAgentDefinition[];
   /**
    * Ambient tools spread into every registered agent's tools record;
    * per-agent tools win on key collision. Use for a small shared

package/src/genie.ts

@@ -48,10 +48,10 @@ import { plugin } from "@dbx-tools/appkit";
 import { chat, space as genieSpace } from "@dbx-tools/genie";
 import { error, log, string } from "@dbx-tools/shared-core";
 import { genieModel, type GenieMessage } from "@dbx-tools/shared-genie";
-import type { MastraWriter, StartedEvent } from "@dbx-tools/shared-mastra";
+import type { StartedEvent } from "@dbx-tools/shared-mastra";
 import type { RequestContext } from "@mastra/core/request-context";
 import { MASTRA_THREAD_ID_KEY } from "@mastra/core/request-context";
-import { createTool } from "@mastra/core/tools";
+import { createTool, type ToolExecutionContext } from "@mastra/core/tools";
 import { z } from "zod";
 
 import type { MastraTools } from "./agents.ts";
@@ -59,7 +59,7 @@ import { chartPlannerRequestSchema, chartToolOutputSchema, prepareChart } from "
 import { MASTRA_USER_KEY, resolveUserKey } from "./config.ts";
 import type { MastraPluginConfig, User } from "./config.ts";
 import { fetchStatementData } from "./statement.ts";
-import { safeWrite } from "./writer.ts";
+import { safeWriteProgress } from "./writer.ts";
 
 const logger = log.logger("mastra/genie");
 
@@ -96,12 +96,7 @@ export type GenieSpacesConfig = Record<string, GenieSpaceConfig | string>;
  * `abortSignal` (for per-call cancellation).
  */
 type ToolExecuteCtx =
-  | {
-      requestContext?: RequestContext;
-      writer?: MastraWriter;
-      abortSignal?: AbortSignal;
-    }
-  | undefined;
+  Pick<ToolExecutionContext, "requestContext" | "writer" | "abortSignal" | "agent"> | undefined;
 
 /**
  * Pull the per-request {@link WorkspaceClient} off the active
@@ -435,6 +430,7 @@ function buildAskGenieTool(opts: {
       const ctx = ctxRaw as ToolExecuteCtx;
       const { client, requestContext } = requireClient(ctx, toolId);
       const writer = ctx?.writer;
+      const toolCallId = ctx?.agent?.toolCallId;
       const signal = ctx?.abortSignal;
       const threadId = requestContext.get(MASTRA_THREAD_ID_KEY) as string | undefined;
 
@@ -475,7 +471,7 @@ function buildAskGenieTool(opts: {
           spaceId,
           content: question,
         };
-        await safeWrite(logger, writer, startedEvent);
+        await safeWriteProgress(logger, writer, toolCallId, startedEvent);
 
         const runTurn = async (): Promise<GenieMessage> => {
           const seedConversationId = conversationId;
@@ -487,7 +483,7 @@ function buildAskGenieTool(opts: {
             ...(signal ? { context: signal } : {}),
           })) {
             if (event.type !== "message") {
-              await safeWrite(logger, writer, event);
+              await safeWriteProgress(logger, writer, toolCallId, event);
             }
             const eventConversationId = event.conversation_id;
             if (eventConversationId) {

package/src/memory.ts

@@ -39,7 +39,7 @@ import { Memory } from "@mastra/memory";
 import { PgVector, PostgresStore } from "@mastra/pg";
 import { Pool, type PoolConfig } from "pg";
 
-import type { MastraAgentDefinition, MastraMemoryConfigOverride } from "./agents.ts";
+import type { AnyMastraAgentDefinition, MastraMemoryConfigOverride } from "./agents.ts";
 import type { MastraPluginConfig } from "./config.ts";
 import { agentStorageSchemaName } from "./storage-schema.ts";
 import { summaryModel, TITLE_INSTRUCTIONS } from "./summarize.ts";
@@ -143,8 +143,8 @@ export async function createServicePrincipalPool(pgConfig: PoolConfig): Promise<
 }
 
 /** Effective per-knob setting after the plugin/agent cascade. */
-type StorageSetting = MastraAgentDefinition["storage"];
-type MemorySetting = MastraAgentDefinition["memory"];
+type StorageSetting = AnyMastraAgentDefinition["storage"];
+type MemorySetting = AnyMastraAgentDefinition["memory"];
 
 /**
  * True when any plugin-level or per-agent setting could need the
@@ -223,7 +223,7 @@ export class MemoryBuilder {
    * vector store enabled - Mastra accepts a missing `memory` field
    * and treats the agent as stateless.
    */
-  forAgent(agentId: string, def: MastraAgentDefinition): Memory | undefined {
+  forAgent(agentId: string, def: AnyMastraAgentDefinition): Memory | undefined {
     const storageSetting = def.storage ?? this.config.storage;
     const memorySetting = def.memory ?? this.config.memory;
 
@@ -368,14 +368,14 @@ function settingNeedsSharedPool(setting: StorageSetting | MemorySetting | undefi
 }
 
 /** Walk the three shapes of `config.agents` into a flat list. */
-function collectAgentDefinitions(config: MastraPluginConfig): MastraAgentDefinition[] {
+function collectAgentDefinitions(config: MastraPluginConfig): AnyMastraAgentDefinition[] {
   const agents = config.agents;
   if (!agents) return [];
   if (Array.isArray(agents)) return agents;
-  if (typeof (agents as MastraAgentDefinition).instructions === "string") {
-    return [agents as MastraAgentDefinition];
+  if ("instructions" in agents) {
+    return [agents as AnyMastraAgentDefinition];
   }
-  return Object.values(agents as Record<string, MastraAgentDefinition>);
+  return Object.values(agents);
 }
 
 /** Fill in a default `id` when the caller didn't supply one. */

package/src/model.ts

@@ -25,6 +25,7 @@
 
 import { getExecutionContext } from "@databricks/appkit";
 import { classes, invoke, resolve } from "@dbx-tools/model";
+import { ModelServingApi, modelServingApi } from "@dbx-tools/model-rs";
 import { functionModule, json, log, net } from "@dbx-tools/shared-core";
 import { model } from "@dbx-tools/shared-model";
 import type { MastraModelConfig } from "@mastra/core/llm";
@@ -42,6 +43,11 @@ type ModelClass = model.ModelClass;
 const { parseModelClass } = classes;
 const { selectModel } = resolve;
 
+/** Pick the native Databricks inference surface required by a resolved model. */
+export function servingApi(modelId: string): "chat" | "responses" {
+  return modelServingApi(modelId) === ModelServingApi.Responses ? "responses" : "chat";
+}
+
 /** Optional overrides accepted by {@link buildModel}. */
 export interface BuildModelOverrides {
   /**
@@ -128,6 +134,7 @@ export async function buildModel(
     modelId,
     url,
     headers: Object.fromEntries(headers.entries()),
+    api: servingApi(modelId),
   };
 }
 

package/src/plugin.ts

@@ -76,6 +76,7 @@ import type { Pool } from "pg";
 
 import { buildAgents, FALLBACK_AGENT_ID, type BuiltAgents } from "./agents.ts";
 import { fetchChart } from "./chart.ts";
+import { agentChatRoutes } from "./chat.ts";
 import { attributedUserId, MASTRA_CONFIG_SCHEMA, type MastraPluginConfig } from "./config.ts";
 import {
   chartFetchDefaults,
@@ -85,7 +86,6 @@ import {
   statementDataDefaults,
 } from "./defaults.ts";
 import { collectSpaceSuggestions, resolveGenieSpaces } from "./genie.ts";
-import { historyRoute } from "./history.ts";
 import {
   requestUserId,
   resolveIdentityMode,
@@ -105,7 +105,6 @@ import {
 } from "./server.ts";
 import { resolveServingConfig } from "./serving.ts";
 import { fetchStatementData, STATEMENT_ROW_CAP } from "./statement.ts";
-import { threadsRoute } from "./threads.ts";
 import { attachChatTurnTraceIo } from "./trace-io.ts";
 import { invalidFields } from "./validation.ts";
 
@@ -1122,34 +1121,7 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
       app: this.mastraApp,
       mastra: this.mastra,
       prefix: "",
-      customApiRoutes: [
-        // `historyRoute` registers both GET (load) and DELETE
-        // (clear) on the same path, so it returns an array we
-        // splice in.
-        ...historyRoute({
-          path: routes.MASTRA_ROUTES.history,
-          agent: this.built.defaultAgentId,
-        }),
-        // Assert the `:agentId` template type: the per-package build's
-        // NodeNext resolution widens the imported `routes.MASTRA_ROUTES.history`
-        // to `string` (the source/bundler typecheck keeps it a literal),
-        // which would otherwise drop this out of the dynamic-agent
-        // overload and demand a fixed `agent`.
-        ...historyRoute({
-          path: `${routes.MASTRA_ROUTES.history}/:agentId` as `${string}:agentId`,
-        }),
-        // `threadsRoute` registers GET (list the caller's conversation
-        // threads) and DELETE (remove the targeted thread) on the same
-        // path; both the default-agent and dynamic-agent mounts are
-        // spliced in, mirroring the history routes above.
-        ...threadsRoute({
-          path: routes.MASTRA_ROUTES.threads,
-          agent: this.built.defaultAgentId,
-        }),
-        ...threadsRoute({
-          path: `${routes.MASTRA_ROUTES.threads}/:agentId` as `${string}:agentId`,
-        }),
-      ],
+      customApiRoutes: agentChatRoutes(),
     });
     await this.mastraServer.init();
     this.logger.info("ready", {

package/src/processors.ts

@@ -1,21 +1,15 @@
 /**
  * Mastra stream processors wired onto the plugin's agents.
  *
- * Two complementary processors live here:
- *
- * - An **input** processor ({@link stripStaleChartsProcessor}) that
- *   scrubs turn-scoped `chartId` fields out of prior tool results
- *   replayed from Memory, so the model can't copy a stale id into the
- *   new turn's `[chart:<id>]` markers.
- * - An **output** processor ({@link ResultProcessor}) that trims the
- *   bulky, redundant payload fields off targeted outbound stream frames
- *   before they're serialized to the SSE client.
+ * The input processor ({@link stripStaleChartsProcessor}) scrubs turn-scoped
+ * `chartId` fields out of prior tool results replayed from Memory, so the model
+ * cannot copy a stale id into the new turn's `[chart:<id>]` markers.
  *
  * @module
  */
 
 import { log } from "@dbx-tools/shared-core";
-import type { InputProcessor, ProcessInputArgs, Processor } from "@mastra/core/processors";
+import type { InputProcessor, ProcessInputArgs } from "@mastra/core/processors";
 
 const logger = log.logger("mastra/processors");
 
@@ -112,59 +106,3 @@ export const stripStaleChartsProcessor: InputProcessor = {
     return args.messages;
   },
 };
-
-/**
- * Mastra output processor that trims the bulky, redundant payload
- * fields off targeted outbound stream frames.
- *
- * Mastra emits step / finish / tool-result frames whose payloads
- * echo the full tool `output` / `result` / assistant `messages` /
- * `response` - data the chat client already received inline and
- * doesn't need re-sent. This processor empties those keys on the
- * targeted frame types so the outbound SSE stream stays lean;
- * every other frame passes through untouched.
- */
-export class ResultProcessor implements Processor {
-  id = "result-processor";
-
-  // Tell Mastra to also route tool/data parts to this processor method
-  processDataParts = true;
-
-  async processOutputStream({ part }: { part: any }): Promise<any | null> {
-    // 1. Guard clause: Ensure the chunk is a valid object
-    if (!part || typeof part !== "object") {
-      return part;
-    }
-
-    // 2. Filter for the targeted frame types
-    const targetedTypes = ["step-finish", "finish", "tool-result", "data-tool-agent"];
-    if (!targetedTypes.includes(part.type)) {
-      return part; // Return unchanged to pass-through
-    }
-
-    // 3. Check for the presence of a payload object
-    const payload = part.payload;
-    if (!payload || typeof payload !== "object") {
-      return part;
-    }
-
-    // 4. Safely delete the unwanted keys from the payload reference
-    const keysToDelete = ["output", "messages", "response", "result"];
-    for (const key of keysToDelete) {
-      if (key in payload) {
-        const value = payload[key];
-        if (typeof value === "object") {
-          payload[key] = {};
-        } else if (Array.isArray(value)) {
-          payload[key] = [];
-        } else {
-          delete payload[key];
-        }
-      }
-    }
-
-    // 5. Return the modified part object. Mastra handles re-serialization
-    // for the outbound SSE client stream automatically.
-    return part;
-  }
-}