@depup/sentry__server-utils 10.67.0-depup.0

package/build/esm/tracing-channel.js

@@ -0,0 +1,132 @@
+import { getAsyncContextStrategy, getMainCarrier, debug, getActiveSpan, captureException, SPAN_STATUS_ERROR, isObjectLike } from '@sentry/core';
+import { DEBUG_BUILD } from './debug-build.js';
+import { ERROR_TYPE } from '@sentry/conventions/attributes';
+
+const NOOP = () => {
+};
+function bindTracingChannelToSpan(channel, getSpan, opts) {
+  const handle = bindSpanToChannelStore(channel, getSpan, opts);
+  const beforeSpanEnd = opts?.beforeSpanEnd;
+  const deferSpanEnd = opts?.deferSpanEnd;
+  const getErrorHint = (e) => {
+    if (typeof opts?.captureError === "function") {
+      return opts.captureError(e);
+    }
+    return {
+      mechanism: {
+        type: "auto.diagnostic_channels.bind_span",
+        handled: false
+      }
+    };
+  };
+  const annotateSpanError = (span, error) => {
+    if (opts?.captureError) {
+      captureException(error, getErrorHint(error));
+    }
+    const { message, attributes } = getErrorInfo(error);
+    span.setStatus({ code: SPAN_STATUS_ERROR, message });
+    span.setAttributes(attributes);
+  };
+  const makeDeferredEnd = (span, data) => {
+    let ended = false;
+    return (error) => {
+      if (ended) {
+        return;
+      }
+      ended = true;
+      if (error !== void 0) {
+        annotateSpanError(span, error);
+      }
+      endBoundSpan(data, beforeSpanEnd);
+    };
+  };
+  const subscribers = {
+    start: NOOP,
+    asyncStart: NOOP,
+    end(data) {
+      if ("error" in data || "result" in data) {
+        const span = data._sentrySpan;
+        if (span && deferSpanEnd?.({ span, data, end: makeDeferredEnd(span, data) })) {
+          return;
+        }
+        endBoundSpan(data, beforeSpanEnd);
+      }
+    },
+    error(data) {
+      const span = data._sentrySpan;
+      if (!span) {
+        return;
+      }
+      annotateSpanError(span, data.error);
+    },
+    asyncEnd(data) {
+      const span = data._sentrySpan;
+      if (span && deferSpanEnd?.({ span, data, end: makeDeferredEnd(span, data) })) {
+        return;
+      }
+      endBoundSpan(data, beforeSpanEnd);
+    }
+  };
+  handle.channel.subscribe(subscribers);
+  return {
+    channel: handle.channel,
+    unbind: () => {
+      handle.channel.unsubscribe(subscribers);
+      handle.unbind();
+    }
+  };
+}
+function bindSpanToChannelStore(channel, getSpan, opts) {
+  const binding = getAsyncContextStrategy(getMainCarrier()).getTracingChannelBinding?.();
+  if (!binding) {
+    DEBUG_BUILD && debug.log("[TracingChannel] Could not access async context binding.");
+    return {
+      channel,
+      unbind: NOOP
+    };
+  }
+  const asyncLocalStorage = binding.asyncLocalStorage;
+  channel.start.bindStore(asyncLocalStorage, (data) => {
+    data._sentryCallerStore = asyncLocalStorage.getStore();
+    const shouldGetSpan = !opts?.requiresParentSpan || getActiveSpan();
+    const span = shouldGetSpan ? getSpan(data) : void 0;
+    if (!span) {
+      return data._sentryCallerStore;
+    }
+    data._sentrySpan = span;
+    return binding.getStoreWithActiveSpan(span);
+  });
+  channel.asyncStart.bindStore(asyncLocalStorage, (data) => {
+    return data._sentryCallerStore;
+  });
+  return {
+    channel,
+    unbind: () => {
+      channel.start.unbindStore(asyncLocalStorage);
+      channel.asyncStart.unbindStore(asyncLocalStorage);
+    }
+  };
+}
+function endBoundSpan(data, beforeSpanEnd) {
+  const span = data._sentrySpan;
+  if (!span) {
+    return;
+  }
+  beforeSpanEnd?.(span, data);
+  span.end();
+}
+function getErrorInfo(error) {
+  const errorIsObject = isObjectLike(error);
+  const raw = errorIsObject ? "message" in error ? error.message : void 0 : error;
+  const message = raw ? String(raw) : void 0;
+  const type = errorIsObject && "name" in error ? String(error.name) : "unknown";
+  return {
+    message,
+    attributes: {
+      [ERROR_TYPE]: type
+    }
+  };
+}
+
+export { bindTracingChannelToSpan };
+//# sourceMappingURL=tracing-channel.js.map

