@dbx-tools/appkit-mastra 0.9.182 → 0.9.184

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,13 +1,21 @@
1
1
  /**
2
2
  * Mastra stream processors wired onto the plugin's agents.
3
3
  *
4
- * The input processor ({@link stripStaleChartsProcessor}) scrubs turn-scoped
5
- * `chartId` fields out of prior tool results replayed from Memory, so the model
6
- * cannot copy a stale id into the new turn's `[chart:<id>]` markers.
4
+ * Input processors apply provider-aware reasoning defaults, remove incompatible
5
+ * provider continuation state, and scrub turn-scoped chart ids from Memory.
7
6
  *
8
7
  * @module
9
8
  */
10
- import type { InputProcessor } from "@mastra/core/processors";
9
+ import { ProviderHistoryCompat } from "@mastra/core/processors";
10
+ import type { CompatRule, InputProcessor } from "@mastra/core/processors";
11
+ /** Add stateless Responses defaults only after Mastra resolves the step model. */
12
+ export declare function buildResponsesProviderOptionsProcessor(sendReasoning: boolean): InputProcessor;
13
+ /** Omit incomplete thoughts and raw reasoning content that Responses cannot replay. */
14
+ export declare const sanitizeResponsesReasoningReplay: CompatRule;
15
+ /** Remove Responses continuation state produced by a different concrete model. */
16
+ export declare const stripForeignResponsesState: CompatRule;
17
+ /** Mastra-owned compatibility processor extended for Databricks Responses routing. */
18
+ export declare const providerHistoryCompatProcessor: ProviderHistoryCompat;
11
19
  /**
12
20
  * Mastra input processor that strips `chartId` fields from every
13
21
  * tool-invocation result in prior assistant messages before they
@@ -1,14 +1,254 @@
1
1
  /**
2
2
  * Mastra stream processors wired onto the plugin's agents.
3
3
  *
4
- * The input processor ({@link stripStaleChartsProcessor}) scrubs turn-scoped
5
- * `chartId` fields out of prior tool results replayed from Memory, so the model
6
- * cannot copy a stale id into the new turn's `[chart:<id>]` markers.
4
+ * Input processors apply provider-aware reasoning defaults, remove incompatible
5
+ * provider continuation state, and scrub turn-scoped chart ids from Memory.
7
6
  *
8
7
  * @module
9
8
  */
10
- import { log } from "@dbx-tools/shared-core";
9
+ import { isRecord, log } from "@dbx-tools/shared-core";
10
+ import { ProviderHistoryCompat } from "@mastra/core/processors";
11
+ import { RESPONSES_PROVIDER_OPTIONS } from "./model.js";
11
12
  const logger = log.logger("mastra/processors");
