dd-trace 6.20.1 → 6.22.0

package/packages/dd-trace/src/llmobs/plugins/anthropic/index.js

@@ -239,11 +239,19 @@ function mergeChunkUsage (usage, chunk) {
   const mergedUsage = usage ?? { input_tokens: 0, output_tokens: 0 }
   mergedUsage.output_tokens = chunk.usage.output_tokens
 
+  // `message_delta` counts are cumulative; input grows past the `message_start` count when server
+  // tools (e.g. web search) feed results back into the model
+  const inputTokens = chunk.usage.input_tokens
+  if (inputTokens != null) mergedUsage.input_tokens = inputTokens
+
   const cacheCreationTokens = chunk.usage.cache_creation_input_tokens
   const cacheReadTokens = chunk.usage.cache_read_input_tokens
   if (cacheCreationTokens) mergedUsage.cache_creation_input_tokens = cacheCreationTokens
   if (cacheReadTokens) mergedUsage.cache_read_input_tokens = cacheReadTokens
 
+  const serverToolUse = chunk.usage.server_tool_use
+  if (serverToolUse) mergedUsage.server_tool_use = serverToolUse
+
   return mergedUsage
 }
 
@@ -280,6 +288,13 @@ function extractUsage (result) {
     metrics.cacheWrite1hTokens = 0
   }
 
+  // Read the usage counter, not server_tool_use blocks: dynamic filtering nests searches under code
+  // execution, and `response_inclusion: "excluded"` drops the blocks while the searches are still billed.
+  // Failed searches aren't billed and are already excluded. web_fetch_requests is skipped because web
+  // fetch has no per-call price.
+  const webSearchRequests = usage.server_tool_use?.web_search_requests
+  if (webSearchRequests > 0) metrics.webSearchCount = webSearchRequests
+
   return metrics
 }
 

package/packages/dd-trace/src/llmobs/plugins/genai/util.js

