@azure/ai-projects 2.7.1 → 2.9.0

package/dist/commonjs/tracing/voiceAgentTracing.js

@@ -0,0 +1,705 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var voiceAgentTracing_exports = {};
+__export(voiceAgentTracing_exports, {
+  VoiceAgentRealtimeTracing: () => VoiceAgentRealtimeTracing,
+  traceVoiceAgentOperation: () => traceVoiceAgentOperation
+});
+module.exports = __toCommonJS(voiceAgentTracing_exports);
+var import_api = require("@opentelemetry/api");
+var import_core_rest_pipeline = require("@azure/core-rest-pipeline");
+var import_logger = require("../logger.js");
+var import_attributes = require("./attributes.js");
+var import_tracingClient = require("./tracingClient.js");
+var import_metrics = require("./metrics.js");
+var import_constants = require("./constants.js");
+const prefix = "az.ai.voice_agents.";
+const maxResponses = 64;
+const maxInputItems = 64;
+const maxParts = 32;
+const maxContentLength = 4096;
+const safeErrorTypes = /* @__PURE__ */ new Set([
+  "Error",
+  "TypeError",
+  "AbortError",
+  "RestError",
+  "VoiceAgentAuthenticationError",
+  "VoiceAgentConnectionError",
+  "VoiceAgentProtocolError",
+  "invalid_request_error",
+  "server_error",
+  "authentication_error",
+  "rate_limit_error"
+]);
+const safeErrorCodes = /* @__PURE__ */ new Set([
+  "agent_disabled",
+  "invalid_request",
+  "invalid_request_error",
+  "invalid_event",
+  "invalid_state",
+  "rate_limit_exceeded",
+  "insufficient_quota",
+  "session_expired",
+  "authentication_error",
+  "permission_denied",
+  "server_error"
+]);
+function serverErrorAttributes(type, code) {
+  const attributes = {
+    [import_constants.ERROR_TYPE]: typeof type === "string" && safeErrorTypes.has(type) ? type : "Error"
+  };
+  if (typeof code === "string" && safeErrorCodes.has(code)) {
+    attributes[`${prefix}error.code`] = code;
+  }
+  return attributes;
+}
+function recordTelemetry(action) {
+  try {
+    action();
+  } catch {
+    import_logger.logger.warning("Unable to record Voice Agents telemetry.");
+  }
+}
+function commonAttributes(span, endpoint) {
+  span.setAttribute(import_constants.GEN_AI_PROVIDER_NAME, import_constants.AGENTS_PROVIDER);
+  span.setAttribute(import_constants.AZ_NAMESPACE, import_constants.AZ_NAMESPACE_VALUE);
+  (0, import_attributes.setServerAttributes)(span, endpoint);
+}
+function fail(span, error) {
+  const type = (0, import_core_rest_pipeline.isRestError)(error) ? "RestError" : error instanceof Error && safeErrorTypes.has(error.name) ? error.name : "Error";
+  span.setAttribute(import_constants.ERROR_TYPE, type);
+  if ((0, import_core_rest_pipeline.isRestError)(error) && error.statusCode !== void 0) {
+    span.setAttribute("http.response.status_code", error.statusCode);
+  }
+  span.setStatus({ code: import_api.SpanStatusCode.ERROR });
+}
+async function traceVoiceAgentOperation(operationName, endpoint, config, operation, resultAttributes) {
+  if (!config?.enabled) {
+    return operation();
+  }
+  let recording;
+  recordTelemetry(() => {
+    recording = (0, import_tracingClient.startSpan)(operationName);
+    commonAttributes(recording.span, endpoint);
+    recording.span.setAttribute(
+      operationName === "create_agent" ? import_constants.GEN_AI_OPERATION_NAME : `${prefix}operation`,
+      operationName.slice(operationName.lastIndexOf(".") + 1)
+    );
+  });
+  if (!recording) return operation();
+  const { span, ctx } = recording;
+  try {
+    const result = await (0, import_tracingClient.runInSpanContext)(ctx, operation);
+    recordTelemetry(() => {
+      if (resultAttributes) span.setAttributes(resultAttributes(result));
+    });
+    return result;
+  } catch (error) {
+    recordTelemetry(() => {
+      if (!(error instanceof Error && error.name === "AbortError")) fail(span, error);
+      else span.setAttribute(`${prefix}cancelled`, true);
+    });
+    throw error;
+  } finally {
+    recordTelemetry(() => span.end());
+  }
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function limitedContent(value) {
+  return typeof value === "string" ? value.slice(0, maxContentLength) : void 0;
+}
+function messagePart(value, contentRecording) {
+  const part = asRecord(value);
+  const type = part?.type;
+  if (!part || typeof type !== "string" || !["input_text", "output_text", "text", "input_audio", "output_audio", "audio"].includes(type)) {
+    return void 0;
+  }
+  const audio = type.includes("audio");
+  const summary = { type: audio ? "audio" : "text" };
+  if (contentRecording) {
+    const content = limitedContent(audio ? part.transcript : part.text);
+    if (content !== void 0) summary.content = content;
+  }
+  return summary;
+}
+function messages(item, contentRecording) {
+  const record = asRecord(item);
+  if (!record) return void 0;
+  if (record.type === "function_call" || record.type === "function_call_output" || record.type === "mcp_call") {
+    const part = {
+      type: record.type === "function_call_output" ? "tool_call_response" : "tool_call"
+    };
+    if (typeof record.call_id === "string") part.id = record.call_id;
+    if (contentRecording) {
+      if (typeof record.name === "string") part.name = limitedContent(record.name);
+      if (typeof record.arguments === "string") part.arguments = limitedContent(record.arguments);
+      if (typeof record.output === "string") part.result = limitedContent(record.output);
+    }
+    return { role: record.type === "function_call_output" ? "tool" : "assistant", parts: [part] };
+  }
+  if (record.type !== "message") return void 0;
+  const parts = [];
+  if (Array.isArray(record.content)) {
+    for (const value of record.content.slice(0, maxParts)) {
+      const summary = messagePart(value, contentRecording);
+      if (summary) parts.push(summary);
+    }
+  }
+  const role = record.role === "system" || record.role === "user" ? record.role : "assistant";
+  return parts.length ? { role, parts } : void 0;
+}
+class VoiceAgentRealtimeTracing {
+  constructor(endpoint, config, transport = "websocket") {
+    this.endpoint = endpoint;
+    this.config = config;
+    recordTelemetry(() => {
+      this.session = (0, import_tracingClient.startSpan)("voice_agents.realtime.session");
+      commonAttributes(this.session.span, endpoint);
+      this.session.span.setAttribute(`${prefix}connection.transport`, transport);
+      this.connectSpan = (0, import_tracingClient.startSpan)("voice_agents.realtime.connect", this.session.ctx).span;
+      commonAttributes(this.connectSpan, endpoint);
+      this.connectSpan.setAttribute(`${prefix}connection.transport`, transport);
+    });
+  }
+  endpoint;
+  config;
+  responses = /* @__PURE__ */ new Map();
+  session;
+  connectSpan;
+  ended = false;
+  connected = false;
+  model;
+  inputAudioBytes = 0;
+  inputSequence = 0;
+  nextInputSequence = 0;
+  inputAudioBuffer;
+  inputAudioItems = /* @__PURE__ */ new Map();
+  pendingAudioCommits = { items: [], skipped: 0 };
+  pendingAudioMessages = { items: [], skipped: 0 };
+  pendingAudioClears = 0;
+  untrackedInputItems = 0;
+  finishedResponses = 0;
+  untrackedResponses = 0;
+  opened() {
+    recordTelemetry(() => {
+      if (this.ended) return;
+      this.connected = true;
+      this.connectSpan?.end();
+      this.connectSpan = void 0;
+    });
+  }
+  reserveSend(event) {
+    let reservation;
+    recordTelemetry(() => {
+      if (this.ended || !this.session || event.type !== "conversation.item.create") return;
+      const summary = messages(event.item, this.config.contentRecording);
+      const item = asRecord(event.item);
+      if (!summary) return;
+      reservation = { sequence: ++this.nextInputSequence };
+      if (summary.role !== "user" || !summary.parts.some((part) => part.type === "audio") || typeof item?.id === "string" || this.pendingAudioMessages.items.length >= maxInputItems || this.pendingAudioMessages.skipped > 0) {
+        return;
+      }
+      reservation.audio = { sequence: reservation.sequence, pendingSend: true };
+      this.enqueueInputAudio(this.pendingAudioMessages, reservation.audio);
+    });
+    return reservation;
+  }
+  sent(event, reservation) {
+    recordTelemetry(() => {
+      if (this.ended || !this.session) return;
+      if (event.type === "input_audio_buffer.append") {
+        this.inputAudioBytes += Math.max(
+          0,
+          Math.floor(event.audio.length * 3 / 4) - (event.audio.endsWith("==") ? 2 : event.audio.endsWith("=") ? 1 : 0)
+        );
+        if (!this.inputAudioBuffer) {
+          this.inputAudioBuffer = this.startInputAudio();
+        } else if (this.inputAudioBuffer.sequence !== this.inputSequence) {
+          this.inputSequence = ++this.nextInputSequence;
+          this.inputAudioBuffer.sequence = this.inputSequence;
+          this.setInputAudioSummary();
+        }
+      } else if (event.type === "input_audio_buffer.commit") {
+        if (this.inputAudioBuffer) {
+          this.enqueueInputAudio(this.pendingAudioCommits, this.inputAudioBuffer);
+          this.inputAudioBuffer = void 0;
+        }
+      } else if (event.type === "input_audio_buffer.clear") {
+        this.inputAudioBuffer = void 0;
+        this.pendingAudioClears++;
+      } else if (event.type === "conversation.item.create") {
+        const summary = messages(event.item, this.config.contentRecording);
+        const item = asRecord(event.item);
+        if (summary) {
+          const sequence = reservation?.sequence ?? ++this.nextInputSequence;
+          if (summary.role === "user" && summary.parts.some((part) => part.type === "audio")) {
+            const input = reservation?.audio ?? { sequence };
+            input.pendingSend = void 0;
+            if (!reservation?.audio) {
+              if (typeof item?.id === "string") {
+                this.rememberInputAudio(item.id, input);
+              } else {
+                this.enqueueInputAudio(this.pendingAudioMessages, input);
+              }
+            }
+          }
+          if (sequence >= this.inputSequence) {
+            this.inputSequence = sequence;
+            this.session.span.setAttribute(import_constants.GEN_AI_INPUT_MESSAGES, JSON.stringify([summary]));
+            if (reservation?.audio?.pendingTranscript !== void 0) {
+              this.setInputAudioSummary(reservation.audio.pendingTranscript);
+            }
+          }
+        }
+        if (item?.type === "function_call_output" && typeof item.call_id === "string") {
+          this.session.span.addEvent("voice_agents.tool.output_sent", {
+            [import_constants.GEN_AI_TOOL_CALL_ID]: item.call_id
+          });
+        }
+      } else if (event.type === "response.cancel") {
+        this.session.span.addEvent("voice_agents.response.cancel_requested");
+      }
+    });
+  }
+  sendFailed(error, reservation) {
+    recordTelemetry(() => {
+      if (reservation?.audio) this.rollbackPendingAudioMessage(reservation.audio);
+      if (!this.ended) {
+        this.session?.span.addEvent("voice_agents.send.failed", {
+          [import_constants.ERROR_TYPE]: error instanceof Error && safeErrorTypes.has(error.name) ? error.name : "Error"
+        });
+      }
+    });
+  }
+  received(event) {
+    recordTelemetry(() => {
+      if (this.ended || !this.session || event.type === "unknown") return;
+      switch (event.type) {
+        case "session.created":
+        case "session.updated":
+          this.model = event.session.model;
+          this.session.span.setAttribute(`${prefix}session.id`, event.session.id);
+          if (event.type === "session.created" && event.conversation_id) {
+            this.session.span.setAttribute(import_constants.GEN_AI_CONVERSATION_ID, event.conversation_id);
+          }
+          if (this.model) this.session.span.setAttribute(import_constants.GEN_AI_REQUEST_MODEL, this.model);
+          break;
+        case "input_audio_buffer.speech_started":
+          if (!this.inputAudioItems.has(event.item_id)) {
+            const buffer = this.inputAudioBuffer;
+            const input = buffer && buffer.itemId === void 0 ? buffer : this.startInputAudio();
+            this.rememberInputAudio(event.item_id, input);
+            this.inputAudioBuffer = input;
+          }
+          break;
+        case "input_audio_buffer.committed": {
+          const pending = this.pendingAudioCommits.items.length > 0 || this.pendingAudioCommits.skipped > 0;
+          let input = this.matchInputAudio(this.pendingAudioCommits, event.item_id);
+          if (!input) {
+            if (pending) break;
+            input = this.inputAudioBuffer ?? this.startInputAudio();
+            this.rememberInputAudio(event.item_id, input);
+          }
+          if (this.inputAudioBuffer === input) this.inputAudioBuffer = void 0;
+          break;
+        }
+        case "input_audio_buffer.cleared":
+          if (this.pendingAudioClears > 0) this.pendingAudioClears--;
+          else this.inputAudioBuffer = void 0;
+          break;
+        case "conversation.item.added":
+        case "conversation.item.created": {
+          const item = asRecord(event.item);
+          const summary = messages(event.item, false);
+          if (typeof item?.id === "string" && summary?.role === "user" && summary.parts.some((part) => part.type === "audio")) {
+            this.matchInputAudio(this.pendingAudioMessages, item.id);
+          }
+          break;
+        }
+        case "response.created":
+          this.beginResponse(event.response);
+          break;
+        case "response.output_audio.delta": {
+          const tracked = this.responses.get(event.response_id);
+          if (tracked) {
+            tracked.audioBytes += event.delta.byteLength;
+            if (event.delta.byteLength > 0) {
+              tracked.firstAudioInSeconds ??= (performance.now() - tracked.started) / 1e3;
+            }
+          }
+          break;
+        }
+        case "response.done":
+          this.endResponse(event.response);
+          break;
+        case "response.output_text.done":
+        case "response.output_audio_transcript.done": {
+          const tracked = this.responses.get(event.response_id);
+          if (tracked) {
+            const part = {
+              type: event.type === "response.output_text.done" ? "text" : "audio"
+            };
+            if (this.config.contentRecording) {
+              part.content = limitedContent(
+                event.type === "response.output_text.done" ? event.text : event.transcript
+              );
+            }
+            this.recordOutputPart(tracked, event.item_id, event.content_index, part);
+          }
+          break;
+        }
+        case "response.output_audio.done": {
+          const tracked = this.responses.get(event.response_id);
+          if (tracked) {
+            this.recordOutputPart(tracked, event.item_id, event.content_index, { type: "audio" });
+          }
+          break;
+        }
+        case "response.function_call_arguments.done": {
+          const span = this.responses.get(event.response_id)?.span ?? this.session.span;
+          const attributes = {
+            [import_constants.GEN_AI_TOOL_CALL_ID]: event.call_id,
+            [`${prefix}tool.kind`]: "function"
+          };
+          if (this.config.contentRecording) {
+            attributes["gen_ai.tool.name"] = limitedContent(event.name);
+            attributes[`${prefix}tool.arguments`] = limitedContent(event.arguments);
+          }
+          span.addEvent("voice_agents.tool.requested", attributes);
+          const tracked = this.responses.get(event.response_id);
+          const summary = messages(
+            {
+              type: "function_call",
+              call_id: event.call_id,
+              name: event.name,
+              arguments: event.arguments
+            },
+            this.config.contentRecording
+          );
+          if (tracked && summary && tracked.outputMessages.size < maxParts) {
+            tracked.outputMessages.set(`tool:${event.call_id}`, summary);
+          }
+          break;
+        }
+        case "response.mcp_call.completed":
+        case "response.mcp_call.failed":
+          this.session.span.addEvent(event.type, { [`${prefix}item.id`]: event.item_id });
+          break;
+        case "session.subagent.started":
+        case "session.subagent.completed":
+        case "session.subagent.aborted": {
+          const attributes = {
+            [`${prefix}subagent.consultation.id`]: event.consultation_id
+          };
+          if (event.type === "session.subagent.aborted" && [
+            "unknown_target",
+            "timeout",
+            "cancelled",
+            "stopped_by_user",
+            "superseded",
+            "failed"
+          ].includes(event.reason)) {
+            attributes[`${prefix}subagent.abort_reason`] = event.reason;
+          }
+          this.session.span.addEvent(event.type, attributes);
+          break;
+        }
+        case "error":
+          this.session.span.addEvent(
+            "voice_agents.server_error",
+            serverErrorAttributes(event.error.type, event.error.code)
+          );
+          break;
+        case "warning":
+          this.session.span.addEvent("voice_agents.warning");
+          break;
+        case "rtc.call.error":
+          this.session.span.addEvent(
+            "rtc.call.error",
+            serverErrorAttributes(event.error.type, event.error.code)
+          );
+          break;
+        case "conversation.item.input_audio_transcription.completed": {
+          const input = this.inputAudioItems.get(event.item_id);
+          if (input?.pendingSend) {
+            input.pendingTranscript = event.transcript;
+          } else if (input?.sequence === this.inputSequence) {
+            this.setInputAudioSummary(event.transcript);
+          }
+          this.session.span.addEvent("voice_agents.transcription.completed");
+          break;
+        }
+        case "conversation.item.input_audio_transcription.failed": {
+          const input = this.inputAudioItems.get(event.item_id);
+          if (input?.sequence === this.inputSequence) {
+            this.setInputAudioSummary();
+          }
+          this.session.span.addEvent("voice_agents.transcription.failed");
+          break;
+        }
+      }
+    });
+  }
+  startInputAudio() {
+    const input = { sequence: ++this.nextInputSequence };
+    this.inputSequence = input.sequence;
+    this.setInputAudioSummary();
+    return input;
+  }
+  enqueueInputAudio(queue, input) {
+    input.pendingQueue = queue;
+    if (queue.items.length >= maxInputItems || queue.skipped > 0) {
+      input.pendingSkipped = true;
+      queue.skipped++;
+      this.untrackedInputItems++;
+    } else {
+      queue.items.push(input);
+    }
+  }
+  rollbackPendingAudioMessage(input) {
+    if (input.pendingQueue) {
+      const index = input.pendingQueue.items.indexOf(input);
+      if (index !== -1) {
+        input.pendingQueue.items.splice(index, 1);
+      } else if (input.pendingSkipped && input.pendingQueue.skipped > 0) {
+        input.pendingQueue.skipped--;
+        this.untrackedInputItems--;
+      }
+      input.pendingQueue = void 0;
+      input.pendingSkipped = void 0;
+    }
+    if (input.itemId && this.inputAudioItems.get(input.itemId) === input) {
+      this.inputAudioItems.delete(input.itemId);
+    }
+    input.pendingSend = void 0;
+    input.pendingTranscript = void 0;
+  }
+  matchInputAudio(queue, itemId) {
+    const known = this.inputAudioItems.get(itemId);
+    if (known) {
+      if (known.pendingQueue === queue) {
+        const index = queue.items.indexOf(known);
+        if (index !== -1) queue.items.splice(index, 1);
+        else if (known.pendingSkipped && queue.skipped > 0) queue.skipped--;
+        known.pendingQueue = void 0;
+        known.pendingSkipped = void 0;
+      }
+      return known;
+    }
+    const input = queue.items.shift();
+    if (input) {
+      input.pendingQueue = void 0;
+      this.rememberInputAudio(itemId, input);
+      return input;
+    }
+    if (queue.skipped > 0) queue.skipped--;
+    return void 0;
+  }
+  rememberInputAudio(itemId, input) {
+    input.itemId = itemId;
+    this.inputAudioItems.set(itemId, input);
+    if (this.inputAudioItems.size > maxInputItems) {
+      for (const [id, tracked] of this.inputAudioItems) {
+        if (tracked.sequence !== this.inputSequence || id !== tracked.itemId) {
+          this.inputAudioItems.delete(id);
+          break;
+        }
+      }
+    }
+  }
+  setInputAudioSummary(transcript) {
+    const parts = [{ type: "audio" }];
+    if (this.config.contentRecording && transcript !== void 0) {
+      parts[0].content = limitedContent(transcript);
+    }
+    this.session?.span.setAttribute(
+      import_constants.GEN_AI_INPUT_MESSAGES,
+      JSON.stringify([{ role: "user", parts }])
+    );
+  }
+  recordOutputPart(tracked, itemId, contentIndex, part) {
+    const key = `${itemId}:${contentIndex}:${part.type}`;
+    const existing = tracked.outputParts.get(key);
+    if (existing) {
+      if (part.content !== void 0) existing.part.content = part.content;
+    } else if (tracked.outputParts.size < maxParts) {
+      tracked.outputParts.set(key, { itemId, contentIndex, part });
+    }
+  }
+  beginResponse(response) {
+    const id = response.id;
+    if (!id || !this.session || this.responses.has(id)) return;
+    if (this.responses.size >= maxResponses) {
+      this.untrackedResponses++;
+      return;
+    }
+    const { span } = (0, import_tracingClient.startSpan)("invoke_agent", this.session.ctx);
+    commonAttributes(span, this.endpoint);
+    span.setAttribute(import_constants.GEN_AI_OPERATION_NAME, "invoke_agent");
+    span.setAttribute(import_constants.GEN_AI_RESPONSE_ID, id);
+    if (this.model) span.setAttribute(import_constants.GEN_AI_REQUEST_MODEL, this.model);
+    if (response.conversation_id) {
+      span.setAttribute(import_constants.GEN_AI_CONVERSATION_ID, response.conversation_id);
+    }
+    this.responses.set(id, {
+      span,
+      started: performance.now(),
+      audioBytes: 0,
+      model: this.model,
+      outputMessages: /* @__PURE__ */ new Map(),
+      outputParts: /* @__PURE__ */ new Map()
+    });
+  }
+  endResponse(response) {
+    const id = response.id;
+    const tracked = id ? this.responses.get(id) : void 0;
+    if (!tracked || !id) return;
+    this.responses.delete(id);
+    const durationInSeconds = (performance.now() - tracked.started) / 1e3;
+    const { span } = tracked;
+    if (response.status) span.setAttribute(`${prefix}response.status`, response.status);
+    if (response.output_modalities) {
+      span.setAttribute(`${prefix}response.output_modalities`, response.output_modalities);
+    }
+    if (response.usage?.input_tokens !== void 0) {
+      span.setAttribute(import_constants.GEN_AI_USAGE_INPUT_TOKENS, response.usage.input_tokens);
+    }
+    if (response.usage?.output_tokens !== void 0) {
+      span.setAttribute(import_constants.GEN_AI_USAGE_OUTPUT_TOKENS, response.usage.output_tokens);
+    }
+    this.flushObservedResponse(tracked, response);
+    if (response.status === "failed") {
+      span.setAttribute(import_constants.ERROR_TYPE, "response_failed");
+      span.setStatus({ code: import_api.SpanStatusCode.ERROR });
+    } else if (response.status === "completed") {
+      span.setStatus({ code: import_api.SpanStatusCode.OK });
+    }
+    const dimensions = {
+      operationName: "invoke_agent",
+      ...(0, import_attributes.parseEndpoint)(this.endpoint),
+      responseModel: tracked.model,
+      ...response.status === "failed" ? { errorType: "response_failed" } : {}
+    };
+    span.end();
+    this.finishedResponses++;
+    (0, import_metrics.recordOperationDuration)(durationInSeconds, dimensions);
+    (0, import_metrics.recordTokenUsage)(response.usage?.input_tokens, response.usage?.output_tokens, dimensions);
+  }
+  flushObservedResponse(tracked, response) {
+    const { span } = tracked;
+    span.setAttribute(`${prefix}output.audio.bytes`, tracked.audioBytes);
+    if (tracked.firstAudioInSeconds !== void 0) {
+      span.setAttribute(
+        `${prefix}response.time_to_first_audio_seconds`,
+        tracked.firstAudioInSeconds
+      );
+    }
+    const fallback = new Map(tracked.outputMessages);
+    for (const observed of [...tracked.outputParts.values()].sort(
+      (a, b) => a.contentIndex - b.contentIndex
+    )) {
+      const message = fallback.get(observed.itemId) ?? {
+        role: "assistant",
+        parts: []
+      };
+      message.parts.push(observed.part);
+      fallback.set(observed.itemId, message);
+    }
+    const output = [];
+    let unkeyedFinalItem = false;
+    for (const item of response?.output?.slice(0, maxParts) ?? []) {
+      const summary = messages(item, this.config.contentRecording);
+      if (!summary) continue;
+      const record = asRecord(item);
+      const itemId = record?.type === "function_call" && typeof record.call_id === "string" ? `tool:${record.call_id}` : typeof record?.id === "string" ? record.id : typeof record?.call_id === "string" ? record.call_id : void 0;
+      if (itemId) {
+        fallback.delete(itemId);
+        if (record?.type === "message" && Array.isArray(record.content)) {
+          summary.parts = record.content.slice(0, maxParts).flatMap((value, index) => {
+            const part = messagePart(value, this.config.contentRecording);
+            if (!part) return [];
+            const observed = tracked.outputParts.get(`${itemId}:${index}:${part.type}`);
+            if (part.content === void 0 && observed?.part.content !== void 0) {
+              part.content = observed.part.content;
+            }
+            return [part];
+          });
+        }
+      } else {
+        unkeyedFinalItem = true;
+      }
+      output.push(summary);
+    }
+    if (!unkeyedFinalItem) output.push(...fallback.values());
+    if (output.length) {
+      span.setAttribute(import_constants.GEN_AI_OUTPUT_MESSAGES, JSON.stringify(output.slice(0, maxParts)));
+    }
+  }
+  close(code, wasClean, error) {
+    if (this.ended) return;
+    this.ended = true;
+    recordTelemetry(() => {
+      const cancelled = asRecord(error)?.code === "operationCancelled";
+      if (this.connectSpan) {
+        if (error && !cancelled) fail(this.connectSpan, error);
+        this.connectSpan.end();
+        this.connectSpan = void 0;
+      }
+      for (const tracked of this.responses.values()) {
+        this.flushObservedResponse(tracked);
+        tracked.span.setAttribute(`${prefix}response.status`, "interrupted");
+        if (error && !cancelled) fail(tracked.span, error);
+        tracked.span.end();
+        (0, import_metrics.recordOperationDuration)((performance.now() - tracked.started) / 1e3, {
+          operationName: "invoke_agent",
+          ...(0, import_attributes.parseEndpoint)(this.endpoint),
+          responseModel: tracked.model,
+          ...error && !cancelled ? { errorType: "response_interrupted" } : {}
+        });
+      }
+      this.responses.clear();
+      this.inputAudioItems.clear();
+      this.pendingAudioCommits.items.length = 0;
+      this.pendingAudioMessages.items.length = 0;
+      this.inputAudioBuffer = void 0;
+      if (!this.session) return;
+      if (error && !cancelled) fail(this.session.span, error);
+      if (cancelled) this.session.span.setAttribute(`${prefix}cancelled`, true);
+      if (code !== void 0) this.session.span.setAttribute(`${prefix}close.code`, code);
+      this.session.span.setAttribute(`${prefix}close.was_clean`, wasClean);
+      this.session.span.setAttribute(`${prefix}input.audio.bytes`, this.inputAudioBytes);
+      if (this.untrackedInputItems) {
+        this.session.span.setAttribute(`${prefix}input.items.untracked`, this.untrackedInputItems);
+      }
+      this.session.span.setAttribute(`${prefix}responses.finished`, this.finishedResponses);
+      if (this.untrackedResponses) {
+        this.session.span.setAttribute(`${prefix}responses.untracked`, this.untrackedResponses);
+      }
+      this.session.span.setAttribute(`${prefix}connected`, this.connected);
+      this.session.span.end();
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VoiceAgentRealtimeTracing,
+  traceVoiceAgentOperation
+});
+//# sourceMappingURL=voiceAgentTracing.js.map