@dbx-tools/appkit-mastra 0.9.32 → 0.9.36

package/lib/src/trace-io.js

@@ -1,6 +1,6 @@
 /**
- * Copy each Mastra chat turn's request/response onto the active OTel
- * root span so Databricks-managed MLflow can display them.
+ * Copy each Mastra chat turn's request/response onto its OTel root span
+ * so Databricks-managed MLflow can display them.
  *
  * Why this exists: MLflow's UC `<target>_trace_unified` view picks the
  * one span whose `parent_span_id` is empty and reads request/response
@@ -10,18 +10,24 @@
  * the view never reads, so chat traces arrive with both columns null
  * even when the spans themselves look healthy.
  *
- * The active span inside the Mastra sub-app is still AppKit's HTTP
- * server span (OTel context is async-local). With `OTEL_PROPAGATORS=none`
- * that span is the trace root - see the package README's observability
- * section for why Apps ingress `traceparent` otherwise hides every turn.
+ * AppKit's HTTP instrumentation records the server span in OTel RPC metadata,
+ * which remains available even when Express makes a middleware-layer child
+ * active. When instrumentation is unavailable, this module creates one
+ * request-lifetime server span and runs Mastra under it.
  *
  * @module
  */
+import { StringDecoder } from "node:string_decoder";
 import { json, log, object } from "@dbx-tools/shared-core";
-import { trace } from "@opentelemetry/api";
+import { context, SpanKind, trace } from "@opentelemetry/api";
+import { getRPCMetadata, RPCType } from "@opentelemetry/core";
 const logger = log.logger("mastra/trace-io");
 /** Cap on each payload copied onto a span, so one turn cannot bloat the export. */
 export const TRACE_IO_LIMIT = 8_000;
+/** Bound for a non-streaming body captured through `res.end` instead of `res.json`. */
+const RESPONSE_BODY_LIMIT = TRACE_IO_LIMIT * 4;
+/** Tracer scope used only when AppKit did not create a recording HTTP span. */
+const CHAT_TURN_TRACER = "@dbx-tools/appkit-mastra/trace-io";
 /**
  * Mount-relative Mastra agent invoke paths that carry a chat turn body
  * (`messages`) and stream an assistant answer. Resume / approve verbs
@@ -32,6 +38,20 @@ const AGENT_TURN_ROUTE = /^(?:\/agents\/[^/]+\/(?:stream|generate)(?:\/|$)|\/cha
 /** Attribute keys the MLflow UC `*_trace_unified` view reads from the root span. */
 export const MLFLOW_SPAN_INPUTS_ATTR = "mlflow.spanInputs";
 export const MLFLOW_SPAN_OUTPUTS_ATTR = "mlflow.spanOutputs";