13
+ const RESPONSES_PROVIDER_SUFFIX = ".responses";
14
+ const MODEL_BOUND_PROVIDER_FIELDS = [
15
+ "itemId",
16
+ "resultItemId",
17
+ "reasoningEncryptedContent",
18
+ ];
19
+ function asRecord(value) {
20
+ return isRecord(value) ? value : undefined;
21
+ }
22
+ function responsesProviderName(model) {
23
+ const provider = asRecord(model)?.provider;
24
+ if (typeof provider !== "string" || !provider.endsWith(RESPONSES_PROVIDER_SUFFIX)) {
25
+ return undefined;
26
+ }
27
+ return provider.slice(0, -RESPONSES_PROVIDER_SUFFIX.length);
28
+ }
29
+ /** Add stateless Responses defaults only after Mastra resolves the step model. */
30
+ export function buildResponsesProviderOptionsProcessor(sendReasoning) {
31
+ return {
32
+ id: "databricks-responses-provider-options",
33
+ description: "Applies stateless replay and visible reasoning defaults to Databricks Responses models.",
34
+ processInputStep(args) {
35
+ const providerName = responsesProviderName(args.model);
36
+ if (!providerName)
37
+ return;
38
+ const existing = args.providerOptions?.[providerName] ?? {};
39
+ const next = {
40
+ ...RESPONSES_PROVIDER_OPTIONS.openai,
41
+ ...existing,
42
+ store: false,
43
+ };
44
+ if (!sendReasoning)
45
+ delete next.reasoningSummary;
46
+ return {
47
+ providerOptions: {
48
+ ...args.providerOptions,
49
+ [providerName]: next,
50
+ },
51
+ };
52
+ },
53
+ };
54
+ }
55
+ function providerState(metadata) {
56
+ const encryptedReasoning = [];
57
+ const itemIds = [];
58
+ const providers = asRecord(metadata);
59
+ if (!providers)
60
+ return { encryptedReasoning, itemIds };
61
+ for (const value of Object.values(providers)) {
62
+ const provider = asRecord(value);
63
+ if (!provider)
64
+ continue;
65
+ if (typeof provider.reasoningEncryptedContent === "string") {
66
+ encryptedReasoning.push(provider.reasoningEncryptedContent);
67
+ }
68
+ for (const field of ["itemId", "resultItemId"]) {
69
+ if (typeof provider[field] === "string")
70
+ itemIds.push(provider[field]);
71
+ }
72
+ }
73
+ return { encryptedReasoning, itemIds };
74
+ }
75
+ function foreignResponsesState(messageList, targetModelId) {
76
+ const state = {
77
+ encryptedReasoning: new Set(),
78
+ itemIds: new Set(),
79
+ reasoningItemIds: new Set(),
80
+ };
81
+ if (!messageList)
82
+ return state;
83
+ for (const message of messageList.get.all.db()) {
84
+ if (message.role !== "assistant")
85
+ continue;
86
+ const originModelId = message.content.metadata?.modelId;
87
+ if (typeof originModelId !== "string" || originModelId === targetModelId)
88
+ continue;
89
+ for (const part of message.content.parts) {
90
+ const values = providerState(part.providerMetadata);
91
+ for (const value of values.encryptedReasoning)
92
+ state.encryptedReasoning.add(value);
93
+ for (const value of values.itemIds) {
94
+ state.itemIds.add(value);
95
+ if (part.type === "reasoning")
96
+ state.reasoningItemIds.add(value);
97
+ }
98
+ }
99
+ }
100
+ return state;
101
+ }
102
+ function hasForeignReasoningState(part, state) {
103
+ const record = asRecord(part);
104
+ const values = providerState(record?.providerOptions ?? record?.providerMetadata);
105
+ return (values.encryptedReasoning.some((value) => state.encryptedReasoning.has(value)) ||
106
+ values.itemIds.some((value) => state.reasoningItemIds.has(value)));
107
+ }
108
+ function stripForeignItemIds(part, state) {
109
+ const record = asRecord(part);
110
+ const providerOptions = asRecord(record?.providerOptions);
111
+ if (!providerOptions)
112
+ return part;
113
+ let changed = false;
114
+ const nextProviderOptions = {};
115
+ for (const [name, value] of Object.entries(providerOptions)) {
116
+ const provider = asRecord(value);
117
+ if (!provider) {
118
+ nextProviderOptions[name] = value;
119
+ continue;
120
+ }
121
+ const nextProvider = { ...provider };
122
+ for (const field of MODEL_BOUND_PROVIDER_FIELDS) {
123
+ const fieldValue = nextProvider[field];
124
+ const foreign = typeof fieldValue === "string" &&
125
+ (field === "reasoningEncryptedContent"
126
+ ? state.encryptedReasoning.has(fieldValue)
127
+ : state.itemIds.has(fieldValue));
128
+ if (!foreign)
129
+ continue;
130
+ delete nextProvider[field];
131
+ changed = true;
132
+ }
133
+ if (Object.keys(nextProvider).length > 0)
134
+ nextProviderOptions[name] = nextProvider;
135
+ }
136
+ if (!changed)
137
+ return part;
138
+ return {
139
+ ...record,
140
+ ...(Object.keys(nextProviderOptions).length > 0
141
+ ? { providerOptions: nextProviderOptions }
142
+ : { providerOptions: undefined }),
143
+ };
144
+ }
145
+ function sanitizeResponsesReasoningPart(part, providerName) {
146
+ const record = asRecord(part);
147
+ if (record?.type !== "reasoning")
148
+ return part;
149
+ const providerOptions = asRecord(record.providerOptions);
150
+ const provider = asRecord(providerOptions?.[providerName]);
151
+ const replayable = provider &&
152
+ (typeof provider.reasoningEncryptedContent === "string" ||
153
+ Array.isArray(provider.reasoningSummary));
154
+ if (!provider || !replayable)
155
+ return undefined;
156
+ if (provider.reasoningContent === null)
157
+ return part;
158
+ return {
159
+ ...record,
160
+ providerOptions: {
161
+ ...providerOptions,
162
+ [providerName]: {
163
+ ...provider,
164
+ reasoningContent: null,
165
+ },
166
+ },
167
+ };
168
+ }
169
+ /** Omit incomplete thoughts and raw reasoning content that Responses cannot replay. */
170
+ export const sanitizeResponsesReasoningReplay = {
171
+ name: "databricks-sanitize-responses-reasoning-replay",
172
+ applyToPrompt({ prompt, model }) {
173
+ const providerName = responsesProviderName(model);
174
+ if (!providerName)
175
+ return;
176
+ let changed = false;
177
+ const next = [];
178
+ for (const message of prompt) {
179
+ if (message.role !== "assistant" || !Array.isArray(message.content)) {
180
+ next.push(message);
181
+ continue;
182
+ }
183
+ const content = [];
184
+ let messageChanged = false;
185
+ for (const part of message.content) {
186
+ const sanitized = sanitizeResponsesReasoningPart(part, providerName);
187
+ if (sanitized !== part) {
188
+ changed = true;
189
+ messageChanged = true;
190
+ }
191
+ if (sanitized)
192
+ content.push(sanitized);
193
+ }
194
+ if (!messageChanged) {
195
+ next.push(message);
196
+ }
197
+ else if (content.length > 0) {
198
+ next.push({ ...message, content });
199
+ }
200
+ }
201
+ return changed ? next : undefined;
202
+ },
203
+ };
204
+ /** Remove Responses continuation state produced by a different concrete model. */
205
+ export const stripForeignResponsesState = {
206
+ name: "databricks-strip-foreign-responses-state",
207
+ applyToPrompt({ prompt, model, messageList }) {
208
+ if (!responsesProviderName(model))
209
+ return;
210
+ const targetModelId = asRecord(model)?.modelId;
211
+ if (typeof targetModelId !== "string")
212
+ return;
213
+ const state = foreignResponsesState(messageList, targetModelId);
214
+ if (state.encryptedReasoning.size === 0 && state.itemIds.size === 0)
215
+ return;
216
+ let changed = false;
217
+ const next = [];
218
+ for (const message of prompt) {
219
+ if (message.role !== "assistant" || !Array.isArray(message.content)) {
220
+ next.push(message);
221
+ continue;
222
+ }
223
+ const content = [];
224
+ let messageChanged = false;
225
+ for (const part of message.content) {
226
+ if (part.type === "reasoning" && hasForeignReasoningState(part, state)) {
227
+ changed = true;
228
+ messageChanged = true;
229
+ continue;
230
+ }
231
+ const stripped = stripForeignItemIds(part, state);
232
+ if (stripped !== part) {
233
+ changed = true;
234
+ messageChanged = true;
235
+ }
236
+ content.push(stripped);
237
+ }
238
+ if (!messageChanged) {
239
+ next.push(message);
240
+ }
241
+ else if (content.length > 0) {
242
+ next.push({ ...message, content });
243
+ }
244
+ }
245
+ return changed ? next : undefined;
246
+ },
247
+ };
248
+ /** Mastra-owned compatibility processor extended for Databricks Responses routing. */
249
+ export const providerHistoryCompatProcessor = new ProviderHistoryCompat({
250
+ additionalRules: [sanitizeResponsesReasoningReplay, stripForeignResponsesState],
251
+ });
12
252
  /**
13
253
  * Recursively clone `value`, omitting any property whose key is
14
254
  * `chartId`. Arrays are mapped element-wise; primitives are
@@ -102,4 +342,4 @@ export const stripStaleChartsProcessor = {
102
342
  return args.messages;
103
343
  },
104
344
  };
105
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"processors.js","sourceRoot":"","sources":["../../src/processors.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAG7C,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAE/C;;;;;;GAMG;AACH,SAAS,aAAa,CAAC,KAAc;IACnC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;IAClC,CAAC;IACD,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACvC,MAAM,GAAG,GAAG,KAAgC,CAAC;QAC7C,MAAM,GAAG,GAA4B,EAAE,CAAC;QACxC,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YAC7C,IAAI,GAAG,KAAK,SAAS;gBAAE,SAAS;YAChC,GAAG,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;QAChC,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAmB;IACvD,EAAE,EAAE,oBAAoB;IACxB,WAAW,EACT,iHAAiH;IACnH,YAAY,CAAC,IAAsB;QACjC,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACpC,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW;gBAAE,SAAS;YAC3C,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC;YACrC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBAAE,SAAS;YACpC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,wDAAwD;gBACxD,8DAA8D;gBAC9D,uDAAuD;gBACvD,wDAAwD;gBACxD,wCAAwC;gBACxC,IAAK,IAA2B,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;oBAC5D,SAAS;gBACX,CAAC;gBACD,MAAM,GAAG,GAAI,IAAkD,CAAC,cAAc,CAAC;gBAC/E,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS;oBAAE,SAAS;gBAC/C,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;gBAC1B,MAAM,KAAK,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;gBACpC,sDAAsD;gBACtD,qDAAqD;gBACrD,oDAAoD;gBACpD,8CAA8C;gBAC9C,IACE,OAAO,MAAM,KAAK,QAAQ;oBAC1B,MAAM,KAAK,IAAI;oBACf,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,MAAM,EAC9D,CAAC;oBACD,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC;oBACnB,QAAQ,IAAI,CAAC,CAAC;gBAChB,CAAC;YACH,CAAC;QACH,CAAC;QACD,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;YACjB,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC;QAClD,CAAC;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;CACF,CAAC","sourcesContent":["/**\n * Mastra stream processors wired onto the plugin's agents.\n *\n * The input processor ({@link stripStaleChartsProcessor}) scrubs turn-scoped\n * `chartId` fields out of prior tool results replayed from Memory, so the model\n * cannot copy a stale id into the new turn's `[chart:<id>]` markers.\n *\n * @module\n */\n\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { InputProcessor, ProcessInputArgs } from \"@mastra/core/processors\";\n\nconst logger = log.logger(\"mastra/processors\");\n\n/**\n * Recursively clone `value`, omitting any property whose key is\n * `chartId`. Arrays are mapped element-wise; primitives are\n * returned as-is. The result is structurally identical to the\n * input minus chartIds, so downstream message-shape consumers\n * keep working.\n */\nfunction stripChartIds(value: unknown): unknown {\n  if (Array.isArray(value)) {\n    return value.map(stripChartIds);\n  }\n  if (value && typeof value === \"object\") {\n    const obj = value as Record<string, unknown>;\n    const out: Record<string, unknown> = {};\n    for (const [key, val] of Object.entries(obj)) {\n      if (key === \"chartId\") continue;\n      out[key] = stripChartIds(val);\n    }\n    return out;\n  }\n  return value;\n}\n\n/**\n * Mastra input processor that strips `chartId` fields from every\n * tool-invocation result in prior assistant messages before they\n * reach the model.\n *\n * Why: chartIds are turn-scoped from the model's point of view -\n * each `prepare_chart` / `render_data` call mints a fresh id and\n * the host UI binds it to that turn's reply. Mastra Memory\n * replays prior tool results into the prompt; if old chartIds\n * leak through, the model is tempted to copy them verbatim into\n * the new turn's `[chart:<id>]` markers and the host UI ends up\n * rendering an unrelated chart from the chart cache (or\n * a 404 once the 1h TTL elapsed). This processor removes the\n * temptation by deleting `chartId` keys from every assistant\n * message's tool results before the prompt is built. The current\n * turn's tool results don't exist yet at `processInput` time, so\n * they pass through unmodified.\n *\n * The strip is recursive - any nested `chartId` field is removed,\n * regardless of which tool produced the result. This covers\n * `prepare_chart` / `render_data` top-level chartIds and any\n * legacy `datasets[].chartId` payloads uniformly without coupling\n * to specific tool ids.\n *\n * Wired onto every agent by default via `buildAgents`; opt out with\n * `MastraPluginConfig.stripStaleCharts: false`.\n */\nexport const stripStaleChartsProcessor: InputProcessor = {\n  id: \"strip-stale-charts\",\n  description:\n    \"Removes chartId fields from prior tool-invocation results so the model can't reuse turn-scoped ids from memory.\",\n  processInput(args: ProcessInputArgs) {\n    let stripped = 0;\n    for (const message of args.messages) {\n      if (message.role !== \"assistant\") continue;\n      const parts = message.content?.parts;\n      if (!Array.isArray(parts)) continue;\n      for (const part of parts) {\n        // Tool-invocation parts hold the persisted tool result.\n        // We don't scrub the input args (`rawInput` / `args`) because\n        // the chartId there is the model's outgoing claim, not\n        // anything it could re-reference; only `result` carries\n        // ids that subsequent turns might copy.\n        if ((part as { type?: unknown }).type !== \"tool-invocation\") {\n          continue;\n        }\n        const inv = (part as { toolInvocation?: { result?: unknown } }).toolInvocation;\n        if (!inv || inv.result === undefined) continue;\n        const before = inv.result;\n        const after = stripChartIds(before);\n        // Cheap structural check via JSON length - the actual\n        // strip writes a fresh object only when chartId keys\n        // existed, so different stringification length is a\n        // reliable signal that something was removed.\n        if (\n          typeof before === \"object\" &&\n          before !== null &&\n          JSON.stringify(before).length !== JSON.stringify(after).length\n        ) {\n          inv.result = after;\n          stripped += 1;\n        }\n      }\n    }\n    if (stripped > 0) {\n      logger.debug(\"stripped\", { results: stripped });\n    }\n    return args.messages;\n  },\n};\n"]}
345
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"processors.js","sourceRoot":"","sources":["../../src/processors.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Mastra stream processors wired onto the plugin's agents.\n *\n * Input processors apply provider-aware reasoning defaults, remove incompatible\n * provider continuation state, and scrub turn-scoped chart ids from Memory.\n *\n * @module\n */\n\nimport { isRecord, log } from \"@dbx-tools/shared-core\";\nimport { ProviderHistoryCompat } from \"@mastra/core/processors\";\nimport type {\n  CompatRule,\n  InputProcessor,\n  ProcessInputArgs,\n  ProcessInputStepArgs,\n  ProcessInputStepResult,\n} from \"@mastra/core/processors\";\nimport type { JSONValue } from \"ai\";\n\nimport { RESPONSES_PROVIDER_OPTIONS } from \"./model.ts\";\n\nconst logger = log.logger(\"mastra/processors\");\n\nconst RESPONSES_PROVIDER_SUFFIX = \".responses\";\nconst MODEL_BOUND_PROVIDER_FIELDS = [\n  \"itemId\",\n  \"resultItemId\",\n  \"reasoningEncryptedContent\",\n] as const;\n\ninterface ModelBoundResponsesState {\n  encryptedReasoning: Set<string>;\n  itemIds: Set<string>;\n  reasoningItemIds: Set<string>;\n}\n\nfunction asRecord(value: unknown): Record<string, unknown> | undefined {\n  return isRecord(value) ? value : undefined;\n}\n\nfunction responsesProviderName(model: unknown): string | undefined {\n  const provider = asRecord(model)?.provider;\n  if (typeof provider !== \"string\" || !provider.endsWith(RESPONSES_PROVIDER_SUFFIX)) {\n    return undefined;\n  }\n  return provider.slice(0, -RESPONSES_PROVIDER_SUFFIX.length);\n}\n\n/** Add stateless Responses defaults only after Mastra resolves the step model. */\nexport function buildResponsesProviderOptionsProcessor(sendReasoning: boolean): InputProcessor {\n  return {\n    id: \"databricks-responses-provider-options\",\n    description:\n      \"Applies stateless replay and visible reasoning defaults to Databricks Responses models.\",\n    processInputStep(args: ProcessInputStepArgs) {\n      const providerName = responsesProviderName(args.model);\n      if (!providerName) return;\n      const existing = args.providerOptions?.[providerName] ?? {};\n      const next: Record<string, JSONValue> = {\n        ...RESPONSES_PROVIDER_OPTIONS.openai,\n        ...existing,\n        store: false,\n      };\n      if (!sendReasoning) delete next.reasoningSummary;\n      return {\n        providerOptions: {\n          ...args.providerOptions,\n          [providerName]: next,\n        },\n      } satisfies ProcessInputStepResult;\n    },\n  };\n}\n\nfunction providerState(metadata: unknown): {\n  encryptedReasoning: string[];\n  itemIds: string[];\n} {\n  const encryptedReasoning: string[] = [];\n  const itemIds: string[] = [];\n  const providers = asRecord(metadata);\n  if (!providers) return { encryptedReasoning, itemIds };\n  for (const value of Object.values(providers)) {\n    const provider = asRecord(value);\n    if (!provider) continue;\n    if (typeof provider.reasoningEncryptedContent === \"string\") {\n      encryptedReasoning.push(provider.reasoningEncryptedContent);\n    }\n    for (const field of [\"itemId\", \"resultItemId\"] as const) {\n      if (typeof provider[field] === \"string\") itemIds.push(provider[field]);\n    }\n  }\n  return { encryptedReasoning, itemIds };\n}\n\nfunction foreignResponsesState(\n  messageList: Parameters<NonNullable<CompatRule[\"applyToPrompt\"]>>[0][\"messageList\"],\n  targetModelId: string,\n): ModelBoundResponsesState {\n  const state: ModelBoundResponsesState = {\n    encryptedReasoning: new Set(),\n    itemIds: new Set(),\n    reasoningItemIds: new Set(),\n  };\n  if (!messageList) return state;\n  for (const message of messageList.get.all.db()) {\n    if (message.role !== \"assistant\") continue;\n    const originModelId = message.content.metadata?.modelId;\n    if (typeof originModelId !== \"string\" || originModelId === targetModelId) continue;\n    for (const part of message.content.parts) {\n      const values = providerState(part.providerMetadata);\n      for (const value of values.encryptedReasoning) state.encryptedReasoning.add(value);\n      for (const value of values.itemIds) {\n        state.itemIds.add(value);\n        if (part.type === \"reasoning\") state.reasoningItemIds.add(value);\n      }\n    }\n  }\n  return state;\n}\n\nfunction hasForeignReasoningState(part: unknown, state: ModelBoundResponsesState): boolean {\n  const record = asRecord(part);\n  const values = providerState(record?.providerOptions ?? record?.providerMetadata);\n  return (\n    values.encryptedReasoning.some((value) => state.encryptedReasoning.has(value)) ||\n    values.itemIds.some((value) => state.reasoningItemIds.has(value))\n  );\n}\n\nfunction stripForeignItemIds<T>(part: T, state: ModelBoundResponsesState): T {\n  const record = asRecord(part);\n  const providerOptions = asRecord(record?.providerOptions);\n  if (!providerOptions) return part;\n  let changed = false;\n  const nextProviderOptions: Record<string, unknown> = {};\n  for (const [name, value] of Object.entries(providerOptions)) {\n    const provider = asRecord(value);\n    if (!provider) {\n      nextProviderOptions[name] = value;\n      continue;\n    }\n    const nextProvider = { ...provider };\n    for (const field of MODEL_BOUND_PROVIDER_FIELDS) {\n      const fieldValue = nextProvider[field];\n      const foreign =\n        typeof fieldValue === \"string\" &&\n        (field === \"reasoningEncryptedContent\"\n          ? state.encryptedReasoning.has(fieldValue)\n          : state.itemIds.has(fieldValue));\n      if (!foreign) continue;\n      delete nextProvider[field];\n      changed = true;\n    }\n    if (Object.keys(nextProvider).length > 0) nextProviderOptions[name] = nextProvider;\n  }\n  if (!changed) return part;\n  return {\n    ...record,\n    ...(Object.keys(nextProviderOptions).length > 0\n      ? { providerOptions: nextProviderOptions }\n      : { providerOptions: undefined }),\n  } as T;\n}\n\nfunction sanitizeResponsesReasoningPart<T>(part: T, providerName: string): T | undefined {\n  const record = asRecord(part);\n  if (record?.type !== \"reasoning\") return part;\n  const providerOptions = asRecord(record.providerOptions);\n  const provider = asRecord(providerOptions?.[providerName]);\n  const replayable =\n    provider &&\n    (typeof provider.reasoningEncryptedContent === \"string\" ||\n      Array.isArray(provider.reasoningSummary));\n  if (!provider || !replayable) return undefined;\n  if (provider.reasoningContent === null) return part;\n  return {\n    ...record,\n    providerOptions: {\n      ...providerOptions,\n      [providerName]: {\n        ...provider,\n        reasoningContent: null,\n      },\n    },\n  } as T;\n}\n\n/** Omit incomplete thoughts and raw reasoning content that Responses cannot replay. */\nexport const sanitizeResponsesReasoningReplay: CompatRule = {\n  name: \"databricks-sanitize-responses-reasoning-replay\",\n  applyToPrompt({ prompt, model }) {\n    const providerName = responsesProviderName(model);\n    if (!providerName) return;\n\n    let changed = false;\n    const next = [];\n    for (const message of prompt) {\n      if (message.role !== \"assistant\" || !Array.isArray(message.content)) {\n        next.push(message);\n        continue;\n      }\n      const content = [];\n      let messageChanged = false;\n      for (const part of message.content) {\n        const sanitized = sanitizeResponsesReasoningPart(part, providerName);\n        if (sanitized !== part) {\n          changed = true;\n          messageChanged = true;\n        }\n        if (sanitized) content.push(sanitized);\n      }\n      if (!messageChanged) {\n        next.push(message);\n      } else if (content.length > 0) {\n        next.push({ ...message, content });\n      }\n    }\n    return changed ? next : undefined;\n  },\n};\n\n/** Remove Responses continuation state produced by a different concrete model. */\nexport const stripForeignResponsesState: CompatRule = {\n  name: \"databricks-strip-foreign-responses-state\",\n  applyToPrompt({ prompt, model, messageList }) {\n    if (!responsesProviderName(model)) return;\n    const targetModelId = asRecord(model)?.modelId;\n    if (typeof targetModelId !== \"string\") return;\n    const state = foreignResponsesState(messageList, targetModelId);\n    if (state.encryptedReasoning.size === 0 && state.itemIds.size === 0) return;\n\n    let changed = false;\n    const next = [];\n    for (const message of prompt) {\n      if (message.role !== \"assistant\" || !Array.isArray(message.content)) {\n        next.push(message);\n        continue;\n      }\n      const content = [];\n      let messageChanged = false;\n      for (const part of message.content) {\n        if (part.type === \"reasoning\" && hasForeignReasoningState(part, state)) {\n          changed = true;\n          messageChanged = true;\n          continue;\n        }\n        const stripped = stripForeignItemIds(part, state);\n        if (stripped !== part) {\n          changed = true;\n          messageChanged = true;\n        }\n        content.push(stripped);\n      }\n      if (!messageChanged) {\n        next.push(message);\n      } else if (content.length > 0) {\n        next.push({ ...message, content });\n      }\n    }\n    return changed ? next : undefined;\n  },\n};\n\n/** Mastra-owned compatibility processor extended for Databricks Responses routing. */\nexport const providerHistoryCompatProcessor = new ProviderHistoryCompat({\n  additionalRules: [sanitizeResponsesReasoningReplay, stripForeignResponsesState],\n});\n\n/**\n * Recursively clone `value`, omitting any property whose key is\n * `chartId`. Arrays are mapped element-wise; primitives are\n * returned as-is. The result is structurally identical to the\n * input minus chartIds, so downstream message-shape consumers\n * keep working.\n */\nfunction stripChartIds(value: unknown): unknown {\n  if (Array.isArray(value)) {\n    return value.map(stripChartIds);\n  }\n  if (value && typeof value === \"object\") {\n    const obj = value as Record<string, unknown>;\n    const out: Record<string, unknown> = {};\n    for (const [key, val] of Object.entries(obj)) {\n      if (key === \"chartId\") continue;\n      out[key] = stripChartIds(val);\n    }\n    return out;\n  }\n  return value;\n}\n\n/**\n * Mastra input processor that strips `chartId` fields from every\n * tool-invocation result in prior assistant messages before they\n * reach the model.\n *\n * Why: chartIds are turn-scoped from the model's point of view -\n * each `prepare_chart` / `render_data` call mints a fresh id and\n * the host UI binds it to that turn's reply. Mastra Memory\n * replays prior tool results into the prompt; if old chartIds\n * leak through, the model is tempted to copy them verbatim into\n * the new turn's `[chart:<id>]` markers and the host UI ends up\n * rendering an unrelated chart from the chart cache (or\n * a 404 once the 1h TTL elapsed). This processor removes the\n * temptation by deleting `chartId` keys from every assistant\n * message's tool results before the prompt is built. The current\n * turn's tool results don't exist yet at `processInput` time, so\n * they pass through unmodified.\n *\n * The strip is recursive - any nested `chartId` field is removed,\n * regardless of which tool produced the result. This covers\n * `prepare_chart` / `render_data` top-level chartIds and any\n * legacy `datasets[].chartId` payloads uniformly without coupling\n * to specific tool ids.\n *\n * Wired onto every agent by default via `buildAgents`; opt out with\n * `MastraPluginConfig.stripStaleCharts: false`.\n */\nexport const stripStaleChartsProcessor: InputProcessor = {\n  id: \"strip-stale-charts\",\n  description:\n    \"Removes chartId fields from prior tool-invocation results so the model can't reuse turn-scoped ids from memory.\",\n  processInput(args: ProcessInputArgs) {\n    let stripped = 0;\n    for (const message of args.messages) {\n      if (message.role !== \"assistant\") continue;\n      const parts = message.content?.parts;\n      if (!Array.isArray(parts)) continue;\n      for (const part of parts) {\n        // Tool-invocation parts hold the persisted tool result.\n        // We don't scrub the input args (`rawInput` / `args`) because\n        // the chartId there is the model's outgoing claim, not\n        // anything it could re-reference; only `result` carries\n        // ids that subsequent turns might copy.\n        if ((part as { type?: unknown }).type !== \"tool-invocation\") {\n          continue;\n        }\n        const inv = (part as { toolInvocation?: { result?: unknown } }).toolInvocation;\n        if (!inv || inv.result === undefined) continue;\n        const before = inv.result;\n        const after = stripChartIds(before);\n        // Cheap structural check via JSON length - the actual\n        // strip writes a fresh object only when chartId keys\n        // existed, so different stringification length is a\n        // reliable signal that something was removed.\n        if (\n          typeof before === \"object\" &&\n          before !== null &&\n          JSON.stringify(before).length !== JSON.stringify(after).length\n        ) {\n          inv.result = after;\n          stripped += 1;\n        }\n      }\n    }\n    if (stripped > 0) {\n      logger.debug(\"stripped\", { results: stripped });\n    }\n    return args.messages;\n  },\n};\n"]}
package/package.json CHANGED
@@ -36,23 +36,23 @@
36
36
  },
