@mastra/braintrust 1.3.0 → 1.3.1

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.
Files changed (7) hide show
  1. package/CHANGELOG.md +16 -0
  2. package/dist/index.cjs +550 -634
  3. package/dist/index.cjs.map +1 -1
  4. package/dist/index.js +548 -631
  5. package/dist/index.js.map +1 -1
  6. package/dist/tracing.d.ts.map +1 -1
  7. package/package.json +9 -8
package/dist/index.js CHANGED
@@ -1,650 +1,567 @@
1
- import { SpanType } from '@mastra/core/observability';
2
- import { omitKeys } from '@mastra/core/utils';
3
- import { TrackingExporter } from '@mastra/observability';
4
- import { initLogger, currentSpan } from 'braintrust';
5
-
6
- // src/tracing.ts
7
-
8
- // src/formatter.ts
1
+ import { SpanType } from "@mastra/core/observability";
2
+ import { omitKeys } from "@mastra/core/utils";
3
+ import { TrackingExporter } from "@mastra/observability";
4
+ import { currentSpan, initLogger } from "braintrust";
5
+ //#region src/formatter.ts
6
+ /**
7
+ * Message format conversion utilities for Braintrust.
8
+ *
9
+ * Converts AI SDK message format (v4/v5) to OpenAI Chat Completion format,
10
+ * which Braintrust requires for proper rendering of threads.
11
+ */
12
+ /**
13
+ * Remove null and undefined values from an object (shallow)
14
+ */
9
15
  function removeNullish(obj) {
10
- return Object.fromEntries(Object.entries(obj).filter(([_, v]) => v != null));
16
+ return Object.fromEntries(Object.entries(obj).filter(([_, v]) => v != null));
11
17
  }
18
+ /**
19
+ * Converts a content part to a string representation.
20
+ * Handles text, image, file, reasoning, and other content types.
21
+ */
12
22
  function convertContentPart(part) {
13
- if (!part || typeof part !== "object") {
14
- return null;
15
- }
16
- switch (part.type) {
17
- case "text":
18
- return part.text || null;
19
- case "image":
20
- return "[image]";
21
- case "file": {
22
- const filePart = part;
23
- if (filePart.filename || filePart.name) {
24
- return `[file: ${filePart.filename || filePart.name}]`;
25
- }
26
- return "[file]";
27
- }
28
- case "reasoning": {
29
- const reasoningPart = part;
30
- if (typeof reasoningPart.text === "string" && reasoningPart.text.length > 0) {
31
- return `[reasoning: ${reasoningPart.text.substring(0, 100)}${reasoningPart.text.length > 100 ? "..." : ""}]`;
32
- }
33
- return "[reasoning]";
34
- }
35
- case "tool-call":
36
- return null;
37
- case "tool-result":
38
- return null;
39
- default: {
40
- const unknownPart = part;
41
- if (typeof unknownPart.text === "string") {
42
- return unknownPart.text;
43
- }
44
- if (typeof unknownPart.content === "string") {
45
- return unknownPart.content;
46
- }
47
- return `[${unknownPart.type || "unknown"}]`;
48
- }
49
- }
23
+ if (!part || typeof part !== "object") return null;
24
+ switch (part.type) {
25
+ case "text": return part.text || null;
26
+ case "image": return "[image]";
27
+ case "file": {
28
+ const filePart = part;
29
+ if (filePart.filename || filePart.name) return `[file: ${filePart.filename || filePart.name}]`;
30
+ return "[file]";
31
+ }
32
+ case "reasoning": {
33
+ const reasoningPart = part;
34
+ if (typeof reasoningPart.text === "string" && reasoningPart.text.length > 0) return `[reasoning: ${reasoningPart.text.substring(0, 100)}${reasoningPart.text.length > 100 ? "..." : ""}]`;
35
+ return "[reasoning]";
36
+ }
37
+ case "tool-call": return null;
38
+ case "tool-result": return null;
39
+ default: {
40
+ const unknownPart = part;
41
+ if (typeof unknownPart.text === "string") return unknownPart.text;
42
+ if (typeof unknownPart.content === "string") return unknownPart.content;
43
+ return `[${unknownPart.type || "unknown"}]`;
44
+ }
45
+ }
50
46
  }
47
+ /**
48
+ * Serializes tool result data to a string for OpenAI format.
49
+ */
51
50
  function serializeToolResult(resultData) {
52
- if (typeof resultData === "string") {
53
- return resultData;
54
- }
55
- if (resultData && typeof resultData === "object" && "value" in resultData) {
56
- const valueData = resultData.value;
57
- return typeof valueData === "string" ? valueData : JSON.stringify(valueData);
58
- }
59
- if (resultData === void 0 || resultData === null) {
60
- return "";
61
- }
62
- try {
63
- return JSON.stringify(resultData);
64
- } catch {
65
- return "[unserializable result]";
66
- }
51
+ if (typeof resultData === "string") return resultData;
52
+ if (resultData && typeof resultData === "object" && "value" in resultData) {
53
+ const valueData = resultData.value;
54
+ return typeof valueData === "string" ? valueData : JSON.stringify(valueData);
55
+ }
56
+ if (resultData === void 0 || resultData === null) return "";
57
+ try {
58
+ return JSON.stringify(resultData);
59
+ } catch {
60
+ return "[unserializable result]";
61
+ }
67
62
  }