+/** Return the assistant text from one SSE line, or an empty string. */
+function assistantTextFromSseLine(line) {
+    if (!line.startsWith("data:"))
+        return "";
+    const frame = json.parse(line.slice(5));
+    if (!object.isRecord(frame) || frame.type !== "text-delta")
+        return "";
+    const text = typeof frame.delta === "string"
+        ? frame.delta
+        : object.isRecord(frame.payload)
+            ? frame.payload.text
+            : undefined;
+    return typeof text === "string" ? text : "";
+}
 /**
  * Concatenate the assistant's answer out of an AI SDK SSE transcript.
  *
@@ -43,29 +63,103 @@ export const MLFLOW_SPAN_OUTPUTS_ATTR = "mlflow.spanOutputs";
 export function assistantTextFromSse(body) {
     const parts = [];
     for (const line of body.split("\n")) {
-        if (!line.startsWith("data:"))
-            continue;
-        // SSE carries comment/keepalive lines that are not JSON; they never hold
-        // assistant text, so skipping them is the intended path rather than an error.
-        const frame = json.parse(line.slice(5));
-        if (!object.isRecord(frame) || frame.type !== "text-delta")
-            continue;
-        const text = typeof frame.delta === "string"
-            ? frame.delta
-            : object.isRecord(frame.payload)
-                ? frame.payload.text
-                : undefined;
-        if (typeof text === "string")
+        const text = assistantTextFromSseLine(line);
+        if (text)
             parts.push(text);
     }
-    return parts.join("");
+    return parts.join("").slice(0, TRACE_IO_LIMIT);
+}
+/** Read the final assistant text from a non-streaming Mastra response. */
+export function assistantTextFromJson(body) {
+    if (!object.isRecord(body) || typeof body.text !== "string")
+        return "";
+    return body.text.slice(0, TRACE_IO_LIMIT);
+}
+/** Incrementally assemble UTF-8 SSE text while retaining a bounded JSON fallback. */
+class AssistantResponseCollector {
+    decoder = new StringDecoder("utf8");
+    answer = "";
+    body = "";
+    pendingLine = "";
+    finished = false;
+    write(chunk) {
+        if (this.finished)
+            return;
+        if (typeof chunk === "string") {
+            this.consume(chunk);
+            return;
+        }
+        if (ArrayBuffer.isView(chunk)) {
+            this.consume(this.decoder.write(Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)));
+        }
+    }
+    finish() {
+        if (this.finished)
+            return this.answer || this.jsonAnswer();
+        this.finished = true;
+        this.consume(this.decoder.end());
+        this.consumeSseLine(this.pendingLine);
+        this.pendingLine = "";
+        return this.answer || this.jsonAnswer();
+    }
+    consume(text) {
+        if (!text)
+            return;
+        if (this.body.length < RESPONSE_BODY_LIMIT) {
+            this.body += text.slice(0, RESPONSE_BODY_LIMIT - this.body.length);
+        }
+        this.pendingLine += text;
+        let newline = this.pendingLine.indexOf("\n");
+        while (newline >= 0) {
+            this.consumeSseLine(this.pendingLine.slice(0, newline).replace(/\r$/, ""));
+            this.pendingLine = this.pendingLine.slice(newline + 1);
+            newline = this.pendingLine.indexOf("\n");
+        }
+        if (this.pendingLine.length > RESPONSE_BODY_LIMIT) {
+            this.pendingLine = this.pendingLine.slice(-RESPONSE_BODY_LIMIT);
+        }
+    }
+    consumeSseLine(line) {
+        if (this.answer.length >= TRACE_IO_LIMIT)
+            return;
+        const text = assistantTextFromSseLine(line);
+        this.answer += text.slice(0, TRACE_IO_LIMIT - this.answer.length);
+    }
+    jsonAnswer() {
+        return assistantTextFromJson(json.parse(this.body));
+    }
 }
 /**
- * Express middleware that stamps chat turn I/O onto the active OTel span.
+ * Select the span MLflow treats as the request root.
  *
- * Tee `res.write` / `res.end` instead of listening for `finish`: the HTTP
- * instrumentation ends the root span on finish, and an attribute set after
- * a span ends never reaches the exporter.
+ * OTel HTTP instrumentation stores its server span in RPC metadata. That span
+ * wins over an active Express child. If no recording local span exists, create
+ * one under the current context so enabled W3C propagation remains intact.
+ */
+function resolveTraceTarget() {
+    const activeContext = context.active();
+    const rpc = getRPCMetadata(activeContext);
+    if (rpc?.type === RPCType.HTTP && rpc.span.isRecording()) {
+        return { span: rpc.span, owned: false };
+    }
+    const active = trace.getActiveSpan();
+    if (active?.isRecording())
+        return { span: active, owned: false };
+    const span = trace
+        .getTracer(CHAT_TURN_TRACER)
+        .startSpan("mastra.chat_turn", { kind: SpanKind.SERVER }, activeContext);
+    if (!span.isRecording()) {
+        span.end();
+        return undefined;
+    }
+    return { span, owned: true };
+}
+/**
+ * Express middleware that stamps chat turn I/O onto the exported OTel root.
+ *
+ * Tee `res.write`, `res.json`, and `res.end` instead of listening for `finish`:
+ * HTTP instrumentation ends its server span on finish, and attributes set
+ * after a span ends never reach the exporter.
  *
  * `path` is mount-relative (what the Mastra sub-app sees), e.g.
  * `/agents/support/stream`.
@@ -75,47 +169,66 @@ export function chatTurnTraceIoMiddleware(req, res, next) {
         next();
         return;
     }
-    const span = trace.getActiveSpan();
-    if (!span) {
+    const target = resolveTraceTarget();
+    if (!target) {
         next();
         return;
     }
     const messages = req.body?.messages;
     if (messages !== undefined) {
-        span.setAttribute(MLFLOW_SPAN_INPUTS_ATTR, JSON.stringify(messages).slice(0, TRACE_IO_LIMIT));
+        target.span.setAttribute(MLFLOW_SPAN_INPUTS_ATTR, JSON.stringify(messages).slice(0, TRACE_IO_LIMIT));
     }
-    const chunks = [];
+    const collector = new AssistantResponseCollector();
+    let outputRecorded = false;
+    let ownedSpanEnded = false;
     const passThroughWrite = res.write.bind(res);
     const passThroughEnd = res.end.bind(res);
-    const collect = (chunk) => {
-        if (typeof chunk === "string")
-            chunks.push(chunk);
-        else if (Buffer.isBuffer(chunk))
-            chunks.push(chunk.toString("utf8"));
+    const passThroughJson = res.json.bind(res);
+    const recordOutput = (answer) => {
+        if (outputRecorded || !answer)
+            return;
+        target.span.setAttribute(MLFLOW_SPAN_OUTPUTS_ATTR, answer.slice(0, TRACE_IO_LIMIT));
+        outputRecorded = true;
+    };
+    const endOwnedSpan = () => {
+        if (!target.owned || ownedSpanEnded)
+            return;
+        ownedSpanEnded = true;
+        target.span.end();
     };
     res.write = ((chunk, ...rest) => {
-        collect(chunk);
+        collector.write(chunk);
         return passThroughWrite(chunk, ...rest);
     });
+    res.json = ((body) => {
+        recordOutput(assistantTextFromJson(body));
+        return passThroughJson(body);
+    });
     res.end = ((chunk, ...rest) => {
-        collect(chunk);
-        const answer = assistantTextFromSse(chunks.join(""));
-        if (answer) {
-            span.setAttribute(MLFLOW_SPAN_OUTPUTS_ATTR, answer.slice(0, TRACE_IO_LIMIT));
+        collector.write(chunk);
+        recordOutput(collector.finish());
+        try {
+            return passThroughEnd(chunk, ...rest);
         }
-        return passThroughEnd(chunk, ...rest);
+        finally {
+            endOwnedSpan();
+        }
+    });
+    res.once("close", () => {
+        recordOutput(collector.finish());
+        endOwnedSpan();
     });
-    next();
+    context.with(trace.setSpan(context.active(), target.span), next);
 }
 /**
  * Install {@link chatTurnTraceIoMiddleware} on a Mastra Express sub-app.
  *
  * Call before `MastraServer.init()` so the layer sits ahead of the agent
- * routes. Safe to call unconditionally: with no active span (local, no
- * OTLP) the middleware is a no-op.
+ * routes. Safe to call unconditionally: when no recording tracer is registered,
+ * the middleware is a no-op.
  */
 export function attachChatTurnTraceIo(app) {
     app.use(chatTurnTraceIoMiddleware);
     logger.info("chat turn I/O middleware attached");
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trace-io.js","sourceRoot":"","sources":["../../src/trace-io.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copy each Mastra chat turn's request/response onto the active OTel\n * root span so Databricks-managed MLflow can display them.\n *\n * Why this exists: MLflow's UC `<target>_trace_unified` view picks the\n * one span whose `parent_span_id` is empty and reads request/response\n * from `mlflow.spanInputs` / `mlflow.spanOutputs` (or the `gen_ai.*`\n * equivalents) on THAT span only. Mastra records the turn on its\n * `invoke_agent` child under `mastra.agent_run.input` / `.output`, keys\n * the view never reads, so chat traces arrive with both columns null\n * even when the spans themselves look healthy.\n *\n * The active span inside the Mastra sub-app is still AppKit's HTTP\n * server span (OTel context is async-local). With `OTEL_PROPAGATORS=none`\n * that span is the trace root - see the package README's observability\n * section for why Apps ingress `traceparent` otherwise hides every turn.\n *\n * @module\n */\n\nimport { json, log, object } from \"@dbx-tools/shared-core\";\nimport { trace } from \"@opentelemetry/api\";\nimport type express from \"express\";\n\nconst logger = log.logger(\"mastra/trace-io\");\n\n/** Cap on each payload copied onto a span, so one turn cannot bloat the export. */\nexport const TRACE_IO_LIMIT = 8_000;\n\n/**\n * Mount-relative Mastra agent invoke paths that carry a chat turn body\n * (`messages`) and stream an assistant answer. Resume / approve verbs\n * are intentionally excluded: their bodies are tool decisions, not the\n * user prompt, and they rarely produce a fresh answer worth surfacing.\n */\nconst AGENT_TURN_ROUTE = /^(?:\\/agents\\/[^/]+\\/(?:stream|generate)(?:\\/|$)|\\/chat\\/[^/]+$)/i;\n\n/** Attribute keys the MLflow UC `*_trace_unified` view reads from the root span. */\nexport const MLFLOW_SPAN_INPUTS_ATTR = \"mlflow.spanInputs\";\nexport const MLFLOW_SPAN_OUTPUTS_ATTR = \"mlflow.spanOutputs\";\n\n/**\n * Concatenate the assistant's answer out of an AI SDK SSE transcript.\n *\n * The agent streams its reply as `text-delta` frames\n * (`data: {\"type\":\"text-delta\",\"payload\":{\"text\":\"...\"}}`), so the full\n * answer only ever exists as deltas on the wire and has to be\n * reassembled here.\n */\nexport function assistantTextFromSse(body: string): string {\n  const parts: string[] = [];\n  for (const line of body.split(\"\\n\")) {\n    if (!line.startsWith(\"data:\")) continue;\n    // SSE carries comment/keepalive lines that are not JSON; they never hold\n    // assistant text, so skipping them is the intended path rather than an error.\n    const frame = json.parse(line.slice(5));\n    if (!object.isRecord(frame) || frame.type !== \"text-delta\") continue;\n    const text =\n      typeof frame.delta === \"string\"\n        ? frame.delta\n        : object.isRecord(frame.payload)\n          ? frame.payload.text\n          : undefined;\n    if (typeof text === \"string\") parts.push(text);\n  }\n  return parts.join(\"\");\n}\n\n/**\n * Express middleware that stamps chat turn I/O onto the active OTel span.\n *\n * Tee `res.write` / `res.end` instead of listening for `finish`: the HTTP\n * instrumentation ends the root span on finish, and an attribute set after\n * a span ends never reaches the exporter.\n *\n * `path` is mount-relative (what the Mastra sub-app sees), e.g.\n * `/agents/support/stream`.\n */\nexport function chatTurnTraceIoMiddleware(\n  req: express.Request,\n  res: express.Response,\n  next: express.NextFunction,\n): void {\n  if (req.method !== \"POST\" || !AGENT_TURN_ROUTE.test(req.path)) {\n    next();\n    return;\n  }\n  const span = trace.getActiveSpan();\n  if (!span) {\n    next();\n    return;\n  }\n\n  const messages = (req.body as { messages?: unknown } | undefined)?.messages;\n  if (messages !== undefined) {\n    span.setAttribute(MLFLOW_SPAN_INPUTS_ATTR, JSON.stringify(messages).slice(0, TRACE_IO_LIMIT));\n  }\n\n  const chunks: string[] = [];\n  const passThroughWrite = res.write.bind(res) as (...args: unknown[]) => boolean;\n  const passThroughEnd = res.end.bind(res) as (...args: unknown[]) => unknown;\n  const collect = (chunk: unknown): void => {\n    if (typeof chunk === \"string\") chunks.push(chunk);\n    else if (Buffer.isBuffer(chunk)) chunks.push(chunk.toString(\"utf8\"));\n  };\n\n  res.write = ((chunk: unknown, ...rest: unknown[]) => {\n    collect(chunk);\n    return passThroughWrite(chunk, ...rest);\n  }) as typeof res.write;\n\n  res.end = ((chunk?: unknown, ...rest: unknown[]) => {\n    collect(chunk);\n    const answer = assistantTextFromSse(chunks.join(\"\"));\n    if (answer) {\n      span.setAttribute(MLFLOW_SPAN_OUTPUTS_ATTR, answer.slice(0, TRACE_IO_LIMIT));\n    }\n    return passThroughEnd(chunk, ...rest);\n  }) as typeof res.end;\n\n  next();\n}\n\n/**\n * Install {@link chatTurnTraceIoMiddleware} on a Mastra Express sub-app.\n *\n * Call before `MastraServer.init()` so the layer sits ahead of the agent\n * routes. Safe to call unconditionally: with no active span (local, no\n * OTLP) the middleware is a no-op.\n */\nexport function attachChatTurnTraceIo(app: express.Express): void {\n  app.use(chatTurnTraceIoMiddleware);\n  logger.info(\"chat turn I/O middleware attached\");\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trace-io.js","sourceRoot":"","sources":["../../src/trace-io.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copy each Mastra chat turn's request/response onto its OTel root span\n * so Databricks-managed MLflow can display them.\n *\n * Why this exists: MLflow's UC `<target>_trace_unified` view picks the\n * one span whose `parent_span_id` is empty and reads request/response\n * from `mlflow.spanInputs` / `mlflow.spanOutputs` (or the `gen_ai.*`\n * equivalents) on THAT span only. Mastra records the turn on its\n * `invoke_agent` child under `mastra.agent_run.input` / `.output`, keys\n * the view never reads, so chat traces arrive with both columns null\n * even when the spans themselves look healthy.\n *\n * AppKit's HTTP instrumentation records the server span in OTel RPC metadata,\n * which remains available even when Express makes a middleware-layer child\n * active. When instrumentation is unavailable, this module creates one\n * request-lifetime server span and runs Mastra under it.\n *\n * @module\n */\n\nimport { StringDecoder } from \"node:string_decoder\";\n\nimport { json, log, object } from \"@dbx-tools/shared-core\";\nimport { context, SpanKind, trace, type Span } from \"@opentelemetry/api\";\nimport { getRPCMetadata, RPCType } from \"@opentelemetry/core\";\nimport type express from \"express\";\n\nconst logger = log.logger(\"mastra/trace-io\");\n\n/** Cap on each payload copied onto a span, so one turn cannot bloat the export. */\nexport const TRACE_IO_LIMIT = 8_000;\n\n/** Bound for a non-streaming body captured through `res.end` instead of `res.json`. */\nconst RESPONSE_BODY_LIMIT = TRACE_IO_LIMIT * 4;\n\n/** Tracer scope used only when AppKit did not create a recording HTTP span. */\nconst CHAT_TURN_TRACER = \"@dbx-tools/appkit-mastra/trace-io\";\n\n/**\n * Mount-relative Mastra agent invoke paths that carry a chat turn body\n * (`messages`) and stream an assistant answer. Resume / approve verbs\n * are intentionally excluded: their bodies are tool decisions, not the\n * user prompt, and they rarely produce a fresh answer worth surfacing.\n */\nconst AGENT_TURN_ROUTE = /^(?:\\/agents\\/[^/]+\\/(?:stream|generate)(?:\\/|$)|\\/chat\\/[^/]+$)/i;\n\n/** Attribute keys the MLflow UC `*_trace_unified` view reads from the root span. */\nexport const MLFLOW_SPAN_INPUTS_ATTR = \"mlflow.spanInputs\";\nexport const MLFLOW_SPAN_OUTPUTS_ATTR = \"mlflow.spanOutputs\";\n\ninterface TraceTarget {\n  span: Span;\n  owned: boolean;\n}\n\n/** Return the assistant text from one SSE line, or an empty string. */\nfunction assistantTextFromSseLine(line: string): string {\n  if (!line.startsWith(\"data:\")) return \"\";\n  const frame = json.parse(line.slice(5));\n  if (!object.isRecord(frame) || frame.type !== \"text-delta\") return \"\";\n  const text =\n    typeof frame.delta === \"string\"\n      ? frame.delta\n      : object.isRecord(frame.payload)\n        ? frame.payload.text\n        : undefined;\n  return typeof text === \"string\" ? text : \"\";\n}\n\n/**\n * Concatenate the assistant's answer out of an AI SDK SSE transcript.\n *\n * The agent streams its reply as `text-delta` frames\n * (`data: {\"type\":\"text-delta\",\"payload\":{\"text\":\"...\"}}`), so the full\n * answer only ever exists as deltas on the wire and has to be\n * reassembled here.\n */\nexport function assistantTextFromSse(body: string): string {\n  const parts: string[] = [];\n  for (const line of body.split(\"\\n\")) {\n    const text = assistantTextFromSseLine(line);\n    if (text) parts.push(text);\n  }\n  return parts.join(\"\").slice(0, TRACE_IO_LIMIT);\n}\n\n/** Read the final assistant text from a non-streaming Mastra response. */\nexport function assistantTextFromJson(body: unknown): string {\n  if (!object.isRecord(body) || typeof body.text !== \"string\") return \"\";\n  return body.text.slice(0, TRACE_IO_LIMIT);\n}\n\n/** Incrementally assemble UTF-8 SSE text while retaining a bounded JSON fallback. */\nclass AssistantResponseCollector {\n  private readonly decoder = new StringDecoder(\"utf8\");\n  private answer = \"\";\n  private body = \"\";\n  private pendingLine = \"\";\n  private finished = false;\n\n  write(chunk: unknown): void {\n    if (this.finished) return;\n    if (typeof chunk === \"string\") {\n      this.consume(chunk);\n      return;\n    }\n    if (ArrayBuffer.isView(chunk)) {\n      this.consume(\n        this.decoder.write(Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)),\n      );\n    }\n  }\n\n  finish(): string {\n    if (this.finished) return this.answer || this.jsonAnswer();\n    this.finished = true;\n    this.consume(this.decoder.end());\n    this.consumeSseLine(this.pendingLine);\n    this.pendingLine = \"\";\n    return this.answer || this.jsonAnswer();\n  }\n\n  private consume(text: string): void {\n    if (!text) return;\n    if (this.body.length < RESPONSE_BODY_LIMIT) {\n      this.body += text.slice(0, RESPONSE_BODY_LIMIT - this.body.length);\n    }\n    this.pendingLine += text;\n    let newline = this.pendingLine.indexOf(\"\\n\");\n    while (newline >= 0) {\n      this.consumeSseLine(this.pendingLine.slice(0, newline).replace(/\\r$/, \"\"));\n      this.pendingLine = this.pendingLine.slice(newline + 1);\n      newline = this.pendingLine.indexOf(\"\\n\");\n    }\n    if (this.pendingLine.length > RESPONSE_BODY_LIMIT) {\n      this.pendingLine = this.pendingLine.slice(-RESPONSE_BODY_LIMIT);\n    }\n  }\n\n  private consumeSseLine(line: string): void {\n    if (this.answer.length >= TRACE_IO_LIMIT) return;\n    const text = assistantTextFromSseLine(line);\n    this.answer += text.slice(0, TRACE_IO_LIMIT - this.answer.length);\n  }\n\n  private jsonAnswer(): string {\n    return assistantTextFromJson(json.parse(this.body));\n  }\n}\n\n/**\n * Select the span MLflow treats as the request root.\n *\n * OTel HTTP instrumentation stores its server span in RPC metadata. That span\n * wins over an active Express child. If no recording local span exists, create\n * one under the current context so enabled W3C propagation remains intact.\n */\nfunction resolveTraceTarget(): TraceTarget | undefined {\n  const activeContext = context.active();\n  const rpc = getRPCMetadata(activeContext);\n  if (rpc?.type === RPCType.HTTP && rpc.span.isRecording()) {\n    return { span: rpc.span, owned: false };\n  }\n\n  const active = trace.getActiveSpan();\n  if (active?.isRecording()) return { span: active, owned: false };\n\n  const span = trace\n    .getTracer(CHAT_TURN_TRACER)\n    .startSpan(\"mastra.chat_turn\", { kind: SpanKind.SERVER }, activeContext);\n  if (!span.isRecording()) {\n    span.end();\n    return undefined;\n  }\n  return { span, owned: true };\n}\n\n/**\n * Express middleware that stamps chat turn I/O onto the exported OTel root.\n *\n * Tee `res.write`, `res.json`, and `res.end` instead of listening for `finish`:\n * HTTP instrumentation ends its server span on finish, and attributes set\n * after a span ends never reach the exporter.\n *\n * `path` is mount-relative (what the Mastra sub-app sees), e.g.\n * `/agents/support/stream`.\n */\nexport function chatTurnTraceIoMiddleware(\n  req: express.Request,\n  res: express.Response,\n  next: express.NextFunction,\n): void {\n  if (req.method !== \"POST\" || !AGENT_TURN_ROUTE.test(req.path)) {\n    next();\n    return;\n  }\n  const target = resolveTraceTarget();\n  if (!target) {\n    next();\n    return;\n  }\n\n  const messages = (req.body as { messages?: unknown } | undefined)?.messages;\n  if (messages !== undefined) {\n    target.span.setAttribute(\n      MLFLOW_SPAN_INPUTS_ATTR,\n      JSON.stringify(messages).slice(0, TRACE_IO_LIMIT),\n    );\n  }\n\n  const collector = new AssistantResponseCollector();\n  let outputRecorded = false;\n  let ownedSpanEnded = false;\n  const passThroughWrite = res.write.bind(res) as (...args: unknown[]) => boolean;\n  const passThroughEnd = res.end.bind(res) as (...args: unknown[]) => unknown;\n  const passThroughJson = res.json.bind(res) as (body?: unknown) => express.Response;\n  const recordOutput = (answer: string): void => {\n    if (outputRecorded || !answer) return;\n    target.span.setAttribute(MLFLOW_SPAN_OUTPUTS_ATTR, answer.slice(0, TRACE_IO_LIMIT));\n    outputRecorded = true;\n  };\n  const endOwnedSpan = (): void => {\n    if (!target.owned || ownedSpanEnded) return;\n    ownedSpanEnded = true;\n    target.span.end();\n  };\n\n  res.write = ((chunk: unknown, ...rest: unknown[]) => {\n    collector.write(chunk);\n    return passThroughWrite(chunk, ...rest);\n  }) as typeof res.write;\n\n  res.json = ((body?: unknown) => {\n    recordOutput(assistantTextFromJson(body));\n    return passThroughJson(body);\n  }) as typeof res.json;\n\n  res.end = ((chunk?: unknown, ...rest: unknown[]) => {\n    collector.write(chunk);\n    recordOutput(collector.finish());\n    try {\n      return passThroughEnd(chunk, ...rest);\n    } finally {\n      endOwnedSpan();\n    }\n  }) as typeof res.end;\n\n  res.once(\"close\", () => {\n    recordOutput(collector.finish());\n    endOwnedSpan();\n  });\n\n  context.with(trace.setSpan(context.active(), target.span), next);\n}\n\n/**\n * Install {@link chatTurnTraceIoMiddleware} on a Mastra Express sub-app.\n *\n * Call before `MastraServer.init()` so the layer sits ahead of the agent\n * routes. Safe to call unconditionally: when no recording tracer is registered,\n * the middleware is a no-op.\n */\nexport function attachChatTurnTraceIo(app: express.Express): void {\n  app.use(chatTurnTraceIoMiddleware);\n  logger.info(\"chat turn I/O middleware attached\");\n}\n"]}