package/build/esm/tracing-channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracing-channel.js","sources":["../../src/tracing-channel.ts"],"sourcesContent":["import type { TracingChannel, TracingChannelSubscribers } from 'node:diagnostics_channel';\nimport type { AsyncLocalStorage } from 'node:async_hooks';\nimport type { ExclusiveEventHintOrCaptureContext, Span } from '@sentry/core';\nimport {\n  debug,\n  captureException,\n  isObjectLike,\n  SPAN_STATUS_ERROR,\n  getAsyncContextStrategy,\n  getMainCarrier,\n  getActiveSpan,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build';\nimport { ERROR_TYPE } from '@sentry/conventions/attributes';\n\nexport type TracingChannelPayloadWithSpan<TData extends object> = TData & {\n  /**\n   * The current active span for the traced call.\n   */\n  _sentrySpan?: Span;\n\n  /**\n   * The context's active store value, used to restore the context for asyncStart continuations for callback-based tracing.\n   */\n  _sentryCallerStore?: unknown;\n};\n\n/*\n * A type patch so that we don't have to handle all subscription types.\n */\nexport interface SentryTracingChannel<TData extends object = object> extends Omit<\n  TracingChannel<TData, TracingChannelPayloadWithSpan<TData>>,\n  'subscribe' | 'unsubscribe'\n> {\n  subscribe(subscribers: Partial<TracingChannelSubscribers<TracingChannelPayloadWithSpan<TData>>>): void;\n  unsubscribe(subscribers: Partial<TracingChannelSubscribers<TracingChannelPayloadWithSpan<TData>>>): void;\n}\n\nexport interface TracingChannelLifeCycleOptions<TData extends object = object> {\n  /**\n   * Invoked with the span and the channel context object once the traced operation completes\n   * Use it to enrich the span from the result/error (branch on `'error' in data` / `'result' in data`) or to run cleanup.\n   */\n  beforeSpanEnd?: (span: Span, data: TracingChannelPayloadWithSpan<TData>) => void;\n\n  /**\n   * Whether a thrown error is captured as a Sentry event. The span is always marked with error status regardless. Defaults to `false`.\n   * You can alternatively pass a function that sets the ExclusiveEventHintOrCaptureContext on the captured error.\n   * Set `true` for instrumentations that own the error boundary, (e.g: route handlers)\n   * For database drivers, it is not recommended to set this at all.\n   */\n  captureError?: boolean | ((e: unknown) => ExclusiveEventHintOrCaptureContext);\n\n  /**\n   * Take ownership of *when* the span ends: return `true` and the helper won't end it on\n   * `end`/`asyncEnd`. For results that settle out-of-band — e.g. a streamed `EventEmitter` that\n   * completes via its own `'end'`/`'error'` events.\n   *\n   * Call `end` when it settles — `end()` on success, `end(error)` on failure. `end` owns *how* the span\n   * ends (error status/attributes, `captureError`, `beforeSpanEnd`) and is idempotent. Default `false`\n   * lets the helper end the span as usual.\n   */\n  deferSpanEnd?: (args: {\n    span: Span;\n    data: TracingChannelPayloadWithSpan<TData>;\n    /** Ends the span: `end()` on success, `end(error)` on failure. Idempotent. */\n    end: (error?: unknown) => void;\n  }) => boolean;\n\n  /**\n   * Apply span/scope binding only if there is a parent span, similar to returning `undefined` in the `getSpan` callback.\n   * If you need to perform some conditional checking on the parent span before deciding, do it in the `getSpan` callback.\n   */\n  requiresParentSpan?: boolean;\n}\n\n/** Returned by {@link bindTracingChannelToSpan}: the bound channel plus a teardown handle. */\nexport interface TracingChannelBindingHandle<TData extends object = object> {\n  /**\n   * The tracing channel with the span bound into async context.\n   */\n  channel: SentryTracingChannel<TData>;\n\n  /**\n   * Tears down the binding: unsubscribes lifecycle handlers, when present, and unbinds the start store.\n   * Idempotent, and a no-op when no async context binding was available.\n   */\n  unbind: () => void;\n}\n\nconst NOOP = (): void => {};\n\n/**\n * Bind a span and its lifecycle to a tracing channel so the span becomes the active async context\n * for the traced operation and is ended when the operation completes.\n *\n * `getSpan` may return `undefined` to opt a payload out entirely: nothing is bound, no span is\n * tracked, and the active context is left untouched. Use it for events that ride the same channel\n * but should reuse the enclosing span instead of opening (and ending) their own — e.g. an agent\n * loop's per-step events, where ending a freshly opened span would close the parent prematurely.\n */\nexport function bindTracingChannelToSpan<TData extends object>(\n  channel: TracingChannel<TData, TData>,\n  getSpan: (data: TracingChannelPayloadWithSpan<TData>) => Span | undefined,\n  opts?: TracingChannelLifeCycleOptions<TData>,\n): TracingChannelBindingHandle<TData> {\n  const handle = bindSpanToChannelStore(channel, getSpan, opts);\n\n  const beforeSpanEnd = opts?.beforeSpanEnd;\n  const deferSpanEnd = opts?.deferSpanEnd;\n  const getErrorHint = (e: unknown): ExclusiveEventHintOrCaptureContext => {\n    if (typeof opts?.captureError === 'function') {\n      return opts.captureError(e);\n    }\n\n    return {\n      mechanism: {\n        type: 'auto.diagnostic_channels.bind_span',\n        handled: false,\n      },\n    };\n  };\n\n  // Apply Sentry error status + attributes (and capture, if configured) to a span. Shared by the\n  // channel `error` lifecycle and the deferred `end` util so the two can't drift.\n  const annotateSpanError = (span: Span, error: unknown): void => {\n    if (opts?.captureError) {\n      captureException(error, getErrorHint(error));\n    }\n\n    const { message, attributes } = getErrorInfo(error);\n    span.setStatus({ code: SPAN_STATUS_ERROR, message });\n    span.setAttributes(attributes);\n  };\n\n  // Creates an end fn for deferred handlers to use, ensures consistent span end behavior\n  const makeDeferredEnd = (span: Span, data: TracingChannelPayloadWithSpan<TData>) => {\n    let ended = false;\n\n    return (error?: unknown): void => {\n      if (ended) {\n        return;\n      }\n\n      ended = true;\n      if (error !== undefined) {\n        annotateSpanError(span, error);\n      }\n\n      endBoundSpan(data, beforeSpanEnd);\n    };\n  };\n\n  const subscribers: Partial<TracingChannelSubscribers<TracingChannelPayloadWithSpan<TData>>> = {\n    start: NOOP,\n    asyncStart: NOOP,\n    end(data) {\n      // The operation settled synchronously (returned or threw)\n      // Presence checks because caller can return `undefined` result or throw a falsy value.\n      if ('error' in data || 'result' in data) {\n        const span = data._sentrySpan;\n        if (span && deferSpanEnd?.({ span, data, end: makeDeferredEnd(span, data) })) {\n          return;\n        }\n        endBoundSpan(data, beforeSpanEnd);\n      }\n    },\n    error(data) {\n      // No span was bound for this payload (`getSpan` returned undefined), so there is nothing to\n      // annotate and no instrumentation that owns capturing this error.\n      const span = data._sentrySpan;\n      if (!span) {\n        return;\n      }\n\n      annotateSpanError(span, data.error);\n    },\n    asyncEnd(data) {\n      const span = data._sentrySpan;\n      if (span && deferSpanEnd?.({ span, data, end: makeDeferredEnd(span, data) })) {\n        return;\n      }\n      endBoundSpan(data, beforeSpanEnd);\n    },\n  };\n\n  handle.channel.subscribe(subscribers);\n\n  return {\n    channel: handle.channel,\n    unbind: () => {\n      handle.channel.unsubscribe(subscribers);\n      handle.unbind();\n    },\n  };\n}\n\n/**\n * Bind a span into the channel's async context so it becomes active for the traced operation,\n * without managing its lifecycle. The primitive behind {@link bindTracingChannelToSpan}, which\n * layers span-ending and error handling on top.\n *\n * `getSpan` may return `undefined` to leave the active context untouched for that payload.\n */\nfunction bindSpanToChannelStore<TData extends object>(\n  channel: TracingChannel<TData, TData>,\n  getSpan: (data: TracingChannelPayloadWithSpan<TData>) => Span | undefined,\n  opts?: Pick<TracingChannelLifeCycleOptions, 'requiresParentSpan'>,\n): TracingChannelBindingHandle<TData> {\n  // Grabs the tracing channel binding defined by the AsyncContext strategy implementation\n  const binding = getAsyncContextStrategy(getMainCarrier()).getTracingChannelBinding?.();\n\n  // If no binding, then either the implementer doesn't support tracing channels or there is no active strategy\n  // Failure mode here means we would still access the channel and potentially subscribe to it, but parenting will be off.\n  if (!binding) {\n    DEBUG_BUILD && debug.log('[TracingChannel] Could not access async context binding.');\n\n    return {\n      channel,\n      unbind: NOOP,\n    };\n  }\n\n  // Grab the ALS instance, we don't really care what is in it as long as the AsyncContext strategy can use its value to figure out parenting.\n  const asyncLocalStorage = binding.asyncLocalStorage as AsyncLocalStorage<TData>;\n\n  // bindStore activates the ALS for the traced call; any getStore() inside it returns the value bound for that context.\n  // 1. Produce: getStoreWithActiveSpan(span) clones the current scope, plants the span via _INTERNAL_setSpanForScope, and returns { scope, isolationScope }, the active context carrying our span.\n  // 2. Bind: the courier hands that opaque value to channel.start.bindStore(asyncLocalStorage, producer), which runs the traced op inside asyncLocalStorage.run(value, …); it never inspects the value.\n  // 3. Read: inside the op, Sentry's scope machinery calls getScopes() → asyncStorage.getStore() on that same ALS, so getCurrentScope/getIsolationScope/getActiveSpan resolve to the scope carrying our span.\n  // 4. Nest: any child span started in the traced op parents to that active span.\n  channel.start.bindStore(asyncLocalStorage, (data: TracingChannelPayloadWithSpan<TData>) => {\n    // Stash the caller's store before we swap in the span store, so `asyncStart` can restore it for\n    // callback-style channels (see `_sentryCallerStore`).\n    data._sentryCallerStore = asyncLocalStorage.getStore();\n\n    const shouldGetSpan = !opts?.requiresParentSpan || getActiveSpan();\n    const span = shouldGetSpan ? getSpan(data) : undefined;\n    if (!span) {\n      // Leave the active context untouched so nested operations keep parenting to the enclosing span.\n      return data._sentryCallerStore as TData;\n    }\n    data._sentrySpan = span;\n\n    return binding.getStoreWithActiveSpan(span) as TData;\n  });\n\n  // Restore the caller's context for the async continuation. Only callback-style channels `runStores`\n  // `asyncStart` (so the callback runs inside this store). promise channels `publish` it, leaving this\n  // inert, their continuation already inherits the caller's context natively.\n  channel.asyncStart.bindStore(asyncLocalStorage, (data: TracingChannelPayloadWithSpan<TData>) => {\n    return data._sentryCallerStore as TData;\n  });\n\n  return {\n    channel,\n    unbind: () => {\n      // Removes the stores\n      channel.start.unbindStore(asyncLocalStorage);\n      channel.asyncStart.unbindStore(asyncLocalStorage);\n    },\n  };\n}\n\nfunction endBoundSpan<TData extends object>(\n  data: TracingChannelPayloadWithSpan<TData>,\n  beforeSpanEnd: TracingChannelLifeCycleOptions<TData>['beforeSpanEnd'],\n): void {\n  const span = data._sentrySpan;\n  if (!span) {\n    return;\n  }\n  beforeSpanEnd?.(span, data);\n  span.end();\n}\n\ntype ErrorInfo = {\n  message: string | undefined;\n  attributes: Record<string, string>;\n};\n\n/**\n * Best-effort message and attribute extraction for thrown/rejected values.\n */\nfunction getErrorInfo(error: unknown): ErrorInfo {\n  const errorIsObject = isObjectLike(error);\n  const raw = errorIsObject ? ('message' in error ? error.message : undefined) : error;\n\n  // Leave the status message unset if not set (e.g. an `AggregateError` from\n  // ECONNREFUSED, whose `.message` is empty). Otherwise cast to string.\n  const message = raw ? String(raw) : undefined;\n  const type = errorIsObject && 'name' in error ? String(error.name) : 'unknown';\n\n  return {\n    message,\n    attributes: {\n      [ERROR_TYPE]: type,\n    },\n  };\n}\n"],"names":[],"mappings":"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"}

package/build/esm/vercel-ai/index.js

@@ -0,0 +1,21 @@
+import { defineIntegration, waitForTracingChannelBinding } from '@sentry/core';
+import { subscribeVercelAiTracingChannel } from './vercel-ai-dc-subscriber.js';
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+
+const _vercelAiIntegration = ((options = {}) => {
+  return {
+    name: "VercelAI",
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      waitForTracingChannelBinding(() => {
+        subscribeVercelAiTracingChannel(diagnosticsChannel.tracingChannel, options);
+      });
+    }
+  };
+});
+const vercelAiIntegration = defineIntegration(_vercelAiIntegration);
+
+export { vercelAiIntegration };
+//# sourceMappingURL=index.js.map