63
+ /**
64
+ * Converts AI SDK message format to OpenAI Chat Completion format for Braintrust.
65
+ *
66
+ * Supports both AI SDK v4 and v5 formats:
67
+ * - v4 uses 'args' for tool calls and 'result' for tool results
68
+ * - v5 uses 'input' for tool calls and 'output' for tool results
69
+ *
70
+ * AI SDK format:
71
+ * { role: "user", content: [{ type: "text", text: "hello" }] }
72
+ * { role: "assistant", content: [{ type: "text", text: "..." }, { type: "tool-call", toolCallId: "...", toolName: "...", args: {...} }] }
73
+ * { role: "tool", content: [{ type: "tool-result", toolCallId: "...", result: {...} }] }
74
+ *
75
+ * OpenAI format (what Braintrust expects):
76
+ * { role: "user", content: "hello" }
77
+ * { role: "assistant", content: "...", tool_calls: [{ id: "...", type: "function", function: { name: "...", arguments: "..." } }] }
78
+ * { role: "tool", content: "result", tool_call_id: "..." }
79
+ */
68
80
  function convertAISDKMessage(message) {
69
- if (!message || typeof message !== "object") {
70
- return message;
71
- }
72
- const { role, content, ...rest } = message;
73
- if (typeof content === "string") {
74
- return message;
75
- }
76
- if (Array.isArray(content)) {
77
- if (content.length === 0) {
78
- return { role, content: "", ...rest };
79
- }
80
- if (role === "user" || role === "system") {
81
- const contentParts = content.map((part) => convertContentPart(part)).filter(Boolean);
82
- return {
83
- role,
84
- content: contentParts.length > 0 ? contentParts.join("\n") : "",
85
- ...rest
86
- };
87
- }
88
- if (role === "assistant") {
89
- const contentParts = content.filter((part) => part?.type !== "tool-call").map((part) => convertContentPart(part)).filter(Boolean);
90
- const toolCallParts = content.filter((part) => part?.type === "tool-call");
91
- const result = {
92
- role,
93
- content: contentParts.length > 0 ? contentParts.join("\n") : "",
94
- ...rest
95
- };
96
- if (toolCallParts.length > 0) {
97
- result.tool_calls = toolCallParts.map((tc) => {
98
- const toolCall = tc;
99
- const toolCallId = toolCall.toolCallId;
100
- const toolName = toolCall.toolName;
101
- const args = toolCall.args ?? toolCall.input;
102
- let argsString;
103
- if (typeof args === "string") {
104
- argsString = args;
105
- } else if (args !== void 0 && args !== null) {
106
- argsString = JSON.stringify(args);
107
- } else {
108
- argsString = "{}";
109
- }
110
- return {
111
- id: toolCallId,
112
- type: "function",
113
- function: {
114
- name: toolName,
115
- arguments: argsString
116
- }
117
- };
118
- });
119
- }
120
- return result;
121
- }
122
- if (role === "tool") {
123
- const toolResult = content.find((part) => part?.type === "tool-result");
124
- if (toolResult) {
125
- const resultData = toolResult.output ?? toolResult.result;
126
- const resultContent = serializeToolResult(resultData);
127
- return {
128
- role: "tool",
129
- content: resultContent,
130
- tool_call_id: toolResult.toolCallId
131
- };
132
- }
133
- }
134
- }
135
- return message;
81
+ if (!message || typeof message !== "object") return message;
82
+ const { role, content, ...rest } = message;
83
+ if (typeof content === "string") return message;
84
+ if (Array.isArray(content)) {
85
+ if (content.length === 0) return {
86
+ role,
87
+ content: "",
88
+ ...rest
89
+ };
90
+ if (role === "user" || role === "system") {
91
+ const contentParts = content.map((part) => convertContentPart(part)).filter(Boolean);
92
+ return {
93
+ role,
94
+ content: contentParts.length > 0 ? contentParts.join("\n") : "",
95
+ ...rest
96
+ };
97
+ }
98
+ if (role === "assistant") {
99
+ const contentParts = content.filter((part) => part?.type !== "tool-call").map((part) => convertContentPart(part)).filter(Boolean);
100
+ const toolCallParts = content.filter((part) => part?.type === "tool-call");
101
+ const result = {
102
+ role,
103
+ content: contentParts.length > 0 ? contentParts.join("\n") : "",
104
+ ...rest
105
+ };
106
+ if (toolCallParts.length > 0) result.tool_calls = toolCallParts.map((tc) => {
107
+ const toolCall = tc;
108
+ const toolCallId = toolCall.toolCallId;
109
+ const toolName = toolCall.toolName;
110
+ const args = toolCall.args ?? toolCall.input;
111
+ let argsString;
112
+ if (typeof args === "string") argsString = args;
113
+ else if (args !== void 0 && args !== null) argsString = JSON.stringify(args);
114
+ else argsString = "{}";
115
+ return {
116
+ id: toolCallId,
117
+ type: "function",
118
+ function: {
119
+ name: toolName,
120
+ arguments: argsString
121
+ }
122
+ };
123
+ });
124
+ return result;
125
+ }
126
+ if (role === "tool") {
127
+ const toolResult = content.find((part) => part?.type === "tool-result");
128
+ if (toolResult) return {
129
+ role: "tool",
130
+ content: serializeToolResult(toolResult.output ?? toolResult.result),
131
+ tool_call_id: toolResult.toolCallId
132
+ };
133
+ }
134
+ }
135
+ return message;
136
136
  }
137
-
138
- // src/metrics.ts
137
+ //#endregion
138
+ //#region src/metrics.ts
139
+ /**
140
+ * Formats UsageStats to Braintrust's expected metric format.
141
+ */
139
142
  function formatUsageMetrics(usage) {
140
- const metrics = {};
141
- if (usage?.inputTokens !== void 0) {
142
- metrics.prompt_tokens = usage.inputTokens;
143
- }
144
- if (usage?.outputTokens !== void 0) {
145
- metrics.completion_tokens = usage.outputTokens;
146
- }
147
- if (metrics.prompt_tokens !== void 0 && metrics.completion_tokens !== void 0) {
148
- metrics.tokens = metrics.prompt_tokens + metrics.completion_tokens;
149
- }
150
- if (usage?.outputDetails?.reasoning !== void 0) {
151
- metrics.completion_reasoning_tokens = usage.outputDetails.reasoning;
152
- }
153
- if (usage?.inputDetails?.cacheRead !== void 0) {
154
- metrics.prompt_cached_tokens = usage.inputDetails.cacheRead;
155
- }
156
- if (usage?.inputDetails?.cacheWrite !== void 0) {
157
- metrics.prompt_cache_creation_tokens = usage.inputDetails.cacheWrite;
158
- }
159
- return metrics;
143
+ const metrics = {};
144
+ if (usage?.inputTokens !== void 0) metrics.prompt_tokens = usage.inputTokens;
145
+ if (usage?.outputTokens !== void 0) metrics.completion_tokens = usage.outputTokens;
146
+ if (metrics.prompt_tokens !== void 0 && metrics.completion_tokens !== void 0) metrics.tokens = metrics.prompt_tokens + metrics.completion_tokens;
147
+ if (usage?.outputDetails?.reasoning !== void 0) metrics.completion_reasoning_tokens = usage.outputDetails.reasoning;
148
+ if (usage?.inputDetails?.cacheRead !== void 0) metrics.prompt_cached_tokens = usage.inputDetails.cacheRead;
149
+ if (usage?.inputDetails?.cacheWrite !== void 0) metrics.prompt_cache_creation_tokens = usage.inputDetails.cacheWrite;
150
+ return metrics;
160
151
  }