@@ -84,8 +84,7 @@ function determineRole (candidate, parts = []) {
  * @param {string} role
  */
 function normalizeRole (role) {
-  if (role === ROLES.MODEL) return ROLES.ASSISTANT
-  if (role === ROLES.ASSISTANT) return ROLES.ASSISTANT
+  if (role === ROLES.MODEL || role === ROLES.ASSISTANT) return ROLES.ASSISTANT
   if (role === ROLES.USER) return ROLES.USER
   if (role === ROLES.REASONING) return ROLES.REASONING
   return ROLES.USER // default

package/packages/dd-trace/src/llmobs/plugins/langchain/handlers/chat_model.js

@@ -62,11 +62,9 @@ class LangChainLLMObsChatModelHandler extends LangChainLLMObsHandler {
    */
   getTokenUsage (results) {
     const tokens = this.checkTokenUsageChatOrLLMResult(results)
-    if (tokens.totalTokens > 0) return tokens
-
     // providers that report usage on each generated message instead of on `llmOutput`; counts are
     // summed per run so a run split across generations is totalled once
-    if (!results.generations) return tokens
+    if (tokens.totalTokens > 0 || !results.generations) return tokens
 
     const tokensPerRunId = {}
     for (const messageSet of results.generations) {

package/packages/dd-trace/src/llmobs/plugins/langgraph/index.js

@@ -76,7 +76,7 @@ class NextStreamLLMObsPlugin extends LLMObsPlugin {
     const { streamInputs: inputs, chunks } = streamData
     const input = inputs == null ? undefined : formatIO(inputs)
     const lastChunk = chunks.length > 0 ? chunks.at(-1) : undefined
-    const output = !hasError && lastChunk != null ? formatIO(lastChunk) : undefined
+    const output = hasError || lastChunk == null ? undefined : formatIO(lastChunk)
 
     this._tagger.tagTextIO(span, input, output)
 

package/packages/dd-trace/src/llmobs/plugins/nova-sonic.js

@@ -0,0 +1,92 @@
+'use strict'
+
+const { pcm16ToWav } = require('../audio-codec')
+const { fitsInlineAudioBudget, formatAudioPartWithGuard } = require('../audio-utils')
+const { AUDIO_FALLBACK, LLMOBS_AUDIO_INLINE_MAX_BYTES } = require('../constants/audio')
+const { storage } = require('../storage')
+const LLMObsPlugin = require('./base')
+
+class SonicLLMObsPlugin extends LLMObsPlugin {
+  static id = 'bedrockruntime_sonic_llmobs'
+  static integration = 'bedrock'
+  static system = 'aws.bedrock'
+  static prefix = 'tracing:apm:aws:bedrockruntime:sonic:span'
+  static emitsGenAiApmTags = false
+
+  constructor (...args) {
+    super(...args)
+    this.addSub('dd-trace:aws:bedrockruntime:sonic:capture-context', context => {
+      if (!this._llmobsEnabled) return
+      context.enabled = true
+      // Capture once at invocation, even when absent or already finished. Scoped replay restores
+      // the consumer's context on every exit, including exceptions, without repairing IDs later.
+      const store = storage.getStore()
+      const previous = context.runInContext ?? (fn => fn())
+      context.runInContext = fn => previous(() => storage.run(store, fn))
+    })
+  }
+
+  /** @param {object} ctx */
+  getLLMObsSpanRegisterOptions (ctx) {
+    const options = {
+      kind: ctx.kind,
+      name: ctx.name,
+      sessionId: ctx.descriptor.sessionId,
+    }
+    if (ctx.kind === 'llm') {
+      options.modelName = ctx.model
+      options.modelProvider = 'amazon'
+    }
+    return options
+  }
+
+  /** @param {object} ctx */
+  start (ctx) {
+    super.start(ctx)
+    // Replay already has the complete descriptor. Annotate before any end subscriber can finish
+    // the span, including when disabling/re-enabling LLMObs changes subscriber registration order.
+    if (this._llmobsEnabledFor(ctx)) this.setLLMObsTags(ctx)
+  }
+
+  /** @param {object} ctx */
+  setLLMObsTags (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+    const { turn, history, metadata } = ctx.descriptor
+    const text = turn.finalText || turn.speculativeText
+    if (ctx.kind !== 'llm') {
+      if (ctx.name === 'nova sonic audio turn') this._tagger.tagTextIO(span, turn.userText, text)
+      return
+    }
+
+    const input = { role: 'user', content: turn.userText || (turn.inputAudioObserved ? AUDIO_FALLBACK : '') }
+    const output = { role: 'assistant', content: text || (turn.outputAudioObserved ? AUDIO_FALLBACK : '') }
+    if (turn.tools.length) output.toolCalls = turn.tools
+    const inputs = [...history, input, ...turn.toolResults]
+    const outputs = [output]
+    // Reserve the serialized text/tools and metadata before spending one budget across both WAVs.
+    let budget = Math.max(0, LLMOBS_AUDIO_INLINE_MAX_BYTES -
+      Buffer.byteLength(JSON.stringify([inputs, outputs, metadata])) - 256)
+    for (const [message, pcm, rate] of [
+      [input, turn.inputPcm, turn.inputRate],
+      [output, turn.output.pcm(), turn.output.rate],
+    ]) {
+      if (!pcm?.length || !rate) continue
+      const part = fitsInlineAudioBudget(pcm.length + 44, budget)
+        ? formatAudioPartWithGuard(pcm16ToWav(pcm, rate), 'audio/wav', budget)
+        : undefined
+      if (part) {
+        message.audioParts = [part]
+        budget -= part.content.length
+      } else if (message === output) {
+        metadata.output_audio_omitted_reason = 'payload_limit'
+      }
+    }
+    if (turn.output.omittedReason) metadata.output_audio_omitted_reason = turn.output.omittedReason
+    this._tagger.tagLLMIO(span, inputs, outputs)
+    this._tagger.tagMetadata(span, metadata)
+    this._tagger.tagMetrics(span, turn.metrics)
+  }
+}
+
+module.exports = SonicLLMObsPlugin

package/packages/dd-trace/src/llmobs/plugins/openai/index.js

@@ -8,7 +8,7 @@ const {
 } = require('../../constants/tags')
 const { audioMimeTypeFromFormat, formatAudioPart } = require('../../audio-utils')
 const { safeJsonParse } = require('../../util')
-const { AUDIO_MIME_TYPES } = require('./constants')
+const { AUDIO_MIME_TYPES, IMAGE_FALLBACK, INPUT_TYPE_IMAGE } = require('./constants')
 const {
   extractChatTemplateFromInstructions,
   normalizePromptVariables,
@@ -16,6 +16,7 @@ const {
   extractContentParts,
   hasMultimodalInputs,
   getModelProviderAndClient,
+  getServerToolUsageMetrics,
 } = require('./utils')
 
 const allowedParamKeys = new Set([
@@ -107,6 +108,8 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
       this._tagEmbedding(span, inputs, response, error)
     } else if (operation === 'response') {
       this.#tagResponse(span, inputs, response, error)
+    } else if (operation === 'decision') {
+      this.#tagDecision(span, inputs, response, error)
     }
 
     if (!error) {
@@ -148,12 +151,20 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
         // Responses API - always include
         const cacheReadTokens = tokenUsage.input_tokens_details.cached_tokens
         if (cacheReadTokens !== undefined) metrics.cacheReadTokens = cacheReadTokens
+        const cacheWriteTokens = tokenUsage.input_tokens_details.cache_write_tokens
+        if (cacheWriteTokens != null) metrics.cacheWriteTokens = cacheWriteTokens
+        // Cache writes are billed at a different rate per TTL
+        const cacheWriteDetails = tokenUsage.input_tokens_details.cache_write_tokens_details
+        if (cacheWriteDetails?.ttl_30m_tokens != null) metrics.cacheWrite30mTokens = cacheWriteDetails.ttl_30m_tokens
+        if (cacheWriteDetails?.ttl_12h_tokens != null) metrics.cacheWrite12hTokens = cacheWriteDetails.ttl_12h_tokens
       } else if (tokenUsage.prompt_tokens_details) {
         // Chat/Completions API - only include if > 0
         const cacheReadTokens = tokenUsage.prompt_tokens_details.cached_tokens
         if (cacheReadTokens != null) {
           metrics.cacheReadTokens = cacheReadTokens
         }
+        const cacheWriteTokens = tokenUsage.prompt_tokens_details.cache_write_tokens
+        if (cacheWriteTokens != null) metrics.cacheWriteTokens = cacheWriteTokens
       }
       // Reasoning tokens - Responses API returns `output_tokens_details`, `completion_tokens_details`
       const reasoningOutputObject = tokenUsage.output_tokens_details ?? tokenUsage.completion_tokens_details
@@ -161,6 +172,8 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
       if (reasoningOutputTokens !== undefined) metrics.reasoningOutputTokens = reasoningOutputTokens
     }
 
+    Object.assign(metrics, getServerToolUsageMetrics(response))
+
     return metrics
   }
 
@@ -464,6 +477,30 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
 
     this._tagger.tagMetadata(span, outputMetadata) // update the metadata with the output metadata
   }
+
+  #tagDecision (span, inputs, response, error) {
+    const { input, questions } = inputs
+
+    const inputMessages = typeof input === 'string'
+      ? [{ role: 'user', content: input }]
+      : (Array.isArray(input) ? input : []).map(message => ({
+          role: message.role ?? 'user',
+          content: decisionMessageContent(message.content),
+        }))
+
+    if (Array.isArray(questions)) {
+      this._tagger.tagMetadata(span, { questions })
+    }
+
+    if (error) {
+      this._tagger.tagLLMIO(span, inputMessages, [{ content: '' }])
+      return
+    }
+
+    this._tagger.tagLLMIO(span, inputMessages, [
+      { role: 'assistant', content: JSON.stringify(response.answers ?? []) },
+    ])
+  }
 }
 
 // TODO: this will be moved to the APM integration
@@ -485,13 +522,28 @@ function normalizeOpenAIResourceName (resource) {
     case 'responses.create':
       return 'createResponse'
 
+    // decisions
+    case 'decisions.create':
+      return 'createDecision'
+
     default:
       return resource
   }
 }
 
+// Decision images must be inline data URLs, so they are replaced with a marker instead of copied onto the span
+function decisionMessageContent (content) {
+  if (!Array.isArray(content)) return content ?? ''
+
+  return content
+    .map(part => (part?.type === INPUT_TYPE_IMAGE ? IMAGE_FALLBACK : part?.text ?? ''))
+    .filter(Boolean)
+    .join('\n')
+}
+
 function gateResource (resource) {
-  return ['createCompletion', 'createChatCompletion', 'createEmbedding', 'createResponse'].includes(resource)
+  return ['createCompletion', 'createChatCompletion', 'createEmbedding', 'createResponse', 'createDecision']
+    .includes(resource)
     ? resource
     : undefined
 }
@@ -506,6 +558,8 @@ function getOperation (resource) {
       return 'embedding'
     case 'createResponse':
       return 'response'
+    case 'createDecision':
+      return 'decision'
     default:
       // should never happen
       return 'unknown'

package/packages/dd-trace/src/llmobs/plugins/openai/utils.js

@@ -198,6 +198,43 @@ function getModelProviderAndClient (baseUrl = '') {
   return { modelProvider, client: 'OpenAI' }
 }
 
+/**
+ * Count the billable server-side tool calls in an OpenAI Responses response.
+ *
+ * Web searches are read from the undocumented `tool_usage.web_search.num_requests` when present, otherwise
+ * counted from completed `web_search_call` items whose action is `search` (`open_page` / `find_in_page` steps are
+ * not billed). File searches have no usage counter, so each completed `file_search_call` item counts once.
+ * Zero counts are omitted.
+ *
+ * @param {Record<string, unknown>} [response] - Any OpenAI response; only Responses API fields are read
+ * @returns {{ webSearchCount?: number, storageSearchCount?: number }}
+ */
+function getServerToolUsageMetrics (response) {
+  const metrics = {}
+  const reportedWebSearches = response?.tool_usage?.web_search?.num_requests
+  const hasReportedWebSearches = typeof reportedWebSearches === 'number'
+  if (hasReportedWebSearches && reportedWebSearches > 0) metrics.webSearchCount = reportedWebSearches
+
+  const output = response?.output
+  if (!Array.isArray(output)) return metrics
+
+  for (const item of output) {
+    if (item?.status !== 'completed') continue
+
+    if (item.type === 'web_search_call') {
+      if (hasReportedWebSearches) continue
+      // Items without an action (older payloads) are assumed to be searches.
+      const actionType = item.action?.type
+      if (actionType !== undefined && actionType !== 'search') continue
+      metrics.webSearchCount = (metrics.webSearchCount ?? 0) + 1
+    } else if (item.type === 'file_search_call') {
+      metrics.storageSearchCount = (metrics.storageSearchCount ?? 0) + 1
+    }
+  }
+
+  return metrics
+}
+
 module.exports = {
   extractChatTemplateFromInstructions,
   normalizePromptVariables,
@@ -206,4 +243,5 @@ module.exports = {
   hasMultimodalInputs,
   getModelProviderAndClient,
   getOpenAIModelProvider,
+  getServerToolUsageMetrics,
 }

package/packages/dd-trace/src/llmobs/prompts/manager.js

@@ -84,13 +84,11 @@ function promptFromData (data, source) {
 }
 
 /**
- * Copy a prompt with a different source.
  * @param {ManagedPrompt} prompt
- * @param {'registry'|'cache'|'fallback'|'ff'|'resolve'} source
  */
-function withSource (prompt, source) {
-  if (source === prompt.source) return prompt
-  return new ManagedPrompt({ ...prompt, source })
+function withCacheSource (prompt) {
+  if (SOURCE_CACHE === prompt.source) return prompt
+  return new ManagedPrompt({ ...prompt, source: /** @type {ManagedPrompt['source']} */ (SOURCE_CACHE) })
 }
 
 function detailFromBody (body) {
@@ -310,7 +308,7 @@ class PromptManager {
     const cacheable = generationAtStart === this.cacheGeneration && latest
     if (result.prompt) {
       if (cacheable) {
-        const cached = withSource(result.prompt, SOURCE_CACHE)
+        const cached = withCacheSource(result.prompt)
         if (hot) this.hotCache.set(request.key, cached)
         if (!request.resolve) this.warmCache.set(request.key, cached)
       }
@@ -335,7 +333,7 @@ class PromptManager {
   async #backgroundFetch (request, signal) {
     const result = await this.#fetchAndCache(request, { hot: false, signal })
     if (!result.cacheable) return
-    if (result.prompt) return withSource(result.prompt, SOURCE_CACHE)
+    if (result.prompt) return withCacheSource(result.prompt)
     if (result.notFound) return
     throw new Error(result.reason)
   }

package/packages/dd-trace/src/llmobs/prompts/prompt.js

@@ -93,7 +93,7 @@ class ManagedPrompt {
   format (variables = {}) {
     if (typeof this.template === 'string') return render(this.template, variables)
     return this.template.flatMap(item => {
-      if (!isPlaceholder(item)) return [{ ...item, content: render(item.content, variables) }]
+      if (!isPlaceholder(item)) return { ...item, content: render(item.content, variables) }
       if (!Object.hasOwn(variables, item.name)) {
         throw new TypeError(`Missing message placeholder variable '${item.name}'`)
       }

package/packages/dd-trace/src/llmobs/sdk.js

@@ -29,6 +29,8 @@ const {
   getFunctionArguments,
   validateKind,
 } = require('./util')
+const { buildAgentDeclaration } = require('./agent-manifest')
+/** @typedef {import('./agent-manifest').AgentDeclaration} AgentDeclaration */
 const { storage } = require('./storage')
 const telemetry = require('./telemetry')
 const LLMObsTagger = require('./tagger')
@@ -300,7 +302,7 @@ class LLMObs extends NoopLLMObs {
         throw new Error('LLMObs span must have a span kind specified')
       }
 
-      const { inputData, outputData, metadata, metrics, tags, prompt, costTags, toolDefinitions } = options
+      const { inputData, outputData, metadata, metrics, tags, prompt, costTags, toolDefinitions, agent } = options
 
       const hasInputOrOutput = spanKind === 'experiment'
         ? inputData !== undefined || outputData !== undefined
@@ -338,6 +340,15 @@ class LLMObs extends NoopLLMObs {
       if (toolDefinitions != null) {
         this._tagger.tagToolDefinitions(span, toolDefinitions)
       }
+      if (agent != null) {
+        if (spanKind === 'agent') {
+          this._tagger.tagAgent(span, agent)
+        } else {
+          logger.warn(
+            'Dropping agent annotation on non-agent span kind, annotating agents is only supported for agent spans.'
+          )
+        }
+      }
     } catch (e) {
       if (e.ddErrorTag) {
         err = e.ddErrorTag
@@ -602,14 +613,20 @@ class LLMObs extends NoopLLMObs {
   annotationContext (options, fn) {
     if (!this.enabled) return fn()
 
+    /** @type {{ annotationContext?: object, agentDeclarations?: AgentDeclaration[] } | undefined} */
     const currentStore = storage.getStore()
-
+    const { agent, ...contextOptions } = options ?? {}
+    /** @type {{ annotationContext: object, agentDeclarations?: AgentDeclaration[] }} */
     const store = {
       ...currentStore,
-      annotationContext: {
-        ...currentStore?.annotationContext,
-        ...options,
-      },
+      annotationContext: { ...currentStore?.annotationContext, ...contextOptions },
+    }
+
+    if (agent != null) {
+      const declaration = buildAgentDeclaration(agent)
+      // Outside `annotationContext`, whose keys come from the caller. Outermost first, so nested declarations fold
+      // onto the outer ones.
+      if (declaration) store.agentDeclarations = [...(currentStore?.agentDeclarations ?? []), declaration]
     }
 
     return storage.run(store, fn)

package/packages/dd-trace/src/llmobs/span_processor.js

@@ -15,6 +15,7 @@ const {
   MODEL_PROVIDER,
   METADATA,
   COST_TAGS,
+  AGENT_MANIFEST,
   TOOL_DEFINITIONS,
   EXPERIMENT_INPUT,
   EXPERIMENT_OUTPUT,
@@ -43,6 +44,7 @@ const {
   DEFAULT_MODEL,
 } = require('./constants/tags')
 const { UNSERIALIZABLE_VALUE_TEXT } = require('./constants/text')
+const { MANUAL_FRAMEWORK_NAME } = require('./agent-manifest')
 const { setGenAiApmTags } = require('./gen-ai-tags')
 const telemetry = require('./telemetry')
 const LLMObsTagger = require('./tagger')
@@ -90,9 +92,8 @@ class LLMObsSpanProcessor {
 
   // TODO: instead of relying on the tagger's weakmap registry, can we use some namespaced storage correlation?
   process (span) {
-    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
     // if the span is not in our private tagger map, it is not an llmobs span
-    if (!LLMObsTagger.tagMap.has(span)) return
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED || !LLMObsTagger.tagMap.has(span)) return
 
     try {
       this.#setGenAiApmTags(span)
@@ -152,15 +153,26 @@ class LLMObsSpanProcessor {
       meta.model_provider = (mlObsTags[MODEL_PROVIDER] || DEFAULT_MODEL).toLowerCase()
     }
 
-    if (mlObsTags[METADATA] || mlObsTags[COST_TAGS]) {
+    const name = mlObsTags[NAME] || span._name
+    const agentManifest = spanKind === 'agent' ? mlObsTags[AGENT_MANIFEST] : undefined
+
+    if (mlObsTags[METADATA] || mlObsTags[COST_TAGS] || agentManifest) {
+      /** @type {Record<string, unknown>} */
       const metadata = {}
       if (mlObsTags[METADATA]) this.#addObject(mlObsTags[METADATA], metadata)
-      // Only seed `metadata._dd` when there's something to put in it (currently cost_tags). Mirrors
-      // dd-trace-py and the cross-language wire format enforced by system-tests — metadata-only
-      // spans must not carry an empty `_dd: {}` block.
+      // Only seed `metadata._dd` when there's something to put in it. Mirrors dd-trace-py and the
+      // cross-language wire format enforced by system-tests, so metadata-only spans must not carry
+      // an empty `_dd: {}` block.
       if (mlObsTags[COST_TAGS]) {
         this.#getDdMetadata(metadata).cost_tags = mlObsTags[COST_TAGS]
       }
+      if (agentManifest) {
+        this.#getDdMetadata(metadata).agent_manifest = {
+          framework: MANUAL_FRAMEWORK_NAME,
+          ...agentManifest,
+          name: agentManifest.name ?? name,
+        }
+      }
       meta.metadata = metadata
     }
 
@@ -227,8 +239,6 @@ class LLMObsSpanProcessor {
     const sessionId = mlObsTags[SESSION_ID]
     const parentId = mlObsTags[PARENT_ID_KEY]
 
-    const name = mlObsTags[NAME] || span._name
-
     const tags = this.#getTags(span, mlApp, sessionId, error)
     llmObsSpan._tags = tags
 

package/packages/dd-trace/src/llmobs/tagger.js

@@ -18,6 +18,7 @@ const {
   OUTPUT_VALUE,
   METADATA,
   COST_TAGS,
+  AGENT_MANIFEST,
   METRICS,
   TOOL_DEFINITIONS,
   PARENT_ID_KEY,
@@ -53,6 +54,7 @@ const {
   TRACE_ID,
   PROPAGATED_TRACE_ID_KEY,
 } = require('./constants/tags')
+const { buildAgentDeclaration } = require('./agent-manifest')
 const { storage } = require('./storage')
 const {
   findGenAIAncestorSpanId,
@@ -116,8 +118,8 @@ class LLMObsTagger {
     integration,
     _decorator,
   } = {}) {
-    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
-    if (!kind) return // do not register it in the map if it doesn't have an llmobs span kind
+    // Do not register it in the map if it does not have an LLMObs span kind.
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED || !kind) return
 
     const spanMlApp =
       mlApp ||
@@ -187,6 +189,11 @@ class LLMObsTagger {
       this.tagCostTags(span, annotationContext.costTags, 'annotation_context')
     }
 
+    const agentDeclarations = /** @type {import('./agent-manifest').AgentDeclaration[] | undefined} */ (
+      storage.getStore()?.agentDeclarations
+    )
+    if (agentDeclarations) this.#applyAgentDeclarations(span, agentDeclarations)
+
     // apply annotation context name
     const annotationContextName = annotationContext?.name
     if (annotationContextName) this._setTag(span, NAME, annotationContextName)
@@ -204,6 +211,43 @@ class LLMObsTagger {
     }
   }
 
+  /**
+   * Applies the agents declared by the enclosing annotation contexts, outermost first, to every span in the block.
+   * The manifest is emitted only if the span is an agent when it finishes, since some integrations promote a span
+   * to an agent after registration.
+   *
+   * @param {import('../opentracing/span')} span
+   * @param {import('./agent-manifest').AgentDeclaration[]} declarations
+   */
+  #applyAgentDeclarations (span, declarations) {
+    for (const declaration of declarations) {
+      this.#tagAgentManifestFields(span, declaration.manifest)
+    }
+  }
+
+  /**
+   * Tags the agent a caller declared on an agent span, merged onto what earlier annotations declared.
+   *
+   * @param {import('../opentracing/span')} span
+   * @param {unknown} agent
+   */
+  tagAgent (span, agent) {
+    const declaration = buildAgentDeclaration(agent)
+    if (declaration) this.#tagAgentManifestFields(span, declaration.manifest)
+  }
+
+  /**
+   * @param {import('../opentracing/span')} span
+   * @param {import('./agent-manifest').AgentManifestFields} manifest
+   */
+  #tagAgentManifestFields (span, manifest) {
+    // A shallow update, matching dd-trace-py: each declaration is already validated, so a later field replaces an
+    // earlier one whole (`model_settings` included) and an unset or invalid one leaves it in place. Declarations are
+    // never mutated, so the first one is stored without a copy.
+    const existing = registry.get(span)?.[AGENT_MANIFEST]
+    this._setTag(span, AGENT_MANIFEST, existing ? { ...existing, ...manifest } : manifest)
+  }
+
   #tagSamplingDecision (span, parent) {
     const traceTags = span.context()._trace.tags
     const parentTags = registry.get(parent)
@@ -337,7 +381,16 @@ class LLMObsTagger {
     if (currentTags) {
       Object.assign(currentTags, tags)
     } else {
-      this._setTag(span, TAGS, tags)
+      // Copied so a later annotation cannot write into a caller's object shared by an annotation context. The copy
+      // reads caller getters and Proxy traps during span registration, so it must not throw into the application.
+      let copy
+      try {
+        copy = { ...tags }
+      } catch {
+        log.warn('Dropping span tags that could not be read.')
+        return
+      }
+      this._setTag(span, TAGS, copy)
     }
   }
 

package/packages/dd-trace/src/llmobs/util.js

@@ -260,8 +260,7 @@ function findArgumentsBounds (str) {
 
 const memo = new WeakMap()
 function getFunctionArguments (fn, args = []) {
-  if (!fn) return
-  if (!args.length) return
+  if (!fn || !args.length) return
   if (args.length === 1) return args[0]
 
   try {

package/packages/dd-trace/src/llmobs/writers/base.js

@@ -4,7 +4,7 @@ const { URL, format } = require('node:url')
 const path = require('node:path')
 const request = require('../../exporters/common/request')
 const { getEnvironmentVariable } = require('../../config/helper')
-const { createServerlessDeliveryTracker } = require('../../serverless')
+const { createServerlessDeliveryTracker, IS_STANDARD_AWS_LAMBDA } = require('../../serverless')
 
 const logger = require('../../log')
 
@@ -23,13 +23,12 @@ class LLMObsBuffer {
   /**
    * @param {{
    *   events: Record<string, unknown>[],
-   *   size: number,
    *   routing?: { apiKey?: string, site?: string }
    * }} options
    */
-  constructor ({ events, size, routing = {} }) {
+  constructor ({ events, routing = {} }) {
     this.events = events
-    this.size = size
+    this.size = 0
     this.routing = routing
   }
 
@@ -53,7 +52,7 @@ class BaseLLMObsWriter {
     this._eventType = eventType
 
     /** @type {LLMObsBuffer} */
-    this._buffer = new LLMObsBuffer({ events: [], size: 0 })
+    this._buffer = new LLMObsBuffer({ events: [] })
 
     /** @type {import('../../config/config-base')} */
     this._config = config
@@ -92,7 +91,7 @@ class BaseLLMObsWriter {
     const apiKey = routing.apiKey
     let buffer = this.#multiTenantBuffers.get(apiKey)
     if (!buffer) {
-      buffer = new LLMObsBuffer({ events: [], size: 0, routing })
+      buffer = new LLMObsBuffer({ events: [], routing })
       this.#multiTenantBuffers.set(apiKey, buffer)
     }
     return buffer
@@ -118,6 +117,8 @@ class BaseLLMObsWriter {
 
     buffer.size += eventSize
     buffer.events.push(event)
+    // The standard Lambda sandbox can freeze before the periodic flush runs.
+    if (IS_STANDARD_AWS_LAMBDA) this.flush()
     return true
   }