package/build/esm/vercel-ai/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/vercel-ai/index.ts"],"sourcesContent":["import { defineIntegration, waitForTracingChannelBinding, type IntegrationFn } from '@sentry/core';\nimport { subscribeVercelAiTracingChannel } from './vercel-ai-dc-subscriber';\nimport * as dc from 'node:diagnostics_channel';\n\ntype VercelAiOptions = {\n  /**\n   * Enable or disable input recording. Enabled if `dataCollection.genAI.inputs` (or the deprecated `sendDefaultPii` option) is `true`\n   * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.\n   * Integration-level options take precedence over global `dataCollection` config.\n   */\n  recordInputs?: boolean;\n\n  /**\n   * Enable or disable output recording. Enabled if `dataCollection.genAI.outputs` (or the deprecated `sendDefaultPii` option) is `true`\n   * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.\n   * Integration-level options take precedence over global `dataCollection` config.\n   */\n  recordOutputs?: boolean;\n\n  /**\n   * Enable or disable truncation of recorded input messages.\n   * Defaults to `true`.\n   */\n  enableTruncation?: boolean;\n};\n\nconst _vercelAiIntegration = ((options: VercelAiOptions = {}) => {\n  return {\n    name: 'VercelAI' as const,\n    setupOnce() {\n      // Bail if this is not available\n      if (!dc.tracingChannel) {\n        return;\n      }\n\n      // Subscribe to the `ai` SDK's native telemetry tracing channel (ai >= 7).\n      // This is a no-op on versions that don't publish to the channel, so it is always safe to call.\n      waitForTracingChannelBinding(() => {\n        subscribeVercelAiTracingChannel(dc.tracingChannel, options);\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Auto-instrument the `ai` SDK's native telemetry tracing channel (ai >= 7).\n */\nexport const vercelAiIntegration = defineIntegration(_vercelAiIntegration);\n"],"names":["dc"],"mappings":";;;;AA0BA,MAAM,oBAAA,IAAwB,CAAC,OAAA,GAA2B,EAAC,KAAM;AAC/D,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,UAAA;AAAA,IACN,SAAA,GAAY;AAEV,MAAA,IAAI,CAACA,mBAAG,cAAA,EAAgB;AACtB,QAAA;AAAA,MACF;AAIA,MAAA,4BAAA,CAA6B,MAAM;AACjC,QAAA,+BAAA,CAAgCA,kBAAA,CAAG,gBAAgB,OAAO,CAAA;AAAA,MAC5D,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAA,CAAA;AAKO,MAAM,mBAAA,GAAsB,kBAAkB,oBAAoB;;;;"}

package/build/esm/vercel-ai/util.js

@@ -0,0 +1,106 @@
+import { isObjectLike } from '@sentry/core';
+
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && !isNaN(value) ? value : void 0;
+}
+function sum(a, b) {
+  return a === void 0 && b === void 0 ? void 0 : (a ?? 0) + (b ?? 0);
+}
+function isReadableStream(value) {
+  return isObjectLike(value) && typeof value.pipeThrough === "function" && typeof value.getReader === "function";
+}
+function tapModelCallStream(stream, onFinal, onError) {
+  const reader = stream.getReader();
+  const state = { toolCalls: [] };
+  let text = "";
+  let settled = false;
+  const finalize = () => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    if (text) {
+      state.text = text;
+    }
+    onFinal(state);
+  };
+  const fail = (error) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    onError(error);
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          finalize();
+          controller.close();
+          return;
+        }
+        text += accumulateChunk(state, value) ?? "";
+        controller.enqueue(value);
+      } catch (error) {
+        fail(error);
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      finalize();
+      return reader.cancel(reason);
+    }
+  });
+}
+function accumulateChunk(state, chunk) {
+  if (!isObjectLike(chunk)) {
+    return void 0;
+  }
+  const {
+    type,
+    delta,
+    textDelta,
+    id,
+    modelId,
+    toolCallId,
+    toolName,
+    input,
+    args,
+    finishReason,
+    usage,
+    providerMetadata
+  } = chunk;
+  switch (type) {
+    case "text-delta": {
+      const textChunk = delta ?? textDelta;
+      return typeof textChunk === "string" ? textChunk : void 0;
+    }
+    case "tool-call":
+      state.toolCalls.push({ toolCallId, toolName, input: input ?? args });
+      return void 0;
+    case "response-metadata":
+      if (typeof id === "string") {
+        state.responseId = id;
+      }
+      if (typeof modelId === "string") {
+        state.responseModel = modelId;
+      }
+      return void 0;
+    case "finish":
+      state.finishReason = finishReason;
+      state.usage = usage;
+      if (providerMetadata !== void 0) {
+        state.providerMetadata = providerMetadata;
+      }
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+
+export { asNumber, asString, isReadableStream, sum, tapModelCallStream };
+//# sourceMappingURL=util.js.map

package/build/esm/vercel-ai/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sources":["../../../src/vercel-ai/util.ts"],"sourcesContent":["/** Shared, state-free helpers for the Vercel AI (`ai`) channel subscribers, plus the streamed model-call tap. */\n\nimport { isObjectLike } from '@sentry/core';\n\n/** Narrow to a string, or `undefined` for anything else. */\nexport function asString(value: unknown): string | undefined {\n  return typeof value === 'string' ? value : undefined;\n}\n\n/** Narrow to a finite number, or `undefined` for anything else (including `NaN`). */\nexport function asNumber(value: unknown): number | undefined {\n  return typeof value === 'number' && !isNaN(value) ? value : undefined;\n}\n\n/** Add two optional numbers, treating a missing operand as `0` but returning `undefined` when both are absent. */\nexport function sum(a: number | undefined, b: number | undefined): number | undefined {\n  return a === undefined && b === undefined ? undefined : (a ?? 0) + (b ?? 0);\n}\n\n/*\n * Streaming support for the `ai:telemetry` tracing channel.\n *\n * For a streamed model call (`doStream`) the SDK resolves the `languageModelCall` channel promise as\n * soon as it hands back the *unconsumed* stream — so `result.stream` is a `ReadableStream` and the\n * final usage / finish reason / output only arrive later, as the stream is drained (they ride the\n * stream's own `finish`/`text-delta`/`tool-call` chunks, never the channel context). The SDK\n * deliberately leaves `result` undefined on the `streamText`/`step` contexts and exposes the stream\n * only on the model call, expecting consumers to tap it themselves.\n * @see https://github.com/vercel/ai/pull/15660 (discussion: \"tee off and aggregate ourselves\")\n *\n * We replace `result.stream` with a passthrough that forwards every chunk untouched (so the SDK's own\n * consumption is unaffected) while accumulating the data we need, then hand the aggregate back once the\n * stream settles so the model-call span can be enriched and ended out-of-band.\n */\n\n/** The subset of a streamed provider chunk we read. Unknown chunk types are forwarded and ignored. */\ninterface StreamChunk {\n  type?: unknown;\n  delta?: unknown;\n  // v4 text-delta chunks carry the text on `textDelta`; v5+ uses `delta`.\n  textDelta?: unknown;\n  id?: unknown;\n  modelId?: unknown;\n  toolCallId?: unknown;\n  toolName?: unknown;\n  input?: unknown;\n  args?: unknown;\n  finishReason?: unknown;\n  usage?: unknown;\n  providerMetadata?: unknown;\n  error?: unknown;\n}\n\n/** The aggregate handed back once a streamed model call finishes, in the shape `enrichSpanOnEnd` expects. */\nexport interface StreamedModelCallResult {\n  text?: string;\n  toolCalls: Array<Record<string, unknown>>;\n  usage?: unknown;\n  finishReason?: unknown;\n  responseId?: string;\n  responseModel?: string;\n  providerMetadata?: unknown;\n}\n\n/** A minimal structural check — the streamed model call exposes a web `ReadableStream` on `result.stream`. */\nexport function isReadableStream(value: unknown): value is ReadableStream<unknown> {\n  return (\n    isObjectLike(value) &&\n    typeof (value as { pipeThrough?: unknown }).pipeThrough === 'function' &&\n    typeof (value as { getReader?: unknown }).getReader === 'function'\n  );\n}\n\n/**\n * Wrap a streamed model call's `ReadableStream` so its chunks are observed as the SDK consumes them,\n * without altering what the SDK sees. Returns a replacement stream to swap onto `result.stream`.\n *\n * `onFinal` runs exactly once when the stream drains cleanly; `onError` runs exactly once if it errors\n * or is cancelled. Reading one source chunk per `pull` preserves the SDK's backpressure. The\n * `try/catch` around every read guarantees the owning span is always ended — a leaked open span on a\n * mid-stream failure would be worse than a slightly-less-enriched one.\n */\nexport function tapModelCallStream(\n  stream: ReadableStream<unknown>,\n  onFinal: (result: StreamedModelCallResult) => void,\n  onError: (error: unknown) => void,\n): ReadableStream<unknown> {\n  const reader = stream.getReader();\n  const state: StreamedModelCallResult = { toolCalls: [] };\n  let text = '';\n  let settled = false;\n\n  const finalize = (): void => {\n    if (settled) {\n      return;\n    }\n    settled = true;\n    if (text) {\n      state.text = text;\n    }\n    onFinal(state);\n  };\n\n  const fail = (error: unknown): void => {\n    if (settled) {\n      return;\n    }\n    settled = true;\n    onError(error);\n  };\n\n  return new ReadableStream<unknown>({\n    async pull(controller) {\n      try {\n        const { done, value } = await reader.read();\n        if (done) {\n          finalize();\n          controller.close();\n\n          return;\n        }\n        text += accumulateChunk(state, value) ?? '';\n        controller.enqueue(value);\n      } catch (error) {\n        fail(error);\n        controller.error(error);\n      }\n    },\n    cancel(reason) {\n      // Consumer stopped reading early (e.g. a `break` out of `for await`); close out the span with\n      // whatever we have rather than leave it open. A non-error reason is a deliberate stop, not a failure.\n      finalize();\n\n      return reader.cancel(reason);\n    },\n  });\n}\n\n/**\n * Fold a single streamed chunk into the running aggregate. Returns any text delta so the caller can\n * accumulate it (kept out of `state` until the end to avoid re-joining on every chunk).\n */\nfunction accumulateChunk(state: StreamedModelCallResult, chunk: unknown): string | undefined {\n  if (!isObjectLike(chunk)) {\n    return undefined;\n  }\n  const {\n    type,\n    delta,\n    textDelta,\n    id,\n    modelId,\n    toolCallId,\n    toolName,\n    input,\n    args,\n    finishReason,\n    usage,\n    providerMetadata,\n  } = chunk as StreamChunk;\n\n  switch (type) {\n    case 'text-delta': {\n      const textChunk = delta ?? textDelta;\n      return typeof textChunk === 'string' ? textChunk : undefined;\n    }\n    case 'tool-call':\n      state.toolCalls.push({ toolCallId, toolName, input: input ?? args });\n\n      return undefined;\n    case 'response-metadata':\n      if (typeof id === 'string') {\n        state.responseId = id;\n      }\n      if (typeof modelId === 'string') {\n        state.responseModel = modelId;\n      }\n\n      return undefined;\n    case 'finish':\n      state.finishReason = finishReason;\n      state.usage = usage;\n      if (providerMetadata !== undefined) {\n        state.providerMetadata = providerMetadata;\n      }\n\n      return undefined;\n    default:\n      return undefined;\n  }\n}\n"],"names":[],"mappings":";;AAKO,SAAS,SAAS,KAAA,EAAoC;AAC3D,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,GAAW,KAAA,GAAQ,MAAA;AAC7C;AAGO,SAAS,SAAS,KAAA,EAAoC;AAC3D,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,CAAC,KAAA,CAAM,KAAK,IAAI,KAAA,GAAQ,MAAA;AAC9D;AAGO,SAAS,GAAA,CAAI,GAAuB,CAAA,EAA2C;AACpF,EAAA,OAAO,MAAM,MAAA,IAAa,CAAA,KAAM,SAAY,MAAA,GAAA,CAAa,CAAA,IAAK,MAAM,CAAA,IAAK,CAAA,CAAA;AAC3E;AAgDO,SAAS,iBAAiB,KAAA,EAAkD;AACjF,EAAA,OACE,YAAA,CAAa,KAAK,CAAA,IAClB,OAAQ,MAAoC,WAAA,KAAgB,UAAA,IAC5D,OAAQ,KAAA,CAAkC,SAAA,KAAc,UAAA;AAE5D;AAWO,SAAS,kBAAA,CACd,MAAA,EACA,OAAA,EACA,OAAA,EACyB;AACzB,EAAA,MAAM,MAAA,GAAS,OAAO,SAAA,EAAU;AAChC,EAAA,MAAM,KAAA,GAAiC,EAAE,SAAA,EAAW,EAAC,EAAE;AACvD,EAAA,IAAI,IAAA,GAAO,EAAA;AACX,EAAA,IAAI,OAAA,GAAU,KAAA;AAEd,EAAA,MAAM,WAAW,MAAY;AAC3B,IAAA,IAAI,OAAA,EAAS;AACX,MAAA;AAAA,IACF;AACA,IAAA,OAAA,GAAU,IAAA;AACV,IAAA,IAAI,IAAA,EAAM;AACR,MAAA,KAAA,CAAM,IAAA,GAAO,IAAA;AAAA,IACf;AACA,IAAA,OAAA,CAAQ,KAAK,CAAA;AAAA,EACf,CAAA;AAEA,EAAA,MAAM,IAAA,GAAO,CAAC,KAAA,KAAyB;AACrC,IAAA,IAAI,OAAA,EAAS;AACX,MAAA;AAAA,IACF;AACA,IAAA,OAAA,GAAU,IAAA;AACV,IAAA,OAAA,CAAQ,KAAK,CAAA;AAAA,EACf,CAAA;AAEA,EAAA,OAAO,IAAI,cAAA,CAAwB;AAAA,IACjC,MAAM,KAAK,UAAA,EAAY;AACrB,MAAA,IAAI;AACF,QAAA,MAAM,EAAE,IAAA,EAAM,KAAA,EAAM,GAAI,MAAM,OAAO,IAAA,EAAK;AAC1C,QAAA,IAAI,IAAA,EAAM;AACR,UAAA,QAAA,EAAS;AACT,UAAA,UAAA,CAAW,KAAA,EAAM;AAEjB,UAAA;AAAA,QACF;AACA,QAAA,IAAA,IAAQ,eAAA,CAAgB,KAAA,EAAO,KAAK,CAAA,IAAK,EAAA;AACzC,QAAA,UAAA,CAAW,QAAQ,KAAK,CAAA;AAAA,MAC1B,SAAS,KAAA,EAAO;AACd,QAAA,IAAA,CAAK,KAAK,CAAA;AACV,QAAA,UAAA,CAAW,MAAM,KAAK,CAAA;AAAA,MACxB;AAAA,IACF,CAAA;AAAA,IACA,OAAO,MAAA,EAAQ;AAGb,MAAA,QAAA,EAAS;AAET,MAAA,OAAO,MAAA,CAAO,OAAO,MAAM,CAAA;AAAA,IAC7B;AAAA,GACD,CAAA;AACH;AAMA,SAAS,eAAA,CAAgB,OAAgC,KAAA,EAAoC;AAC3F,EAAA,IAAI,CAAC,YAAA,CAAa,KAAK,CAAA,EAAG;AACxB,IAAA,OAAO,MAAA;AAAA,EACT;AACA,EAAA,MAAM;AAAA,IACJ,IAAA;AAAA,IACA,KAAA;AAAA,IACA,SAAA;AAAA,IACA,EAAA;AAAA,IACA,OAAA;AAAA,IACA,UAAA;AAAA,IACA,QAAA;AAAA,IACA,KAAA;AAAA,IACA,IAAA;AAAA,IACA,YAAA;AAAA,IACA,KAAA;AAAA,IACA;AAAA,GACF,GAAI,KAAA;AAEJ,EAAA,QAAQ,IAAA;AAAM,IACZ,KAAK,YAAA,EAAc;AACjB,MAAA,MAAM,YAAY,KAAA,IAAS,SAAA;AAC3B,MAAA,OAAO,OAAO,SAAA,KAAc,QAAA,GAAW,SAAA,GAAY,MAAA;AAAA,IACrD;AAAA,IACA,KAAK,WAAA;AACH,MAAA,KAAA,CAAM,SAAA,CAAU,KAAK,EAAE,UAAA,EAAY,UAAU,KAAA,EAAO,KAAA,IAAS,MAAM,CAAA;AAEnE,MAAA,OAAO,MAAA;AAAA,IACT,KAAK,mBAAA;AACH,MAAA,IAAI,OAAO,OAAO,QAAA,EAAU;AAC1B,QAAA,KAAA,CAAM,UAAA,GAAa,EAAA;AAAA,MACrB;AACA,MAAA,IAAI,OAAO,YAAY,QAAA,EAAU;AAC/B,QAAA,KAAA,CAAM,aAAA,GAAgB,OAAA;AAAA,MACxB;AAEA,MAAA,OAAO,MAAA;AAAA,IACT,KAAK,QAAA;AACH,MAAA,KAAA,CAAM,YAAA,GAAe,YAAA;AACrB,MAAA,KAAA,CAAM,KAAA,GAAQ,KAAA;AACd,MAAA,IAAI,qBAAqB,MAAA,EAAW;AAClC,QAAA,KAAA,CAAM,gBAAA,GAAmB,gBAAA;AAAA,MAC3B;AAEA,MAAA,OAAO,MAAA;AAAA,IACT;AACE,MAAA,OAAO,MAAA;AAAA;AAEb;;;;"}