161
-
162
- // src/thread-reconstruction.ts
152
+ //#endregion
153
+ //#region src/thread-reconstruction.ts
154
+ /**
155
+ * Thread view reconstruction for Braintrust.
156
+ *
157
+ * Reconstructs LLM output in OpenAI Chat Completion format by examining
158
+ * child MODEL_STEP and TOOL_CALL spans. This enables Braintrust's Thread
159
+ * view to properly display the full conversation flow including tool calls.
160
+ *
161
+ * See THREAD_VIEW_RECONSTRUCTION.md for details.
162
+ */
163
+ /**
164
+ * Reconstruct the Thread view output from accumulated threadData.
165
+ * Converts to OpenAI Chat Completion message format.
166
+ */
163
167
  function reconstructThreadOutput(threadData, originalOutput) {
164
- const messages = [];
165
- const sortedSteps = [...threadData].sort((a, b) => a.stepIndex - b.stepIndex);
166
- for (const step of sortedSteps) {
167
- const sortedToolCalls = step.toolCalls ? [...step.toolCalls].sort((a, b) => {
168
- if (!a.startTime || !b.startTime) return 0;
169
- return a.startTime.getTime() - b.startTime.getTime();
170
- }) : [];
171
- if (sortedToolCalls.length > 0) {
172
- messages.push({
173
- role: "assistant",
174
- content: step.text || "",
175
- tool_calls: sortedToolCalls.map((tc) => {
176
- const cleanArgs = tc.args && typeof tc.args === "object" && !Array.isArray(tc.args) ? removeNullish(tc.args) : tc.args;
177
- return {
178
- id: tc.toolCallId,
179
- type: "function",
180
- function: {
181
- name: tc.toolName,
182
- arguments: typeof cleanArgs === "string" ? cleanArgs : JSON.stringify(cleanArgs)
183
- }
184
- };
185
- })
186
- });
187
- for (const tc of sortedToolCalls) {
188
- if (tc.result !== void 0) {
189
- messages.push({
190
- role: "tool",
191
- content: typeof tc.result === "string" ? tc.result : JSON.stringify(tc.result),
192
- tool_call_id: tc.toolCallId
193
- });
194
- }
195
- }
196
- } else if (step.text) {
197
- messages.push({
198
- role: "assistant",
199
- content: step.text
200
- });
201
- }
202
- }
203
- if (messages.length > 0) {
204
- const lastMessage = messages[messages.length - 1];
205
- const originalText = originalOutput?.text;
206
- if (originalText && lastMessage.role === "tool") {
207
- messages.push({
208
- role: "assistant",
209
- content: originalText
210
- });
211
- }
212
- }
213
- return messages;
168
+ const messages = [];
169
+ const sortedSteps = [...threadData].sort((a, b) => a.stepIndex - b.stepIndex);
170
+ for (const step of sortedSteps) {
171
+ const sortedToolCalls = step.toolCalls ? [...step.toolCalls].sort((a, b) => {
172
+ if (!a.startTime || !b.startTime) return 0;
173
+ return a.startTime.getTime() - b.startTime.getTime();
174
+ }) : [];
175
+ if (sortedToolCalls.length > 0) {
176
+ messages.push({
177
+ role: "assistant",
178
+ content: step.text || "",
179
+ tool_calls: sortedToolCalls.map((tc) => {
180
+ const cleanArgs = tc.args && typeof tc.args === "object" && !Array.isArray(tc.args) ? removeNullish(tc.args) : tc.args;
181
+ return {
182
+ id: tc.toolCallId,
183
+ type: "function",
184
+ function: {
185
+ name: tc.toolName,
186
+ arguments: typeof cleanArgs === "string" ? cleanArgs : JSON.stringify(cleanArgs)
187
+ }
188
+ };
189
+ })
190
+ });
191
+ for (const tc of sortedToolCalls) if (tc.result !== void 0) messages.push({
192
+ role: "tool",
193
+ content: typeof tc.result === "string" ? tc.result : JSON.stringify(tc.result),
194
+ tool_call_id: tc.toolCallId
195
+ });
196
+ } else if (step.text) messages.push({
197
+ role: "assistant",
198
+ content: step.text
199
+ });
200
+ }
201
+ if (messages.length > 0) {
202
+ const lastMessage = messages[messages.length - 1];
203
+ const originalText = originalOutput?.text;
204
+ if (originalText && lastMessage.role === "tool") messages.push({
205
+ role: "assistant",
206
+ content: originalText
207
+ });
208
+ }
209
+ return messages;
214
210
  }
