@mastra/core/dist/chunk-D3BJ5NBH.cjs.map

Mastra is a framework for building AI-powered applications and agents with a modern TypeScript stack.

{"version":3,"sources":["../src/observability/utils.ts"],"names":["EntityType"],"mappings":"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","file":"chunk-D3BJ5NBH.cjs","sourcesContent":["/**\n * Browser-safe observability utilities.\n *\n * Functions that depend on AsyncLocalStorage (getCurrentSpan, executeWithContext,\n * executeWithContextSync) are in context-storage.ts and should only be imported\n * by server-side code.\n */\n\nimport { EntityType, SpanType } from './types';\nimport type { Span, GetOrCreateSpanOptions, AnySpan } from './types';\n\nconst entityTypeValues = new Set<EntityType>(Object.values(EntityType));\nlet currentSpanResolver: (() => AnySpan | undefined) | undefined;\n\nexport function setCurrentSpanResolver(resolver: (() => AnySpan | undefined) | undefined): void {\n  currentSpanResolver = resolver;\n}\n\nexport function resolveCurrentSpan(): AnySpan | undefined {\n  return currentSpanResolver?.();\n}\n\n/** Generate a unique id for an observability signal (log, metric, score, feedback). */\nexport function generateSignalId(): string {\n  return crypto.randomUUID();\n}\n\n/**\n * Compute the names of tools the model can call on a single inference step,\n * applying `activeTools` filtering when present. Used to populate the\n * `availableTools` attribute on MODEL_INFERENCE spans so observers see the\n * post-processor tool set, which can differ per-step from the AGENT_RUN view.\n *\n * `activeTools` is treated by presence, not truthiness: an explicit empty\n * array means \"no tools enabled for this step\" and is honored as such.\n * Returns `[]` (not `undefined`) when `tools` is provided but empty, so a\n * tool-less agent still reports a definitive empty list to observers.\n */\nexport function getStepAvailableToolNames(\n  tools?: Record<string, unknown> | undefined,\n  activeTools?: readonly string[] | undefined,\n): string[] | undefined {\n  if (activeTools !== undefined) {\n    return [...activeTools];\n  }\n  if (tools) {\n    return Object.keys(tools);\n  }\n  return undefined;\n}\n\n// --- Lazy resolvers for executeWithContext / executeWithContextSync ---\n// The real implementations live in context-storage.ts (which imports AsyncLocalStorage).\n// context-storage.ts registers them at import time so that consumer code can call these\n// browser-safe wrappers without pulling async_hooks into shared chunks.\n\ntype ExecuteWithContextFn = <T>(params: { span?: AnySpan; fn: () => Promise<T> }) => Promise<T>;\ntype ExecuteWithContextSyncFn = <T>(params: { span?: AnySpan; fn: () => T }) => T;\n\nlet executeWithContextImpl: ExecuteWithContextFn | undefined;\nlet executeWithContextSyncImpl: ExecuteWithContextSyncFn | undefined;\n\nexport function setExecuteWithContext(impl: ExecuteWithContextFn): void {\n  executeWithContextImpl = impl;\n}\n\nexport function setExecuteWithContextSync(impl: ExecuteWithContextSyncFn): void {\n  executeWithContextSyncImpl = impl;\n}\n\n/**\n * Execute an async function within a span's tracing context.\n * Falls back to direct execution if no context-storage implementation is registered or no span exists.\n */\nexport async function executeWithContext<T>(params: { span?: AnySpan; fn: () => Promise<T> }): Promise<T> {\n  if (executeWithContextImpl) {\n    return executeWithContextImpl(params);\n  }\n  const { span, fn } = params;\n  if (span?.executeInContext) {\n    return span.executeInContext(fn);\n  }\n  return fn();\n}\n\n/**\n * Execute a sync function within a span's tracing context.\n * Falls back to direct execution if no context-storage implementation is registered or no span exists.\n */\nexport function executeWithContextSync<T>(params: { span?: AnySpan; fn: () => T }): T {\n  if (executeWithContextSyncImpl) {\n    return executeWithContextSyncImpl(params);\n  }\n  const { span, fn } = params;\n  if (span?.executeInContextSync) {\n    return span.executeInContextSync(fn);\n  }\n  return fn();\n}\n\n/**\n * Creates or gets a child span from existing tracing context or starts a new trace.\n * This helper consolidates the common pattern of creating spans that can either be:\n * 1. Children of an existing span (when tracingContext.currentSpan exists)\n * 2. New root spans (when no current span exists)\n *\n * @param options - Configuration object for span creation\n * @returns The created Span or undefined if tracing is disabled\n */\nexport function getOrCreateSpan<T extends SpanType>(options: GetOrCreateSpanOptions<T>): Span<T> | undefined {\n  const { type, attributes, tracingContext, requestContext, tracingOptions, ...rest } = options;\n\n  const metadata = {\n    ...(rest.metadata ?? {}),\n    ...(tracingOptions?.metadata ?? {}),\n  };\n\n  // If we have a current span, create a child span\n  if (tracingContext?.currentSpan) {\n    return tracingContext.currentSpan.createChildSpan({\n      type,\n      attributes,\n      ...rest,\n      metadata,\n      requestContext,\n    });\n  }\n\n  // Otherwise, try to create a new root span\n  const instance = options.mastra?.observability?.getSelectedInstance({ requestContext });\n\n  return instance?.startSpan<T>({\n    type,\n    attributes,\n    ...rest,\n    metadata,\n    requestContext,\n    tracingOptions,\n    traceId: tracingOptions?.traceId,\n    parentSpanId: tracingOptions?.parentSpanId,\n    customSamplerOptions: {\n      requestContext,\n      metadata,\n    },\n  });\n}\n\n/**\n * Returns the top-most non-internal span that would appear in exported tracing output.\n *\n * Public API results should use this span for trace/span correlation because internal Mastra\n * workflow spans are omitted from external exporters.\n */\nexport function getRootExportSpan(span?: AnySpan): AnySpan | undefined {\n  if (!span?.isValid) {\n    return undefined;\n  }\n\n  let current: AnySpan | undefined = span;\n  let rootExportSpan: AnySpan | undefined = span.isInternal ? undefined : span;\n\n  while (current?.parent) {\n    current = current.parent;\n\n    if (!current.isInternal) {\n      rootExportSpan = current;\n    }\n  }\n\n  return rootExportSpan;\n}\n\n/**\n * Resolves the best available entity type for a span-like record.\n *\n * Prefers an explicit `entityType` when present and valid, then falls back to the\n * span type for common observability entities.\n */\nexport function getEntityTypeForSpan(span: {\n  entityType?: string | null;\n  spanType?: SpanType | string | null;\n}): EntityType | undefined {\n  if (span.entityType && entityTypeValues.has(span.entityType as EntityType)) {\n    return span.entityType as EntityType;\n  }\n\n  switch (span.spanType) {\n    case SpanType.AGENT_RUN:\n      return EntityType.AGENT;\n    case SpanType.RAG_INGESTION:\n      return EntityType.RAG_INGESTION;\n    case SpanType.SCORER_RUN:\n    case SpanType.SCORER_STEP:\n      return EntityType.SCORER;\n    case SpanType.WORKFLOW_RUN:\n      return EntityType.WORKFLOW_RUN;\n    case SpanType.WORKFLOW_STEP:\n      return EntityType.WORKFLOW_STEP;\n    case SpanType.TOOL_CALL:\n    case SpanType.MCP_TOOL_CALL:\n      return EntityType.TOOL;\n    case SpanType.PROCESSOR_RUN:\n      return EntityType.OUTPUT_PROCESSOR;\n    default:\n      return undefined;\n  }\n}\n"]}