37
37
  "dependencies": {
38
38
  "@databricks/appkit": "0.81.0",
39
- "@dbx-tools/appkit": "^0.9.182",
40
- "@dbx-tools/appkit-model-gateway": "^0.9.182",
41
- "@dbx-tools/cache": "^0.9.182",
42
- "@dbx-tools/core": "^0.9.182",
43
- "@dbx-tools/databricks": "^0.9.182",
44
- "@dbx-tools/fs": "^0.9.182",
45
- "@dbx-tools/genie": "^0.9.182",
46
- "@dbx-tools/model": "^0.9.182",
47
- "@dbx-tools/model-protocol": "^0.9.182",
48
- "@dbx-tools/path": "^0.9.182",
49
- "@dbx-tools/postgres": "^0.9.182",
50
- "@dbx-tools/shared-core": "^0.9.182",
51
- "@dbx-tools/shared-fs": "^0.9.182",
52
- "@dbx-tools/shared-genie": "^0.9.182",
53
- "@dbx-tools/shared-mastra": "^0.9.182",
54
- "@dbx-tools/shared-model": "^0.9.182",
55
- "@dbx-tools/shared-model-gateway": "^0.9.182",
39
+ "@dbx-tools/appkit": "^0.9.184",
40
+ "@dbx-tools/appkit-model-gateway": "^0.9.184",
41
+ "@dbx-tools/cache": "^0.9.184",
42
+ "@dbx-tools/core": "^0.9.184",
43
+ "@dbx-tools/databricks": "^0.9.184",
44
+ "@dbx-tools/fs": "^0.9.184",
45
+ "@dbx-tools/genie": "^0.9.184",
46
+ "@dbx-tools/model": "^0.9.184",
47
+ "@dbx-tools/model-protocol": "^0.9.184",
48
+ "@dbx-tools/path": "^0.9.184",
49
+ "@dbx-tools/postgres": "^0.9.184",
50
+ "@dbx-tools/shared-core": "^0.9.184",
51
+ "@dbx-tools/shared-fs": "^0.9.184",
52
+ "@dbx-tools/shared-genie": "^0.9.184",
53
+ "@dbx-tools/shared-mastra": "^0.9.184",
54
+ "@dbx-tools/shared-model": "^0.9.184",
55
+ "@dbx-tools/shared-model-gateway": "^0.9.184",
56
56
  "@mastra/ai-sdk": "1.10.5",
57
57
  "@mastra/core": "1.71.0",
58
58
  "@mastra/express": "1.5.15",
@@ -90,7 +90,7 @@
90
90
  "./package.json": "./package.json"
91
91
  }