215
-
216
- // src/tracing.ts
217
- var DEFAULT_SPAN_TYPE = "task";
218
- var SPAN_TYPE_EXCEPTIONS = {
219
- [SpanType.MODEL_GENERATION]: "llm",
220
- [SpanType.TOOL_CALL]: "tool",
221
- [SpanType.MCP_TOOL_CALL]: "tool",
222
- [SpanType.PROVIDER_TOOL_CALL]: "tool",
223
- [SpanType.WORKFLOW_CONDITIONAL_EVAL]: "function",
224
- [SpanType.WORKFLOW_WAIT_EVENT]: "function"
211
+ //#endregion
212
+ //#region src/tracing.ts
213
+ const DEFAULT_SPAN_TYPE = "task";
214
+ const SPAN_TYPE_EXCEPTIONS = {
215
+ [SpanType.MODEL_GENERATION]: "llm",
216
+ [SpanType.TOOL_CALL]: "tool",
217
+ [SpanType.MCP_TOOL_CALL]: "tool",
218
+ [SpanType.PROVIDER_TOOL_CALL]: "tool",
219
+ [SpanType.WORKFLOW_CONDITIONAL_EVAL]: "function",
220
+ [SpanType.WORKFLOW_WAIT_EVENT]: "function"
225
221
  };
226
222
  function mapSpanType(spanType) {
227
- return SPAN_TYPE_EXCEPTIONS[spanType] ?? DEFAULT_SPAN_TYPE;
223
+ return SPAN_TYPE_EXCEPTIONS[spanType] ?? DEFAULT_SPAN_TYPE;
228
224
  }
229
225
  var BraintrustExporter = class extends TrackingExporter {
230
- name = "braintrust";
231
- // Flags and logger for context-aware mode
232
- #useProvidedLogger;
233
- #providedLogger;
234
- #localLogger;
235
- constructor(config = {}) {
236
- const resolvedApiKey = config.apiKey ?? process.env.BRAINTRUST_API_KEY;
237
- const resolvedEndpoint = config.endpoint ?? process.env.BRAINTRUST_ENDPOINT;
238
- super({
239
- ...config,
240
- apiKey: resolvedApiKey,
241
- endpoint: resolvedEndpoint
242
- });
243
- this.#useProvidedLogger = !!config.braintrustLogger;
244
- if (this.#useProvidedLogger) {
245
- this.#providedLogger = config.braintrustLogger;
246
- } else {
247
- if (!this.config.apiKey) {
248
- this.setDisabled(
249
- `Missing required API key. Set BRAINTRUST_API_KEY environment variable or pass apiKey in config.`
250
- );
251
- return;
252
- }
253
- this.#localLogger = void 0;
254
- }
255
- }
256
- async getLocalLogger() {
257
- if (this.#localLogger) {
258
- return this.#localLogger;
259
- }
260
- try {
261
- const logger = await initLogger({
262
- projectName: this.config.projectName ?? "mastra-tracing",
263
- apiKey: this.config.apiKey,
264
- appUrl: this.config.endpoint,
265
- ...this.config.tuningParameters
266
- });
267
- this.#localLogger = logger;
268
- return logger;
269
- } catch (err) {
270
- this.logger.error("Braintrust exporter: Failed to initialize logger", { error: err });
271
- this.setDisabled("Failed to initialize Braintrust logger");
272
- }
273
- }
274
- async onScoreEvent(event) {
275
- if (this.isDisabled) return;
276
- const { score } = event;
277
- const rowId = score.spanId ?? score.traceId;
278
- if (!rowId) {
279
- this.logger.debug("Braintrust exporter: skipping score with no spanId or traceId", {
280
- scorerId: score.scorerId
281
- });
282
- return;
283
- }
284
- const logger = this.#useProvidedLogger ? this.#providedLogger : await this.getLocalLogger();
285
- if (!logger) return;
286
- const name = score.scorerName ?? score.scorerId;
287
- try {
288
- logger.logFeedback({
289
- id: rowId,
290
- scores: { [name]: score.score },
291
- ...score.reason ? { comment: score.reason } : {},
292
- metadata: {
293
- scorerId: score.scorerId,
294
- ...score.scoreSource ? { scoreSource: score.scoreSource } : {},
295
- ...score.metadata ?? {}
296
- },
297
- source: "external"
298
- });
299
- } catch (err) {
300
- this.logger.error("Braintrust exporter: Failed to submit score", {
301
- error: err,
302
- traceId: score.traceId,
303
- spanId: score.spanId,
304
- scorerId: score.scorerId
305
- });
306
- }
307
- }
308
- startSpan(args) {
309
- const { parent, span } = args;
310
- const payload = this.buildSpanPayload(span);
311
- const braintrustSpan = parent.startSpan({
312
- spanId: span.id,
313
- name: span.name,
314
- type: mapSpanType(span.type),
315
- startTime: span.startTime.getTime() / 1e3,
316
- event: {
317
- id: span.id,
318
- // Use Mastra span ID as Braintrust row ID for logFeedback() compatibility
319
- ...payload
320
- }
321
- });
322
- const isModelGeneration = span.type === SpanType.MODEL_GENERATION;
323
- return {
324
- span: braintrustSpan,
325
- spanType: span.type,
326
- threadData: isModelGeneration ? [] : void 0,
327
- pendingToolResults: isModelGeneration ? /* @__PURE__ */ new Map() : void 0
328
- };
329
- }
330
- async _buildRoot(_args) {
331
- if (this.#useProvidedLogger) {
332
- let externalSpan;
333
- try {
334
- externalSpan = this.config.currentSpan?.();
335
- } catch (err) {
336
- this.logger.error("Braintrust exporter: Failed to resolve configured currentSpan", { error: err });
337
- }
338
- externalSpan ??= currentSpan();
339
- if (externalSpan && externalSpan.id) {
340
- return externalSpan;
341
- } else {
342
- return this.#providedLogger;
343
- }
344
- } else {
345
- return this.getLocalLogger();
346
- }
347
- }
348
- async _buildSpan(args) {
349
- const { span, traceData } = args;
350
- if (span.isRootSpan) {
351
- const root = traceData.getRoot();
352
- if (root) {
353
- return this.startSpan({ parent: root, span });
354
- }
355
- } else {
356
- const parent = traceData.getParent(args);
357
- if (parent) {
358
- const parentSpan = "span" in parent ? parent.span : parent;
359
- return this.startSpan({ parent: parentSpan, span });
360
- }
361
- }
362
- }
363
- async _buildEvent(args) {
364
- const spanData = await this._buildSpan(args);
365
- if (!spanData) {
366
- return;
367
- }
368
- spanData.span.end({ endTime: args.span.startTime.getTime() / 1e3 });
369
- return spanData.span;
370
- }
371
- async _updateSpan(args) {
372
- const { span, traceData } = args;
373
- const spanData = traceData.getSpan({ spanId: span.id });
374
- if (!spanData) {
375
- return;
376
- }
377
- spanData.span.log(this.buildSpanPayload(span, false));
378
- }
379
- async _finishSpan(args) {
380
- const { span, traceData } = args;
381
- const spanData = traceData.getSpan({ spanId: span.id });
382
- if (!spanData) {
383
- return;
384
- }
385
- if (span.type === SpanType.MODEL_STEP) {
386
- this.accumulateModelStepData(span, traceData);
387
- } else if (span.type === SpanType.TOOL_CALL) {
388
- this.accumulateToolCallResult(span, traceData);
389
- }
390
- const payload = span.type === SpanType.MODEL_GENERATION ? this.buildModelGenerationPayload(span, spanData) : this.buildSpanPayload(span, false);
391
- spanData.span.log(payload);
392
- if (span.endTime) {
393
- spanData.span.end({ endTime: span.endTime.getTime() / 1e3 });
394
- } else {
395
- spanData.span.end();
396
- }
397
- }
398
- async _abortSpan(args) {
399
- const { span: spanData, reason } = args;
400
- spanData.span.log({
401
- error: reason.message,
402
- metadata: { errorDetails: reason }
403
- });
404
- spanData.span.end();
405
- }
406
- // ==============================================================================
407
- // Thread view reconstruction helpers
408
- // ==============================================================================
409
- /**
410
- * Walk up the tree to find the MODEL_GENERATION ancestor span.
411
- * Returns the BraintrustSpanData if found, undefined otherwise.
412
- */
413
- findModelGenerationAncestor(spanId, traceData) {
414
- let currentId = spanId;
415
- while (currentId) {
416
- const parentId = traceData.getParentId({ spanId: currentId });
417
- if (!parentId) return void 0;
418
- const parentSpanData = traceData.getSpan({ spanId: parentId });
419
- if (parentSpanData?.spanType === SpanType.MODEL_GENERATION) {
420
- return parentSpanData;
421
- }
422
- currentId = parentId;
423
- }
424
- return void 0;
425
- }
426
- /**
427
- * Accumulate MODEL_STEP data to the parent MODEL_GENERATION's threadData.
428
- * Called when a MODEL_STEP span ends.
429
- */
430
- accumulateModelStepData(span, traceData) {
431
- const modelGenSpanData = this.findModelGenerationAncestor(span.id, traceData);
432
- if (!modelGenSpanData?.threadData) {
433
- return;
434
- }
435
- const output = span.output;
436
- const attributes = span.attributes;
437
- const stepData = {
438
- stepSpanId: span.id,
439
- stepIndex: attributes?.stepIndex ?? 0,
440
- text: output?.text,
441
- toolCalls: output?.toolCalls?.map((tc) => ({
442
- toolCallId: tc.toolCallId,
443
- toolName: tc.toolName,
444
- args: tc.args
445
- }))
446
- };
447
- modelGenSpanData.threadData.push(stepData);
448
- }
449
- /**
450
- * Store TOOL_CALL result in parent MODEL_GENERATION's pendingToolResults.
451
- * Called when a TOOL_CALL span ends.
452
- * Results are merged into threadData when MODEL_GENERATION ends.
453
- */
454
- accumulateToolCallResult(span, traceData) {
455
- const modelGenSpanData = this.findModelGenerationAncestor(span.id, traceData);
456
- if (!modelGenSpanData?.pendingToolResults) {
457
- return;
458
- }
459
- const input = span.input;
460
- const toolCallId = input?.toolCallId;
461
- if (!toolCallId) {
462
- return;
463
- }
464
- modelGenSpanData.pendingToolResults.set(toolCallId, {
465
- result: span.output,
466
- startTime: span.startTime
467
- });
468
- }
469
- /**
470
- * Build the payload for MODEL_GENERATION span, reconstructing output from threadData if available.
471
- */
472
- buildModelGenerationPayload(span, spanData) {
473
- const basePayload = this.buildSpanPayload(span, false);
474
- const threadData = spanData.threadData;
475
- if (!threadData || threadData.length === 0) {
476
- return basePayload;
477
- }
478
- if (spanData.pendingToolResults && spanData.pendingToolResults.size > 0) {
479
- for (const step of threadData) {
480
- if (step.toolCalls) {
481
- for (const toolCall of step.toolCalls) {
482
- const pendingResult = spanData.pendingToolResults.get(toolCall.toolCallId);
483
- if (pendingResult) {
484
- toolCall.result = pendingResult.result;
485
- toolCall.startTime = pendingResult.startTime;
486
- }
487
- }
488
- }
489
- }
490
- }
491
- const hasToolCalls = threadData.some((step) => step.toolCalls && step.toolCalls.length > 0);
492
- if (!hasToolCalls) {
493
- return basePayload;
494
- }
495
- const reconstructedOutput = reconstructThreadOutput(threadData, span.output);
496
- return {
497
- ...basePayload,
498
- output: reconstructedOutput
499
- };
500
- }
501
- /**
502
- * Transforms MODEL_GENERATION input to Braintrust Thread view format.
503
- * Converts AI SDK messages (v4/v5) to OpenAI Chat Completion format, which Braintrust requires
504
- * for proper rendering of threads (fixes #11023).
505
- */
506
- transformInput(input, spanType) {
507
- if (spanType === SpanType.MODEL_GENERATION) {
508
- if (Array.isArray(input)) {
509
- return input.map((msg) => convertAISDKMessage(msg));
510
- }
511
- if (input && typeof input === "object" && "messages" in input && Array.isArray(input.messages)) {
512
- return input.messages.map((msg) => convertAISDKMessage(msg));
513
- }
514
- }
515
- return input;
516
- }
517
- /**
518
- * Transforms MODEL_GENERATION output to Braintrust Thread view format.
519
- */
520
- transformOutput(output, spanType) {
521
- if (spanType === SpanType.MODEL_GENERATION) {
522
- if (!output || typeof output !== "object") {
523
- return output;
524
- }
525
- const { text, ...rest } = output;
526
- return { role: "assistant", content: text, ...removeNullish(rest) };
527
- }
528
- return output;
529
- }
530
- isToolSpan(span) {
531
- return span.type === SpanType.TOOL_CALL || span.type === SpanType.MCP_TOOL_CALL || span.type === SpanType.PROVIDER_TOOL_CALL;
532
- }
533
- getToolName(span) {
534
- if (span.entityName) {
535
- return span.entityName;
536
- }
537
- const match = /'([^']+)'/.exec(span.name);
538
- return match?.[1] ?? span.name;
539
- }
540
- getToolCallId(span) {
541
- const attrs = span.attributes;
542
- return attrs?.toolCallId ?? span.input?.toolCallId ?? span.id;
543
- }
544
- toToolCallInput(span) {
545
- const args = span.input;
546
- let argsString;
547
- if (typeof args === "string") {
548
- argsString = args;
549
- } else {
550
- try {
551
- argsString = JSON.stringify(args ?? {});
552
- } catch {
553
- argsString = "[unserializable result]";
554
- }
555
- }
556
- return [
557
- {
558
- role: "assistant",
559
- content: "",
560
- tool_calls: [
561
- {
562
- id: this.getToolCallId(span),
563
- type: "function",
564
- function: {
565
- name: this.getToolName(span),
566
- arguments: argsString
567
- }
568
- }
569
- ]
570
- }
571
- ];
572
- }
573
- toToolCallOutput(span) {
574
- return {
575
- role: "tool",
576
- content: serializeToolResult(span.output),
577
- tool_call_id: this.getToolCallId(span)
578
- };
579
- }
580
- buildSpanPayload(span, isCreate = true) {
581
- const payload = {};
582
- const isToolType = this.isToolSpan(span);
583
- if (span.input !== void 0) {
584
- payload.input = isToolType ? this.toToolCallInput(span) : this.transformInput(span.input, span.type);
585
- }
586
- if (span.output !== void 0) {
587
- payload.output = isToolType ? this.toToolCallOutput(span) : this.transformOutput(span.output, span.type);
588
- }
589
- if (isCreate && span.isRootSpan && span.tags?.length) {
590
- payload.tags = span.tags;
591
- }
592
- payload.metrics = {};
593
- payload.metadata = {
594
- ...span.metadata,
595
- spanType: span.type
596
- };
597
- if (isCreate) {
598
- payload.metadata["mastra-trace-id"] = span.traceId;
599
- }
600
- const attributes = span.attributes ?? {};
601
- if (span.type === SpanType.MODEL_GENERATION) {
602
- const modelAttr = attributes;
603
- if (modelAttr.model !== void 0) {
604
- payload.metadata.model = modelAttr.model;
605
- }
606
- if (modelAttr.provider !== void 0) {
607
- payload.metadata.provider = modelAttr.provider;
608
- }
609
- if (modelAttr.responseModel !== void 0) {
610
- payload.metadata.model = modelAttr.responseModel;
611
- }
612
- payload.metrics = formatUsageMetrics(modelAttr.usage);
613
- if (modelAttr.completionStartTime) {
614
- payload.metrics.time_to_first_token = (modelAttr.completionStartTime.getTime() - span.startTime.getTime()) / 1e3;
615
- }
616
- if (modelAttr.parameters !== void 0) {
617
- payload.metadata.modelParameters = modelAttr.parameters;
618
- }
619
- const otherAttributes = omitKeys(attributes, [
620
- "model",
621
- "responseModel",
622
- "usage",
623
- "parameters",
624
- "completionStartTime"
625
- ]);
626
- payload.metadata = {
627
- ...payload.metadata,
628
- ...otherAttributes
629
- };
630
- } else {
631
- payload.metadata = {
632
- ...payload.metadata,
633
- ...attributes
634
- };
635
- }
636
- if (span.errorInfo) {
637
- payload.error = span.errorInfo.message;
638
- payload.metadata.errorDetails = span.errorInfo;
639
- }
640
- if (Object.keys(payload.metrics).length === 0) {
641
- delete payload.metrics;
642
- }
643
- payload.metadata = removeNullish(payload.metadata);
644
- return payload;
645
- }
226
+ name = "braintrust";
227
+ #useProvidedLogger;
228
+ #providedLogger;
229
+ #localLogger;
230
+ constructor(config = {}) {
231
+ const resolvedApiKey = config.apiKey ?? process.env.BRAINTRUST_API_KEY;
232
+ const resolvedEndpoint = config.endpoint ?? process.env.BRAINTRUST_ENDPOINT;
233
+ super({
234
+ ...config,
235
+ apiKey: resolvedApiKey,
236
+ endpoint: resolvedEndpoint
237
+ });
238
+ this.#useProvidedLogger = !!config.braintrustLogger;
239
+ if (this.#useProvidedLogger) this.#providedLogger = config.braintrustLogger;
240
+ else {
241
+ if (!this.config.apiKey) {
242
+ this.setDisabled(`Missing required API key. Set BRAINTRUST_API_KEY environment variable or pass apiKey in config.`);
243
+ return;
244
+ }
245
+ this.#localLogger = void 0;
246
+ }
247
+ }
248
+ async getLocalLogger() {
249
+ if (this.#localLogger) return this.#localLogger;
250
+ try {
251
+ const logger = await initLogger({
252
+ projectName: this.config.projectName ?? "mastra-tracing",
253
+ apiKey: this.config.apiKey,
254
+ appUrl: this.config.endpoint,
255
+ ...this.config.tuningParameters
256
+ });
257
+ this.#localLogger = logger;
258
+ return logger;
259
+ } catch (err) {
260
+ this.logger.error("Braintrust exporter: Failed to initialize logger", { error: err });
261
+ this.setDisabled("Failed to initialize Braintrust logger");
262
+ }
263
+ }
264
+ async onScoreEvent(event) {
265
+ if (this.isDisabled) return;
266
+ const { score } = event;
267
+ const rowId = score.spanId ?? score.traceId;
268
+ if (!rowId) {
269
+ this.logger.debug("Braintrust exporter: skipping score with no spanId or traceId", { scorerId: score.scorerId });
270
+ return;
271
+ }
272
+ const logger = this.#useProvidedLogger ? this.#providedLogger : await this.getLocalLogger();
273
+ if (!logger) return;
274
+ const name = score.scorerName ?? score.scorerId;
275
+ try {
276
+ logger.logFeedback({
277
+ id: rowId,
278
+ scores: { [name]: score.score },
279
+ ...score.reason ? { comment: score.reason } : {},
280
+ metadata: {
281
+ scorerId: score.scorerId,
282
+ ...score.scoreSource ? { scoreSource: score.scoreSource } : {},
283
+ ...score.metadata ?? {}
284
+ },
285
+ source: "external"
286
+ });
287
+ } catch (err) {
288
+ this.logger.error("Braintrust exporter: Failed to submit score", {
289
+ error: err,
290
+ traceId: score.traceId,
291
+ spanId: score.spanId,
292
+ scorerId: score.scorerId
293
+ });
294
+ }
295
+ }
296
+ startSpan(args) {
297
+ const { parent, span } = args;
298
+ const payload = this.buildSpanPayload(span);
299
+ const braintrustSpan = parent.startSpan({
300
+ spanId: span.id,
301
+ name: span.name,
302
+ type: mapSpanType(span.type),
303
+ startTime: span.startTime.getTime() / 1e3,
304
+ event: {
305
+ id: span.id,
306
+ ...payload
307
+ }
308
+ });
309
+ const isModelGeneration = span.type === SpanType.MODEL_GENERATION;
310
+ return {
311
+ span: braintrustSpan,
312
+ spanType: span.type,
313
+ threadData: isModelGeneration ? [] : void 0,
314
+ pendingToolResults: isModelGeneration ? /* @__PURE__ */ new Map() : void 0
315
+ };
316
+ }
317
+ async _buildRoot(_args) {
318
+ if (this.#useProvidedLogger) {
319
+ let externalSpan;
320
+ try {
321
+ externalSpan = this.config.currentSpan?.();
322
+ } catch (err) {
323
+ this.logger.error("Braintrust exporter: Failed to resolve configured currentSpan", { error: err });
324
+ }
325
+ externalSpan ??= currentSpan();
326
+ if (externalSpan && externalSpan.id) return externalSpan;
327
+ else return this.#providedLogger;
328
+ } else return this.getLocalLogger();
329
+ }
330
+ async _buildSpan(args) {
331
+ const { span, traceData } = args;
332
+ if (span.isRootSpan) {
333
+ const root = traceData.getRoot();
334
+ if (root) return this.startSpan({
335
+ parent: root,
336
+ span
337
+ });
338
+ } else {
339
+ const parent = traceData.getParent(args);
340
+ if (parent) {
341
+ const parentSpan = "span" in parent ? parent.span : parent;
342
+ return this.startSpan({
343
+ parent: parentSpan,
344
+ span
345
+ });
346
+ }
347
+ }
348
+ }
349
+ async _buildEvent(args) {
350
+ const spanData = await this._buildSpan(args);
351
+ if (!spanData) return;
352
+ spanData.span.end({ endTime: args.span.startTime.getTime() / 1e3 });
353
+ return spanData.span;
354
+ }
355
+ async _updateSpan(args) {
356
+ const { span, traceData } = args;
357
+ const spanData = traceData.getSpan({ spanId: span.id });
358
+ if (!spanData) return;
359
+ spanData.span.log(this.buildSpanPayload(span, false));
360
+ }
361
+ async _finishSpan(args) {
362
+ const { span, traceData } = args;
363
+ const spanData = traceData.getSpan({ spanId: span.id });
364
+ if (!spanData) return;
365
+ if (span.type === SpanType.MODEL_STEP) this.accumulateModelStepData(span, traceData);
366
+ else if (span.type === SpanType.TOOL_CALL) this.accumulateToolCallResult(span, traceData);
367
+ const payload = span.type === SpanType.MODEL_GENERATION ? this.buildModelGenerationPayload(span, spanData) : this.buildSpanPayload(span, false);
368
+ spanData.span.log(payload);
369
+ if (span.endTime) spanData.span.end({ endTime: span.endTime.getTime() / 1e3 });
370
+ else spanData.span.end();
371
+ }
372
+ async _abortSpan(args) {
373
+ const { span: spanData, reason } = args;
374
+ spanData.span.log({
375
+ error: reason.message,
376
+ metadata: { errorDetails: reason }
377
+ });
378
+ spanData.span.end();
379
+ }
380
+ /**
381
+ * Walk up the tree to find the MODEL_GENERATION ancestor span.
382
+ * Returns the BraintrustSpanData if found, undefined otherwise.
383
+ */
384
+ findModelGenerationAncestor(spanId, traceData) {
385
+ let currentId = spanId;
386
+ while (currentId) {
387
+ const parentId = traceData.getParentId({ spanId: currentId });
388
+ if (!parentId) return void 0;
389
+ const parentSpanData = traceData.getSpan({ spanId: parentId });
390
+ if (parentSpanData?.spanType === SpanType.MODEL_GENERATION) return parentSpanData;
391
+ currentId = parentId;
392
+ }
393
+ }
394
+ /**
395
+ * Accumulate MODEL_STEP data to the parent MODEL_GENERATION's threadData.
396
+ * Called when a MODEL_STEP span ends.
397
+ */
398
+ accumulateModelStepData(span, traceData) {
399
+ const modelGenSpanData = this.findModelGenerationAncestor(span.id, traceData);
400
+ if (!modelGenSpanData?.threadData) return;
401
+ const output = span.output;
402
+ const attributes = span.attributes;
403
+ const stepData = {
404
+ stepSpanId: span.id,
405
+ stepIndex: attributes?.stepIndex ?? 0,
406
+ text: output?.text,
407
+ toolCalls: output?.toolCalls?.map((tc) => ({
408
+ toolCallId: tc.toolCallId,
409
+ toolName: tc.toolName,
410
+ args: tc.args
411
+ }))
412
+ };
413
+ modelGenSpanData.threadData.push(stepData);
414
+ }
415
+ /**
416
+ * Store TOOL_CALL result in parent MODEL_GENERATION's pendingToolResults.
417
+ * Called when a TOOL_CALL span ends.
418
+ * Results are merged into threadData when MODEL_GENERATION ends.
419
+ */
420
+ accumulateToolCallResult(span, traceData) {
421
+ const modelGenSpanData = this.findModelGenerationAncestor(span.id, traceData);
422
+ if (!modelGenSpanData?.pendingToolResults) return;
423
+ const toolCallId = span.input?.toolCallId;
424
+ if (!toolCallId) return;
425
+ modelGenSpanData.pendingToolResults.set(toolCallId, {
426
+ result: span.output,
427
+ startTime: span.startTime
428
+ });
429
+ }
430
+ /**
431
+ * Build the payload for MODEL_GENERATION span, reconstructing output from threadData if available.
432
+ */
433
+ buildModelGenerationPayload(span, spanData) {
434
+ const basePayload = this.buildSpanPayload(span, false);
435
+ const threadData = spanData.threadData;
436
+ if (!threadData || threadData.length === 0) return basePayload;
437
+ if (spanData.pendingToolResults && spanData.pendingToolResults.size > 0) {
438
+ for (const step of threadData) if (step.toolCalls) for (const toolCall of step.toolCalls) {
439
+ const pendingResult = spanData.pendingToolResults.get(toolCall.toolCallId);
440
+ if (pendingResult) {
441
+ toolCall.result = pendingResult.result;
442
+ toolCall.startTime = pendingResult.startTime;
443
+ }
444
+ }
445
+ }
446
+ if (!threadData.some((step) => step.toolCalls && step.toolCalls.length > 0)) return basePayload;
447
+ const reconstructedOutput = reconstructThreadOutput(threadData, span.output);
448
+ return {
449
+ ...basePayload,
450
+ output: reconstructedOutput
451
+ };
452
+ }
453
+ /**
454
+ * Transforms MODEL_GENERATION input to Braintrust Thread view format.
455
+ * Converts AI SDK messages (v4/v5) to OpenAI Chat Completion format, which Braintrust requires
456
+ * for proper rendering of threads (fixes #11023).
457
+ */
458
+ transformInput(input, spanType) {
459
+ if (spanType === SpanType.MODEL_GENERATION) {
460
+ if (Array.isArray(input)) return input.map((msg) => convertAISDKMessage(msg));
461
+ if (input && typeof input === "object" && "messages" in input && Array.isArray(input.messages)) return input.messages.map((msg) => convertAISDKMessage(msg));
462
+ }
463
+ return input;
464
+ }
465
+ /**
466
+ * Transforms MODEL_GENERATION output to Braintrust Thread view format.
467
+ */
468
+ transformOutput(output, spanType) {
469
+ if (spanType === SpanType.MODEL_GENERATION) {
470
+ if (!output || typeof output !== "object") return output;
471
+ const { text, ...rest } = output;
472
+ return {
473
+ role: "assistant",
474
+ content: text,
475
+ ...removeNullish(rest)
476
+ };
477
+ }
478
+ return output;
479
+ }
480
+ isToolSpan(span) {
481
+ return span.type === SpanType.TOOL_CALL || span.type === SpanType.MCP_TOOL_CALL || span.type === SpanType.PROVIDER_TOOL_CALL;
482
+ }
483
+ getToolName(span) {
484
+ if (span.entityName) return span.entityName;
485
+ return /'([^']+)'/.exec(span.name)?.[1] ?? span.name;
486
+ }
487
+ getToolCallId(span) {
488
+ return span.attributes?.toolCallId ?? span.input?.toolCallId ?? span.id;
489
+ }
490
+ toToolCallInput(span) {
491
+ const args = span.input;
492
+ let argsString;
493
+ if (typeof args === "string") argsString = args;
494
+ else try {
495
+ argsString = JSON.stringify(args ?? {});
496
+ } catch {
497
+ argsString = "[unserializable result]";
498
+ }
499
+ return [{
500
+ role: "assistant",
501
+ content: "",
502
+ tool_calls: [{
503
+ id: this.getToolCallId(span),
504
+ type: "function",
505
+ function: {
506
+ name: this.getToolName(span),
507
+ arguments: argsString
508
+ }
509
+ }]
510
+ }];
511
+ }
512
+ toToolCallOutput(span) {
513
+ return {
514
+ role: "tool",
515
+ content: serializeToolResult(span.output),
516
+ tool_call_id: this.getToolCallId(span)
517
+ };
518
+ }
519
+ buildSpanPayload(span, isCreate = true) {
520
+ const payload = {};
521
+ const isToolType = this.isToolSpan(span);
522
+ if (span.input !== void 0) payload.input = isToolType ? this.toToolCallInput(span) : this.transformInput(span.input, span.type);
523
+ if (span.output !== void 0) payload.output = isToolType ? this.toToolCallOutput(span) : this.transformOutput(span.output, span.type);
524
+ if (isCreate && span.isRootSpan && span.tags?.length) payload.tags = span.tags;
525
+ payload.metrics = {};
526
+ payload.metadata = {
527
+ ...span.metadata,
528
+ spanType: span.type
529
+ };
530
+ if (isCreate) payload.metadata["mastra-trace-id"] = span.traceId;
531
+ const attributes = span.attributes ?? {};
532
+ if (span.type === SpanType.MODEL_GENERATION) {
533
+ const modelAttr = attributes;
534
+ if (modelAttr.model !== void 0) payload.metadata.model = modelAttr.model;
535
+ if (modelAttr.provider !== void 0) payload.metadata.provider = modelAttr.provider;
536
+ if (modelAttr.responseModel !== void 0) payload.metadata.model = modelAttr.responseModel;
537
+ payload.metrics = formatUsageMetrics(modelAttr.usage);
538
+ if (modelAttr.completionStartTime) payload.metrics.time_to_first_token = (modelAttr.completionStartTime.getTime() - span.startTime.getTime()) / 1e3;
539
+ if (modelAttr.parameters !== void 0) payload.metadata.modelParameters = modelAttr.parameters;
540
+ const otherAttributes = omitKeys(attributes, [
541
+ "model",
542
+ "responseModel",
543
+ "usage",
544
+ "parameters",
545
+ "completionStartTime"
546
+ ]);
547
+ payload.metadata = {
548
+ ...payload.metadata,
549
+ ...otherAttributes
550
+ };
551
+ } else payload.metadata = {
552
+ ...payload.metadata,
553
+ ...attributes
554
+ };
555
+ if (span.errorInfo) {
556
+ payload.error = span.errorInfo.message;
557
+ payload.metadata.errorDetails = span.errorInfo;
558
+ }
559
+ if (Object.keys(payload.metrics).length === 0) delete payload.metrics;
560
+ payload.metadata = removeNullish(payload.metadata);
561
+ return payload;
562
+ }
646
563
  };
647
-
564
+ //#endregion
648
565
  export { BraintrustExporter };
649
- //# sourceMappingURL=index.js.map
566
+
650
567
  //# sourceMappingURL=index.js.map