@cap-js/agents 0.9.6 → 0.9.8

package/lib/agents/middleware/status-update.js

@@ -1,63 +1,103 @@
 import cds from "@sap/cds"
 import { createMiddleware } from "langchain"
-import { ToolMessage } from "@langchain/core/messages"
+import { AIMessage, ToolMessage } from "@langchain/core/messages"
+import { resolvePseudonyms } from "../../masking/index.js"
+import { serviceLabel, declaredServiceLabel, mcpToolKind } from "../../utils/utils.js"
 
 /**
- * Resolves a human-readable label for a tool call.
- *
- * - query tool → resolves entity label from CDS model: @Common.Label, @title, or i18n
- * - actions → resolves label from action definition
- * - fallback → tool name as-is
+ * Resolve the metadata for a tool call, or undefined when the tool is unknown.
+ * Static tools come from the precomputed `toolMeta` map; remote MCP tools are
+ * resolved per-request from cds.context.__mcpDynamicTools.
  */
-function resolveToolLabel(tc) {
-  const serviceName = cds.context?.["agent.service"]
-  const srv = serviceName && cds.services?.[serviceName]
-  const model = cds.context?.model ?? cds.model
+function resolveMeta(tc, toolMeta) {
+  const meta = toolMeta.get(tc.name)
+  if (meta) return meta
 
-  // Query tool: extract entity target and resolve its label
-  if (tc.name === "query" || tc.name?.endsWith("_query")) {
-    let entityName = tc.args?.entity ? `${serviceName}.${tc.args.entity}` : undefined
-
-    // SQL format: no entity arg — parse SQL to extract FROM target
-    if (!entityName && tc.args?.cql) {
-      try {
-        const cqn = cds.parse.cql(tc.args.cql)
-        const ref0 = cqn.SELECT?.from?.ref?.[0]
-        const targetName = ref0?.id ?? ref0
-        if (targetName && serviceName && !targetName.startsWith(serviceName + ".")) {
-          entityName = `${serviceName}.${targetName}`
-        } else {
-          entityName = targetName
-        }
-      } catch {
-        /* fallback to tc.name below */
-      }
-    }
-    if (entityName) {
-      const entityDef = model.definitions?.[entityName]
-      if (entityDef) {
-        const label = cds.i18n?.labels?.at(entityDef)
-        if (label) return label
-      }
-    }
-    // Fallback: strip service prefix if present
-    if (entityName && srv?.name && entityName.startsWith(srv.name + ".")) {
-      return entityName.slice(srv.name.length + 1)
+  const cache = cds.context?.__mcpDynamicTools
+  if (cache) {
+    for (const entry of Object.values(cache)) {
+      const t = entry.tools?.find((t) => t.name === tc.name)
+      if (t) return t.metadata
     }
-    return entityName || tc.name
   }
+  return undefined
+}
+
+/**
+ * Resolve the kind ("query" | "describe" | "action" | "agent") for a tool call.
+ * Prefer the build-time `meta.kind` (classified from the unprefixed name, so it
+ * survives prefixing/truncation); else sniff `tc.name` for own-service tools.
+ */
+function resolveToolKind(tc, meta) {
+  if (meta?.kind) return meta.kind
+  return mcpToolKind(tc.name)
+}
+
+/** Resolve an entity's display label (declared i18n label, else its simple name). */
+function entityLabel(name, serviceName, model) {
+  const fq = serviceName && !name.startsWith(serviceName + ".") ? `${serviceName}.${name}` : name
+  const def = model?.definitions?.[fq]
+  return (
+    (def && cds.i18n?.labels?.at(def)) ||
+    (fq.includes(".") ? fq.slice(fq.lastIndexOf(".") + 1) : fq)
+  )
+}
 
-  // Action/function tools: resolve from service definition
-  if (srv) {
-    // Try as action on service
-    const actionDef = model.definitions[`${srv.name}.${tc.name}`]
-    if (actionDef) {
-      const label = cds.i18n?.labels?.at(actionDef)
-      if (label) return label
+/** Resolve the query target: the `entity` arg, or the FROM target parsed from `cql`. */
+function queryTarget(tc) {
+  if (tc.args?.entity) return tc.args.entity
+  if (tc.args?.cql) {
+    try {
+      const ref0 = cds.parse.cql(tc.args.cql).SELECT?.from?.ref?.[0]
+      return ref0?.id ?? ref0 ?? undefined
+    } catch {
+      /* no target derivable */
     }
   }
+  return undefined
+}
+
+/**
+ * Resolve a human-readable label for a tool call:
+ * - agent    → declared service label, else the subagent's agent-card name
+ * - describe → service label (declared, else the FQ service name)
+ * - query    → entity label, prefixed with the service only when it has a declared label
+ * - action   → action label, prefixed with the service only when it has a declared label
+ */
+function resolveToolLabel(tc, meta, kind = resolveToolKind(tc, meta)) {
+  const model = cds.context?.model ?? cds.model
+  const serviceName = meta?.serviceName ?? cds.context?.["agent.service"] // REVISIT: why are we using cds.context here?
+
+  if (kind === "agent") {
+    return declaredServiceLabel(meta?.serviceName) || meta?.agentName || tc.name
+  }
+
+  if (kind === "describe") {
+    let parts = []
+    if (tc.args?.entities) parts.push(...tc.args.entities.map(e => entityLabel(e, serviceName, model)))
+    if (tc.args?.actions) parts.push(...tc.args.actions.map(a => entityLabel(a, serviceName, model)))
+    if (!parts.length) parts.push(serviceLabel(serviceName) || tc.name)
+    return parts.join(", ")
+  }
+
+  const svcLabel = declaredServiceLabel(serviceName)
+  const withService = (detail) => (svcLabel ? `${svcLabel} · ${detail}` : detail)
+
+  if (kind === "query") {
+    const target = queryTarget(tc)
+    if (target) return withService(entityLabel(target, serviceName, model))
+    return svcLabel || tc.name
+  }
 
-  return tc.name
+  // meta.actionName is the un-prefixed name for MCP action tools (tc.name is
+  // "{service}_{action}"); own-service tools already carry the bare name.
+  const actionName = meta?.actionName ?? tc.args?.action ?? tc.name
+  if (serviceName) {
+    const actionDef = model?.definitions?.[`${serviceName}.${actionName}`]
+    const declared = actionDef && cds.i18n?.labels?.at(actionDef) || actionName
+    if (declared) return withService(declared)
+  }
+  return withService(actionName)
 }
 
 /**
@@ -86,29 +126,106 @@ export function publishStatus(text) {
 }
 
 /**
- * beforeModel hook: emit "Processing tool response" when tools just finished.
+ * Reads tool-call visibility config from the current request's metadata.
+ * Controlled entirely by the client: presence of userMessage.metadata["tool-status-update"] enables it.
+ */
+function toolCallConfig() {
+  const requestMeta = cds.context?.["agent.request.metadata"]?.["tool-status-update"]
+  return {
+    enabled: requestMeta !== undefined,
+    args: requestMeta?.args ?? true,
+    result: requestMeta?.result ?? true,
+  }
+}
+
+function serialize(v) {
+  return resolvePseudonyms(typeof v === "string" ? v : JSON.stringify(v))
+}
+
+/**
+ * Publishes an artifact-update for a tool call (start or end).
+ */
+function publishToolCallArtifact(tc, { meta, status, lastChunk, result }) {
+  const eventBus = cds.context?.["agent.eventBus"]
+  const config = toolCallConfig()
+  if (!eventBus || !config.enabled) return
+
+  let kind = resolveToolKind(tc, meta)
+  let label = resolveToolLabel(tc, meta)
+  eventBus.publish({
+    kind: "artifact-update",
+    taskId: cds.context["agent.task.id"],
+    contextId: cds.context["agent.context.id"],
+    append: false,
+    lastChunk,
+    artifact: {
+      artifactId: `tool-call-${tc.id}`,
+      parts: [
+        {
+          kind: "data",
+          data: {
+            type: "tool-call",
+            name: tc.name,
+            kind,
+            label,
+            status,
+            ...(config.args && { args: serialize(tc.args) }),
+            ...(result !== undefined && config.result && { result: serialize(result) }),
+          },
+        },
+      ],
+    },
+  })
+}
+
+/**
+ * beforeModel hook: emit "Processing tool response" + tool-call completion events.
  */
-export function beforeModelHook(state) {
+export function beforeModelHook(state, toolMeta) {
   if (!cds.context?.["agent.eventBus"]) return {}
 
   const msgs = state.messages
   if (!msgs?.length) return {}
-  const lastMsg = msgs[msgs.length - 1]
-  if (!ToolMessage.isInstance(lastMsg)) return {}
+  if (!ToolMessage.isInstance(msgs[msgs.length - 1])) return {}
 
-  // Plural if second-to-last is also a ToolMessage
-  const plural = msgs.length >= 2 && ToolMessage.isInstance(msgs[msgs.length - 2])
+  const firstToolIdx = msgs.findLastIndex((m) => !ToolMessage.isInstance(m)) + 1
+  const toolMsgs = msgs.slice(firstToolIdx)
+
+  const tcMap = {}
+  const msg = msgs.findLast((m) => AIMessage.isInstance(m) && m.tool_calls?.length)
+  if (msg) for (const tc of msg.tool_calls) tcMap[tc.id] = tc
+
+  for (const tm of toolMsgs) {
+    const tc = tcMap[tm.tool_call_id]
+    if (!tc) continue
+    const meta = resolveMeta(tc, toolMeta)
+    if (meta) {
+      publishToolCallArtifact(tc, {
+        meta,
+        status: tm.status === "error" ? "error" : "done",
+        lastChunk: true,
+        result: tm.content,
+      })
+    }
+  }
+
+  const plural = toolMsgs.length >= 2
   const key = plural ? "agent_status_processing_responses" : "agent_status_processing_response"
-  const text = cds.i18n.messages.at(key)
-  publishStatus(text)
+  publishStatus(cds.i18n.messages.at(key))
 
   return {}
 }
 
+/** De-duplicate labels while preserving order. */
+function uniqueLabels(calls) {
+  return [...new Set(calls.map(({ label }) => label))].join(", ")
+}
+
 /**
- * afterModel hook: emit tool-call status updates (querying/calling).
+ * afterModel hook: emit tool-call status updates (querying/inspecting/calling)
+ * + tool-call start events.
  */
-export function afterModelHook(state) {
+export function afterModelHook(state, toolMeta) {
   if (!cds.context?.["agent.eventBus"]) return {}
 
   const msgs = state.messages
@@ -118,36 +235,52 @@ export function afterModelHook(state) {
   const toolCalls = lastAI?.tool_calls
   if (!toolCalls?.length) return {}
 
-  // Separate query calls from action calls
-  const queryCalls = toolCalls.filter((tc) => tc.name === "query" || tc.name?.endsWith("_query"))
-  const otherCalls = toolCalls.filter((tc) => tc.name !== "query" && !tc.name?.endsWith("_query"))
+  const resolved = toolCalls
+    .map((tc) => ({ tc, meta: resolveMeta(tc, toolMeta) }))
+    .filter(({ meta }) => meta)
+    .map(({ tc, meta }) => {
+      let kind = resolveToolKind(tc, meta)
+      let label = resolveToolLabel(tc, meta, kind)
+      return { tc, meta, kind, label }
+    })
+
+  const queryCalls = resolved.filter(({ kind }) => kind === "query")
+  const describeCalls = resolved.filter(({ kind }) => kind === "describe")
+  const otherCalls = resolved.filter(({ kind }) => kind !== "query" && kind !== "describe")
 
-  // Emit "Querying {entities}" for query tools
   if (queryCalls.length) {
-    const labels = queryCalls.map((tc) => resolveToolLabel(tc))
-    const text = cds.i18n.messages.at("agent_status_querying", [labels.join(", ")])
-    publishStatus(text)
+    publishStatus(cds.i18n.messages.at("agent_status_querying", [uniqueLabels(queryCalls)]))
+  }
+  if (describeCalls.length) {
+    publishStatus(cds.i18n.messages.at("agent_status_describing", [uniqueLabels(describeCalls)]))
   }
-
-  // Emit "Calling {action labels}" for other tools
   if (otherCalls.length) {
-    const labels = otherCalls.map((tc) => resolveToolLabel(tc))
-    const text = cds.i18n.messages.at("agent_status_calling_tools", [labels.join(", ")])
-    publishStatus(text)
+    publishStatus(cds.i18n.messages.at("agent_status_calling_tools", [uniqueLabels(otherCalls)]))
+  }
+
+  for (const { tc, meta } of resolved) {
+    publishToolCallArtifact(tc, { meta, status: "running", lastChunk: false })
   }
 
   return {}
 }
 
 /**
- * Middleware factory that emits non-final status-update events during agent execution:
- * - beforeModel: "Processing tool response" after tools finish
- * - afterModel:  "Querying <entity>" / "Calling <action>" before tools are invoked
+ * Middleware emitting non-final status-update events during agent execution:
+ * - beforeModel: "Processing tool response" + tool-call completion events
+ * - afterModel:  "Querying"/"Inspecting"/"Calling" + tool-call start events
+ *
+ * Static tools are captured here; remote MCP tools are resolved per-request from
+ * cds.context.__mcpDynamicTools by resolveMeta().
  */
-export async function statusUpdateMiddleware() {
+export async function statusUpdateMiddleware(tools = []) {
+  // Presence in the map marks a tool as "known"; own-service tools carry no
+  // metadata (→ {}), so resolveToolKind sniffs their kind from the name.
+  const toolMeta = new Map(tools.map((t) => [t.name, t.metadata ?? {}]))
+
   return createMiddleware({
     name: "statusUpdateMiddleware",
-    beforeModel: { hook: beforeModelHook },
-    afterModel: { hook: afterModelHook },
+    beforeModel: { hook: (state) => beforeModelHook(state, toolMeta) },
+    afterModel: { hook: (state) => afterModelHook(state, toolMeta) },
   })
 }

package/lib/agents/middleware/tool-wrap.js

@@ -14,9 +14,8 @@ export function toolWrapMiddleware(srv) {
   return createMiddleware({
     name: "ToolWrapMiddleware",
     wrapToolCall: async function (request, handler) {
-      const { name, id, args } = request.toolCall
+      const { name, id } = request.toolCall
       try {
-        LOG.debug(srv.name, "calling tool", name, args)
         const result = await handler(request)
         if (ToolMessage.isInstance(result) && result.artifact?.isError === true) {
           result.status = "error"

package/lib/agents/summarize-on-timeout.js

@@ -60,14 +60,17 @@ export async function summarizePartialWork({
       reason === "timeOut"
         ? `Agent task was not completed within its time limit. Write short, precise progress summary so user can decide whether to continue. State completed work and immediate next work. Do not claim work not shown. Start with: Agent did not finish within time! End with: Continue running or stop? No other questions to the user allowed!`
         : `Agent task was interrupted. Reason: ${reason}. Based on conversation history, provide brief summary of completed work and remaining work. Be concise.`
-    summaryPrompt += `\n\n Conversation Snippet: \n\n ${conversationSnippet.trim()}`
+    summaryPrompt += `\n\n Conversation Snippet: \n\n`
 
     let summaryTimer
     try {
       const response = await Promise.race([
         (async () => {
+          const instruction = new HumanMessage(summaryPrompt)
+          instruction.name = "cap-js-agents-summarize"
           const model = await getModel()
-          return model.invoke([new HumanMessage(summaryPrompt)])
+          // Two messages, so the first one can be logged as the prompt for summarization in MLflow
+          return model.invoke([instruction, new HumanMessage(conversationSnippet.trim())])
         })(),
         new Promise((_, reject) => {
           summaryTimer = setTimeout(() => reject(new Error("Summary LLM call timed out")), timeout)

package/lib/config/local.js

@@ -2,26 +2,35 @@ import path from "node:path"
 import fs from "node:fs"
 import os from "node:os"
 import cds from "@sap/cds"
+import { toml } from "../utils/toml.js"
 
 const HOME = os.homedir() || process.env.HOME || process.env.USERPROFILE
 const local = (file) => file.replace(HOME, "~")
 const LOG = cds.log("agents")
 
 /**
- * `cds.connect.to` compliant langchain model
- * for connecting to an Anthropic compatible API,
- * with autoconfiguration based on env, options,
- * ~/.claude/settings.json and ~/.config/opencode/opencode.json
+ * Autoconfiguration for anthropic -> openai -> mock
  */
 export function resolve_config(options) {
-  let config = fromEnv()
+  let config = resolve_anthropic_config(options)
+  if (config?.credentials?.anthropicApiUrl || config?.credentials?.apiKey) return config
+  config = resolve_openai_config(options)
+  if (config?.credentials?.baseURL || config?.credentials?.apiKey) return config
+  return { kind: "mock" }
+}
+
+/**
+ * Anthropic autoconfiguration based on env, options,
+ * ~/.claude/settings.json and ~/.config/opencode/opencode.json
+ */
+export function resolve_anthropic_config(options) {
+  let config = fromAnthropicEnv()
   if (!config?.anthropicApiUrl)
     config = {
       ...config,
       ...(fromClaude() || fromOpencode()),
     }
   let { model, ...credentials } = config
-  if (!model && !options?.model) return { kind: "mock" }
   return {
     kind: "anthropic",
     model: options?.model || model,
@@ -32,7 +41,7 @@ export function resolve_config(options) {
   }
 }
 
-function fromEnv(env = process.env, silent) {
+function fromAnthropicEnv(env = process.env, silent) {
   let any,
     config = {}
   if ((any = env.ANTHROPIC_BASE_URL)) config.anthropicApiUrl = any
@@ -51,7 +60,7 @@ function fromClaude() {
     let settings = JSON.parse(fs.readFileSync(settings_json, "utf8"))
     // https://www.schemastore.org/claude-code-settings.json
 
-    let conf = (fromClaude.cached = fromEnv(settings?.env, "silent"))
+    let conf = (fromClaude.cached = fromAnthropicEnv(settings?.env, "silent"))
     if (!conf.model && settings.env) {
       let family = (settings.model || "sonnet").toUpperCase()
       conf.model = settings.env[`ANTHROPIC_DEFAULT_${family}_MODEL`] || settings?.model
@@ -88,6 +97,110 @@ function fromOpencode() {
   return fromOpencode.cached
 }
 
+/**
+ * OpenAI autoconfiguration based on env, options,
+ * ~/.codex/config.toml and ~/.config/opencode/opencode.json
+ */
+export function resolve_openai_config(options = {}) {
+  let config = fromOpenAIEnv()
+  if (!config?.baseURL)
+    config = {
+      ...config,
+      ...fromCodex(),
+      ...fromOpencodeOpenAI(),
+    }
+  let { model, ...credentials } = config
+  return {
+    kind: "openai",
+    model: options?.model || model,
+    credentials: {
+      ...credentials,
+      ...options?.credentials,
+    },
+  }
+}
+
+function fromOpenAIEnv(env = process.env) {
+  let any,
+    config = {}
+  if ((any = env.OPENAI_BASE_URL)) config.baseURL = any
+  if ((any = env.OPENAI_API_KEY)) config.apiKey = any
+  if ((any = env.OPENAI_MODEL)) config.model = any
+  if (!Object.keys(config).length) return null
+  LOG.debug(`Loaded OpenAI settings from env:`, config)
+  return config
+}
+
+function fromCodex() {
+  if ("cached" in fromCodex) return fromCodex.cached
+  const codex_toml = path.join(HOME, ".codex/config.toml")
+  try {
+    let conf = toml.parse(fs.readFileSync(codex_toml, "utf8"))
+    LOG.debug(`Loaded Codex settings from`, local(codex_toml))
+    const provider = conf.model_provider ?? "openai"
+    const p = conf.model_providers?.[provider] ?? {}
+    let apiKey = (p.env_key && process.env[p.env_key]) || p.experimental_bearer_token
+    if (!apiKey && p.requires_openai_auth) apiKey = fromCodexAuth()
+    let any,
+      config = {}
+    if ((any = p.base_url)) config.baseURL = any
+    if (
+      (any =
+        (p.env_key && process.env[p.env_key]) ??
+        p.experimental_bearer_token ??
+        (p.requires_openai_auth && fromCodexAuth()))
+    )
+      config.apiKey = any
+    if ((any = conf.model)) config.model = any
+    fromCodex.cached = Object.keys(config).length ? config : null
+    LOG.debug(`Loaded config from`, local(codex_toml), ":", sanitized(config))
+  } catch {
+    LOG.debug(`Failed loading Codex settings from`, local(codex_toml))
+    fromCodex.cached = null
+  }
+  return fromCodex.cached
+}
+
+function fromCodexAuth() {
+  const auth_json = path.join(HOME, ".codex/auth.json")
+  try {
+    let auth = JSON.parse(fs.readFileSync(auth_json, "utf8"))
+    // auth.json stores the key under OPENAI_API_KEY (or a custom env var name)
+    return auth?.OPENAI_API_KEY ?? null
+  } catch {
+    LOG.debug(`Failed loading Codex auth from`, local(auth_json))
+    return null
+  }
+}
+
+function fromOpencodeOpenAI() {
+  if ("cached" in fromOpencodeOpenAI) return fromOpencodeOpenAI.cached
+  const opencode_json = path.join(HOME, ".config/opencode/opencode.json")
+  try {
+    let conf = JSON.parse(fs.readFileSync(opencode_json, "utf8"))
+    LOG.debug(`Loaded OpenCode settings from`, local(opencode_json))
+    // https://opencode.ai/config.json
+    let o = conf?.provider?.openai?.options
+    if (!o) return (fromOpencodeOpenAI.cached = null)
+    let any,
+      config = {}
+    if ((any = o.baseURL ?? o.baseURL)) config.baseURL = any
+    if ((any = o.apiKey)) config.apiKey = any
+    if ((any = conf?.model)) config.model = any.replace("openai/", "")
+    fromOpencodeOpenAI.cached = Object.keys(config).length ? config : null
+    LOG.debug(
+      `Loaded config from`,
+      local(opencode_json),
+      ":",
+      sanitized(fromOpencodeOpenAI.cached || {}),
+    )
+  } catch {
+    LOG.debug(`Failed loading OpenCode settings from`, local(opencode_json))
+    fromOpencodeOpenAI.cached = null
+  }
+  return fromOpencodeOpenAI.cached
+}
+
 const sanitized = ({ apiKey, ...rest }) => ({
   ...rest,
   apiKey: apiKey ? "***" : undefined,

package/lib/eval/eval-run.js

@@ -5,6 +5,7 @@ import {
   createEvalRun,
   closeEvalRun,
   logMlflowMetrics,
+  logMlflowRunMetadata,
 } from "../telemetry/mlflow/evaluation.js"
 import { flushMlflowTraces } from "../telemetry/mlflow/tracing.js"
 
@@ -23,6 +24,9 @@ export function evalRun(opts = {}) {
       runId,
       mlflowRunId,
       validationsByTask: new Map(),
+      metricKeys: new Set(),
+      mlflowMetadataLogged: false,
+      prompts: [],
     }
   }
 
@@ -34,15 +38,22 @@ export function evalRun(opts = {}) {
   })
 
   if (typeof afterEach === "function") {
-    afterEach(async () => {
-      if (state) await _flushValidations(state)
+    afterEach(async (testState) => {
+      if (state) {
+        await _flushValidations(state)
+        // Report test failure/success, so aggregated output_correctness respects static asserts
+        _addValidation(
+          { _evalState: state, taskId: "code_asserts" },
+          testState.task.result.state === "pass",
+        )
+      }
     })
   }
 
   afterAll(async () => {
     if (state) await _flushValidations(state)
     await flushMlflowTraces()
-    await closeEvalRun(state?.mlflowRunId).catch(() => {})
+    await closeEvalRun(state).catch(() => {})
     if (cds._activeEvalRun === state) cds._activeEvalRun = null
     state = null
   })
@@ -148,5 +159,40 @@ async function _postAssessmentScore(result, score, comment, config) {
 export async function logMlflowMetricsForResult(result, state = null) {
   state = state ?? cds._activeEvalRun
   if (!state?.mlflowRunId) return
-  await logMlflowMetrics(state.mlflowRunId, result.metrics).catch(() => {})
+  state.prompts = state.prompts.concat(_extractPrompts(result?.spans))
+  await _logMlflowRunMetadataOnce(result, state)
+  await logMlflowMetrics(state, result.metrics).catch(() => {})
+}
+
+// REVISIT: Properly log models as Registered Models in an eval Run to cover the change that an eval run contains multiple models
+async function _logMlflowRunMetadataOnce(result, state) {
+  if (state.mlflowMetadataLogged) return
+  const metadata = _extractMlflowRunMetadata(result?.spans)
+  if (!metadata) return
+  state.mlflowMetadataLogged = true
+  await logMlflowRunMetadata(state.mlflowRunId, metadata).catch(() => {})
+}
+
+function _extractMlflowRunMetadata(spans) {
+  const attrs = spans?.find(
+    (span) => span.attributes?.["gen_ai.operation.name"] === "chat",
+  )?.attributes
+  if (!attrs) return null
+
+  const model = attrs["gen_ai.response.model"]
+  const provider = attrs["gen_ai.provider.name"]
+  const params =
+    attrs["gen_ai.request.model_params"] && JSON.parse(attrs["gen_ai.request.model_params"])
+
+  if (!model && !provider && !Object.keys(params).length) return null
+  return { model, provider, params }
+}
+
+function _extractPrompts(spans) {
+  const attrs = spans?.find(
+    (span) => span.attributes?.["gen_ai.operation.name"] === "invoke_agent",
+  )?.attributes
+  if (!attrs) return []
+  const prompts = JSON.parse(attrs["mlflow.traceTag.mlflow.linkedPrompts"]) ?? []
+  return prompts
 }