92
92
  },
93
- "version": "0.9.182",
93
+ "version": "0.9.184",
94
94
  "types": "./lib/index.d.ts",
95
95
  "dbxToolsConfig": {
96
96
  "tags": [
package/src/agents.ts CHANGED
@@ -69,8 +69,12 @@ import {
69
69
  } from "./follow-up-suggestions.ts";
70
70
  import { buildGenieToolkitProvider, resolveGenieSpaces } from "./genie.ts";
71
71
  import { withRequestMemoryScope, type MemoryBuilder } from "./memory.ts";
72
- import { buildModel, RESPONSES_PROVIDER_OPTIONS } from "./model.ts";
73
- import { stripStaleChartsProcessor } from "./processors.ts";
72
+ import { buildModel } from "./model.ts";
73
+ import {
74
+ buildResponsesProviderOptionsProcessor,
75
+ providerHistoryCompatProcessor,
76
+ stripStaleChartsProcessor,
77
+ } from "./processors.ts";
74
78
  import { MASTRA_ORIGIN_KEY } from "./request-context.ts";
75
79
  import { MASTRA_RESOLVED_MODEL_KEY } from "./serving.ts";
76
80
  import { TYPOGRAPHY_RULE } from "./style.ts";
@@ -935,11 +939,11 @@ export async function buildAgents(opts: {
935
939
  ...(config.tools ?? {}),
936
940
  };
937
941
  const style = resolveStyleInstructions(config);
938
- // Default-on protection against the model copying turn-scoped
939
- // chartIds from prior assistant tool results into the new
940
- // turn's `[chart:<id>]` markers. Opt out per-plugin via
941
- // `config.stripStaleCharts: false`.
942
+ // Apply provider-aware reasoning defaults and compatibility guards before
943
+ // filtering large or turn-scoped values from replayed history.
942
944
  const inputProcessors = [
945
+ buildResponsesProviderOptionsProcessor(config.sendReasoning !== false),
946
+ providerHistoryCompatProcessor,
943
947
  // `render_data` can carry hundreds of inline rows. Keep the complete call
944
948
  // in Memory and the UI transcript, but use Mastra's native prompt-stage
945
949
  // filter to omit prior calls/results from later model requests. Current
@@ -996,7 +1000,6 @@ export async function buildAgents(opts: {
996
1000
  withRequestMemoryScope(
997
1001
  {
998
1002
  maxSteps: config.agentMaxSteps ?? DEFAULT_AGENT_MAX_STEPS,
999
- providerOptions: RESPONSES_PROVIDER_OPTIONS,
1000
1003
  ...(def.requireToolApproval !== undefined
1001
1004
  ? { requireToolApproval: def.requireToolApproval }
1002
1005
  : {}),
package/src/config.ts CHANGED
@@ -237,7 +237,7 @@ export interface MastraPluginConfig extends BasePluginConfig {
237
237
  * to `true`.
238
238
  */
239
239
  backgroundTurns?: boolean;
240
- /** Include model reasoning parts in chat UI streams when the provider returns them. Defaults to true. */
240
+ /** Request and include model reasoning parts for supported models. Defaults to true. */
241
241
  sendReasoning?: boolean;
242
242
  /** AI SDK provider-options namespace. Defaults to `"openai"`; no env fallback. */
243
243
  providerId?: string;
@@ -710,7 +710,7 @@ export const MASTRA_CONFIG_SCHEMA: ConfigSchema = {
710
710
  sendReasoning: {
711
711
  type: "boolean",
712
712
  description:
713
- "Include model reasoning parts in chat UI streams when the provider returns them. Defaults to true.",
713
+ "Request and include model reasoning parts for supported models. Defaults to true.",
714
714
  },
715
715
  providerId: {
716
716
  type: "string",
@@ -5,10 +5,7 @@
5
5
  */
6
6
 
7
7
  import { ConfigurationError } from "@databricks/appkit";
8
- import type {
9
- FeedbackDestination,
10
- FeedbackModeOption,
11
- } from "@dbx-tools/shared-mastra";
8
+ import type { FeedbackDestination, FeedbackModeOption } from "@dbx-tools/shared-mastra";
12
9
 
13
10
  /** Runtime availability used by automatic feedback selection. */
14
11
  export interface FeedbackAvailability {
package/src/mlflow.ts CHANGED
@@ -231,9 +231,7 @@ async function resolveUcTracePrefix(client: WorkspaceClient): Promise<string | u
231
231
  }
232
232
 
233
233
  /** Resolve the configured Unity Catalog trace prefix without failing chat startup. */
234
- export async function mlflowUcTracePrefix(
235
- client: WorkspaceClient,
236
- ): Promise<string | undefined> {
234
+ export async function mlflowUcTracePrefix(client: WorkspaceClient): Promise<string | undefined> {
237
235
  try {
238
236
  return await resolveUcTracePrefix(client);
239
237
  } catch {
package/src/model.ts CHANGED
@@ -77,10 +77,11 @@ export const SMART_ROUTER_ENDPOINT: ServingEndpointSummary = {
77
77
  status: { deprecated: false },
78
78
  };
79
79
 
80
- /** Keep Responses turns stateless so tool continuations replay encrypted reasoning inline. */
80
+ /** Default Responses options: stateless replay plus visible reasoning summaries. */
81
81
  export const RESPONSES_PROVIDER_OPTIONS = {
82
82
  openai: {
83
83
  store: false,
84
+ reasoningSummary: "auto",
84
85
  },
85
86
  } as const;
86
87
 
package/src/plugin.ts CHANGED
@@ -1269,9 +1269,7 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
1269
1269
  }
1270
1270
 
1271
1271
  /** Verify experiment visibility through the active user's OBO client. */
1272
- private async fetchMlflowExperimentViewerUrl(): Promise<
1273
- ExecutionResult<string | undefined>
1274
- > {
1272
+ private async fetchMlflowExperimentViewerUrl(): Promise<ExecutionResult<string | undefined>> {
1275
1273
  const client = getExecutionContext().client;
1276
1274
  return this.execute(() => mlflowExperimentViewerUrl(client), feedbackWriteDefaults);
1277
1275
  }
@@ -1506,16 +1504,16 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
1506
1504
  this.config,
1507
1505
  { mlflowFeedback: this.feedbackEnabled("mlflow") },
1508
1506
  {
1509
- app: this.mastraApp,
1510
- mastra: this.mastra,
1511
- prefix: "",
1512
- customApiRoutes: [
1513
- ...agentChatRoutes(this.config),
1514
- workflowRoute({
1515
- path: "/route/workflows/:workflowId/stream",
1516
- version: "v7",
1517
- }),
1518
- ],
1507
+ app: this.mastraApp,
1508
+ mastra: this.mastra,
1509
+ prefix: "",
1510
+ customApiRoutes: [
1511
+ ...agentChatRoutes(this.config),
1512
+ workflowRoute({
1513
+ path: "/route/workflows/:workflowId/stream",
1514
+ version: "v7",
1515
+ }),
1516
+ ],
1519
1517
  },
1520
1518
  );
1521
1519
  await this.mastraServer.init();