@cap-js/agents 0.9.4 → 0.9.6

package/lib/eval/eval-run.js

@@ -70,15 +70,20 @@ async function _flushValidations(state) {
       tasks.push(
         flushMlflowTraces().then(() =>
           Promise.all([
-            postMlflowAssessment(traceId, success_rate, "", "success_rate", null, codeOpts).catch(
-              () => {},
-            ),
+            postMlflowAssessment(
+              traceId,
+              success_rate,
+              "",
+              "success_rate",
+              "cap-js/agents",
+              codeOpts,
+            ).catch(() => {}),
             postMlflowAssessment(
               traceId,
               output_correctness,
               "",
               "output_correctness",
-              null,
+              "cap-js/agents",
               codeOpts,
             ).catch(() => {}),
           ]),
@@ -124,7 +129,7 @@ async function _postAssessmentScore(result, score, comment, config) {
       score,
       comment ?? "",
       config.assessmentName,
-      config.model ?? null,
+      config.model ?? config.assessmentName ?? "judge",
       { ...opts, metadata: { "mlflow.trace.session": config.sessionId ?? "" } },
     )
   } else {
@@ -134,7 +139,7 @@ async function _postAssessmentScore(result, score, comment, config) {
       score,
       comment ?? "",
       config.assessmentName,
-      config.model ?? null,
+      config.model ?? config.assessmentName ?? "judge",
       opts,
     )
   }

package/lib/index.js

@@ -15,6 +15,9 @@ import * as metrics from "./telemetry/metrics.js"
 
 const LOG = cds.log("agents")
 
+const TRUNCATE = cds.env.agents?.truncate || 111
+const truncated = (msg) => (msg?.length > TRUNCATE ? msg.slice(0, TRUNCATE) + "..." : msg)
+
 // SSE wire-format helpers, mirroring @a2a-js/sdk's sse_utils so the adapter
 // streams message/stream responses identically to the SDK's reference
 // Express handler. Inlined (not imported) because the SDK does not export
@@ -215,11 +218,10 @@ export default function A2AProtocolAdapter(srv, options = {}) {
     if (method === "message/send" || method === "message/stream") {
       const text = userText
 
-      const maxLen = cds.env.agents?.pool?.maxIncomingMessageLength
+      const maxLen = cds.env.agents?.quotas?.maxIncomingMessageLength
       if (maxLen > 0 && text?.length > maxLen) {
-        LOG.warn("message too long", {
+        LOG.warn(srv.name, "message too long", {
           conversation: short(contextId),
-          service: srv.name,
         })
         metrics.errorsTotal.add(1, { ...requestAttrs, "agent.error.code": 400 })
 
@@ -245,15 +247,13 @@ export default function A2AProtocolAdapter(srv, options = {}) {
         return
       }
 
-      const truncated = text?.length > 80 ? text.slice(0, 80) + "..." : text
-      LOG.info("request", {
+      LOG.info(srv.name, "request", {
         conversation: short(contextId),
-        service: srv.name,
         method,
-        text: truncated,
+        text: truncated(text),
       })
     } else {
-      LOG.debug("request", { conversation: short(contextId), service: srv.name, method })
+      LOG.debug(srv.name, "request", { conversation: short(contextId), method })
     }
 
     try {
@@ -264,9 +264,8 @@ export default function A2AProtocolAdapter(srv, options = {}) {
           await import("./agents/quota-enforcer-at-start.js")
         const quotaResult = await quotaEnforcerAtStart()
         if (quotaResult) {
-          LOG.warn("quota exceeded", {
+          LOG.warn(srv.name, "quota exceeded", {
             conversation: short(contextId),
-            service: srv.name,
             reason: quotaResult.message,
           })
           metrics.errorsTotal.add(1, { ...requestAttrs, "agent.error.code": 429 })
@@ -416,8 +415,6 @@ export default function A2AProtocolAdapter(srv, options = {}) {
       })
   })
 
-  LOG.debug("Adapter initialized", { service: srv.name })
-
   router.router = router
   return router
 }

package/lib/models/aicore.js

@@ -2,24 +2,53 @@ import cds from "@sap/cds"
 import { OrchestrationClient } from "@sap-ai-sdk/langchain"
 import { circuitBreaker, timeout } from "../utils/resilience.js"
 
-import { SystemMessage, ToolMessage, HumanMessage, AIMessage } from "@langchain/core/messages"
+import { SystemMessage, ToolMessage, AIMessage } from "@langchain/core/messages"
 import { ms4 } from "../utils/utils.js"
+import {
+  isPromptCachingModel,
+  PROMPT_CACHE_MODEL_PARAMS,
+  withPromptCachingMessages,
+  withPromptCachingOptions,
+  withPromptCachingParams,
+} from "../utils/caching.js"
 import { syncSystemPrompt } from "../telemetry/mlflow/prompts.js"
 
 const LOG = cds.log("agents")
 const DEFAULT_STREAM_DELIMITERS = [".", "!", "?"]
 
+function noTemp0Support(model) {
+  switch (model) {
+    case "gpt-5.6-sol":
+    case "gpt-5.6-luna":
+    case "gpt-5.6-terra":
+    case "gpt-6-astra":
+      return true
+    default:
+      return false
+  }
+}
+
+const llmError = (err) => {
+  LOG.error(`AI Core request failed!`, err.rootCause || err)
+  cds.error(cds.i18n.messages.at("LLM_UNAVAILABLE"))
+}
+
 class _InstrumentedOrchestrationClient extends OrchestrationClient {
   constructor(name, options) {
     const { model, deepAgent, streaming, destinationName, resourceGroup } = options
     const flatten = options.flatten ?? (deepAgent ? true : false)
 
-    // Restore pre-72ef6fa params resolution: caller > deep-agent default > root
+    // params resolution: caller > deep-agent default > root
     // cds.env.agents.params. Without this, AI Core silently applies its own
     // defaults (temperature ≈ 1, verbose model → repeated max_tokens truncation
-    // and extra ReAct iterations — see PR #188 review).
-    const params =
+    // and extra ReAct iterations).
+    const rawParams =
       options.params || (deepAgent ? { max_tokens: 4096, temperature: 0 } : cds.env.agents?.params)
+    const params = withPromptCachingParams(model, rawParams)
+    if (params.temperature === 0 && noTemp0Support(model)) {
+      delete params.temperature
+    }
+
     const auditParams = params && typeof params === "object" ? { ...params } : params
 
     LOG.debug("Initializing LLM", { model, deepAgent: !!deepAgent })
@@ -65,14 +94,24 @@ class _InstrumentedOrchestrationClient extends OrchestrationClient {
       destination,
     )
     this.name = name
-    this.options = { ...options, params: auditParams, contentFilter, flatten }
+    this.options = {
+      ...options,
+      params: auditParams,
+      contentFilter,
+      flatten,
+      promptCaching: isPromptCachingModel(model),
+    }
   }
 
   async _generate(messages, opts, runManager) {
     const { model, flatten } = this.options
     opts = _withMiddleware(this, opts)
     const prepared = _prepareMessages(messages, { flatten, model, opts })
-    return super._generate(prepared.inputMessages, prepared.opts, runManager)
+    try {
+      return super._generate(prepared.inputMessages, prepared.opts, runManager)
+    } catch (err) {
+      llmError(err)
+    }
   }
 
   /**
@@ -80,8 +119,8 @@ class _InstrumentedOrchestrationClient extends OrchestrationClient {
    *
    * 1. Message flattening / normalization — same as _generate: content arrays
    *    must be reduced to text before reaching AI Core's assistant template.
-   * 2. Claude prompt caching — injectCacheControl must run here too, or
-   *    cache_control is silently skipped on the streaming path.
+   * 2. Prompt caching options — same as _generate, or caching is skipped on
+   *    the streaming path.
    * 3. Content extraction — @sap-ai-sdk/langchain getDeltaContent() only handles
    *    string deltas; Anthropic streams content-block arrays (and reasoning in a
    *    sibling field), so we re-extract and re-emit them via buildStreamBlocks().
@@ -94,17 +133,44 @@ class _InstrumentedOrchestrationClient extends OrchestrationClient {
     opts = withDefaultStreamDelimiters(prepared.opts)
 
     let turnHasToolCall = false
-    for await (const chunk of super._streamResponseChunks(inputMessages, opts, runManager)) {
-      if (chunk.message?.tool_call_chunks?.length > 0) turnHasToolCall = true
-      const text = chunk.text || extractTextFromContentBlocks(chunk)
-      const reasoning = extractReasoningFromChunk(chunk)
-      const blocks = buildStreamBlocks(text, reasoning, turnHasToolCall)
-
-      if (!blocks.length && !(text && turnHasToolCall)) {
-        yield chunk
-        continue
+    try {
+      for await (const chunk of super._streamResponseChunks(inputMessages, opts, runManager)) {
+        if (chunk.message?.tool_call_chunks?.length > 0) turnHasToolCall = true
+        const text = chunk.text || extractTextFromContentBlocks(chunk)
+        const reasoning = extractReasoningFromChunk(chunk)
+        const blocks = buildStreamBlocks(text, reasoning, turnHasToolCall)
+
+        if (!blocks.length && !(text && turnHasToolCall)) {
+          yield chunk
+          continue
+        }
+        yield patchChunkContent(chunk, blocks)
       }
-      yield patchChunkContent(chunk, blocks)
+    } catch (err) {
+      llmError(err)
+    }
+  }
+
+  mergeOrchestrationConfig(orchestrationConfig, options) {
+    const config = super.mergeOrchestrationConfig(orchestrationConfig, options)
+    const modelParams = options?.[PROMPT_CACHE_MODEL_PARAMS]
+    if (!modelParams) return config
+    const currentParams = config.promptTemplating?.model?.params || {}
+    const nextParams = { ...modelParams }
+    if (currentParams.prompt_cache_key !== undefined) delete nextParams.prompt_cache_key
+    if (!Object.keys(nextParams).length) return config
+    return {
+      ...config,
+      promptTemplating: {
+        ...config.promptTemplating,
+        model: {
+          ...config.promptTemplating?.model,
+          params: {
+            ...currentParams,
+            ...nextParams,
+          },
+        },
+      },
     }
   }
 }
@@ -113,15 +179,11 @@ export default _InstrumentedOrchestrationClient
 
 // ─── SDK helpers ─────────────────────────────────────────────────────────────
 
-function isClaude(model) {
-  return /anthropic|claude/i.test(model || "")
-}
-
 /**
  * Inject timeout and circuit breaker middleware into opts.
  */
 function _withMiddleware(instance, opts) {
-  const llmTimeout = ms4(cds.env.agents?.pool?.maxLLMCallTimeout || "120s")
+  const llmTimeout = ms4(cds.env.agents?.quotas?.maxLLMCallTimeout || "120s")
   const middleware = [timeout(llmTimeout), circuitBreaker()]
   return {
     ...opts,
@@ -130,23 +192,16 @@ function _withMiddleware(instance, opts) {
 }
 
 /**
- * Prepare input messages: flatten, normalize assistant content, inject cache_control.
- * Returns { inputMessages, opts } (opts may be mutated with cache_control on last tool).
+ * Prepare input messages: flatten, normalize assistant content, and set prompt
+ * caching call options/model params.
  */
 function _prepareMessages(messages, { flatten, model, opts }) {
   let inputMessages = flatten ? flattenMessages(messages) : messages
   inputMessages = normalizeAssistantContent(inputMessages)
-  if (isClaude(model)) {
-    inputMessages = injectCacheControl(inputMessages)
-    if (opts?.tools?.length > 0) {
-      const tools = [...opts.tools]
-      tools[tools.length - 1] = {
-        ...tools[tools.length - 1],
-        cache_control: CACHE_CONTROL_EPHEMERAL,
-      }
-      opts = { ...opts, tools }
-    }
-  }
+  const cached = withPromptCachingMessages(model, inputMessages, opts)
+  inputMessages = cached.messages
+  opts = cached.opts
+  opts = withPromptCachingOptions(model, opts)
   syncSystemPrompt(inputMessages)
   return { inputMessages, opts }
 }
@@ -164,97 +219,6 @@ export function withDefaultStreamDelimiters(opts = {}) {
   }
 }
 
-// Claude currently only supports caching of type ephemeral. TTL can differ between 5min or 1h but
-// we use the 5min default
-const CACHE_CONTROL_EPHEMERAL = { type: "ephemeral" }
-
-/**
- * Marks: all system messages, the last AI message (with text content), and the last human message.
- * Converts string content to content-block arrays where needed so cache_control
- * can be attached per the Anthropic/SAP AI Core API format.
- */
-function injectCacheControl(messages) {
-  if (!messages || messages.length === 0) return messages
-
-  const result = messages.map((m) => {
-    // Clone to avoid mutating original
-    if (m._getType?.() === "system" || m.type === "system") {
-      return _withCacheControl(m)
-    }
-    return m
-  })
-  // Mark last AI message with non-empty text content (stable breakpoint for multi-turn)
-  for (let i = result.length - 1; i >= 0; i--) {
-    const type = result[i]._getType?.() || result[i].type
-    if (type === "ai" && _hasTextContent(result[i])) {
-      result[i] = _withCacheControl(result[i])
-      break
-    }
-  }
-  // Mark last human message
-  for (let i = result.length - 1; i >= 0; i--) {
-    const type = result[i]._getType?.() || result[i].type
-    if (type === "human") {
-      result[i] = _withCacheControl(result[i])
-      break
-    }
-  }
-  return result
-}
-
-/**
- * Check if a message has non-empty text content (not just tool_calls).
- */
-function _hasTextContent(msg) {
-  const content = msg.content
-  if (typeof content === "string") return content.length > 0
-  if (Array.isArray(content)) return content.some((b) => b.type === "text" && b.text?.length > 0)
-  return false
-}
-
-/**
- * If content is a string, convert to [{type:"text", text, cache_control}].
- * If content is an array, add cache_control to the last text block.
- */
-function _withCacheControl(msg) {
-  const content = msg.content
-  if (typeof content === "string") {
-    // Convert to content blocks with cache_control on the block
-    const newContent = [{ type: "text", text: content, cache_control: CACHE_CONTROL_EPHEMERAL }]
-    return _cloneMessageWithContent(msg, newContent)
-  }
-  if (Array.isArray(content) && content.length > 0) {
-    const newContent = [...content]
-    // Find last text block and add cache_control
-    for (let i = newContent.length - 1; i >= 0; i--) {
-      if (newContent[i].type === "text") {
-        newContent[i] = { ...newContent[i], cache_control: CACHE_CONTROL_EPHEMERAL }
-        break
-      }
-    }
-    return _cloneMessageWithContent(msg, newContent)
-  }
-  return msg
-}
-
-function _cloneMessageWithContent(msg, newContent) {
-  const type = msg._getType?.() || msg.type
-  if (type === "system") {
-    return new SystemMessage({ content: newContent })
-  }
-  if (type === "ai") {
-    return new AIMessage({ content: newContent, tool_calls: msg.tool_calls })
-  }
-  if (type === "human") {
-    return new HumanMessage({ content: newContent })
-  }
-  if (type === "tool") {
-    return new ToolMessage({ content: newContent, tool_call_id: msg.tool_call_id, name: msg.name })
-  }
-  // Fallback: shallow clone with new content
-  return { ...msg, content: newContent }
-}
-
 export function flattenMessages(messages) {
   return messages.map((m) => {
     if (!Array.isArray(m.content)) return m

package/lib/models/anthropic.js

@@ -1,92 +1,20 @@
 import { ChatAnthropic } from '@langchain/anthropic'
-import path from 'node:path'
-import fs from 'node:fs'
-import os from 'node:os'
-import cds from '@sap/cds'
+import { withPromptCachingMessages } from '../utils/caching.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
- */
 export default class ChatAnthropicService extends ChatAnthropic {
-  constructor (name, options) {
-    let config = { ...options, ...options?.credentials, ...fromEnv() }
-    if (!config.anthropicApiUrl) config = {
-      ...fromClaude() || fromOpencode(),
-      ...config
-    }
-    if (LOG._debug) {
-      const { kind, model, anthropicApiUrl, apiKey } = config
-      LOG.info (`Using effective config:`, {
-        kind,
-        model,
-        credentials: {
-          anthropicApiUrl,
-          apiKey: apiKey ? '***' : undefined
-        }
-      })
-    }
-    super (config)
+  constructor (name, options = {}) {
+    const { credentials = {} } = options
+    super ({ ...credentials, ...options })
     this.name = name
-    this.options = config
   }
-}
-
-function fromEnv (env = process.env, silent) {
-  let any, config = {}
-  if ((any = env.ANTHROPIC_BASE_URL)) config.anthropicApiUrl = any
-  if ((any = env.ANTHROPIC_AUTH_TOKEN)) config.apiKey = any
-  if ((any = env.ANTHROPIC_API_KEY)) config.apiKey = any
-  if ((any = env.ANTHROPIC_MODEL)) config.model = any
-  if (!Object.keys(config).length) return null
-  if (!silent) LOG.debug (`Loaded Anthropic settings from env:`, config)
-  return config
-}
-
-function fromClaude() {
-  if ('cached' in fromClaude) return fromClaude.cached
-  const settings_json = path.join (HOME,'.claude/settings.json')
-  try {
-    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')
-    if (!conf.model && settings.env) {
-      let family = (settings.model||'sonnet').toUpperCase()
-      conf.model = settings.env[`ANTHROPIC_DEFAULT_${family}_MODEL`] || settings?.model
-    }
-    LOG.debug(`Loaded Claude settings from`, local(settings_json), ':', conf)
-  } catch {
-    LOG.debug(`Failed loading Claude settings from`, local(settings_json))
-    fromClaude.cached = null
+  async _generate (messages, options, runManager) {
+    const cached = withPromptCachingMessages(this.model, messages, options)
+    return super._generate(cached.messages, cached.opts, runManager)
   }
-  return fromClaude.cached
-}
 
-function fromOpencode() {
-  if ('cached' in fromOpencode) return fromOpencode.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?.anthropic?.options
-    if (!o) return fromOpencode.cached = null
-    let any, config = {}
-    if ((any = o.anthropicApiUrl ?? o.apiUrl ?? o.baseURL)) config.anthropicApiUrl = any.replace(/\/v1$/,'') // opencode expects the versioned baseUrl, others do not
-    if ((any = o.anthropicApiKey ?? o.apiKey)) config.apiKey = any
-    if ((any = conf?.model)) config.model = any.replace('anthropic/','')
-    fromOpencode.cached = Object.keys(config).length ? config : null
-    LOG.debug(`Loaded OpenCode settings from`, local(opencode_json), ':', conf)
-  } catch {
-    LOG.debug(`Failed loading OpenCode settings from`, local(opencode_json))
-    fromOpencode.cached = null
+  async *_streamResponseChunks (messages, options, runManager) {
+    const cached = withPromptCachingMessages(this.model, messages, options)
+    yield* super._streamResponseChunks(cached.messages, cached.opts, runManager)
   }
-  return fromOpencode.cached
 }

package/lib/preview/chat.html

@@ -115,7 +115,6 @@
         color: #1d3e5a;
         border-bottom-left-radius: 3px;
         border-left: 3px solid #537492;
-        white-space: pre-wrap;
       }
       .msg.approval::before {
         content: "Action Required";
@@ -127,6 +126,15 @@
         letter-spacing: 0.03em;
         text-transform: uppercase;
       }
+      .msg.approval pre {
+        margin: 8px 0 0;
+        padding: 8px;
+        overflow-x: auto;
+        border-radius: 6px;
+        background: #e7f4ff;
+        font-size: 1.1em;
+        white-space: pre;
+      }
 
       .msg.agent p {
         margin: 0 0 6px;
@@ -372,6 +380,9 @@
         .msg.approval::before {
           color: #91adc5;
         }
+        .msg.approval pre {
+          background: #0f2d45;
+        }
         .btn-approve {
           background: #537492;
         }
@@ -811,31 +822,41 @@
         setTimeout(finish, THINKING_SUMMARY_ANIMATION_MS + 80)
       }
 
-      function addApprovalPrompt(description) {
+      function addApprovalPrompt(description, options, actionRequest) {
         const el = document.createElement("div")
         el.className = "msg approval"
-        el.textContent = description || "The agent requires your approval to continue."
+        const content = document.createElement("div")
+        content.textContent = actionRequest?.name
+          ? `Tool execution requires approval\n\nTool: ${actionRequest.name}`
+          : description || "The agent requires your approval to continue."
+        el.appendChild(content)
+        content.innerHTML = md(content.textContent)
+        if (actionRequest?.args !== undefined) {
+          const json = document.createElement("pre")
+          json.textContent = JSON.stringify(actionRequest.args, null, 2)
+          el.appendChild(json)
+        }
         const actions = document.createElement("div")
         actions.className = "approval-actions"
 
-        const approveBtn = document.createElement("button")
-        approveBtn.className = "btn-approve"
-        approveBtn.textContent = "Approve"
-        approveBtn.addEventListener("click", () => {
-          removeApprovalPrompt(el)
-          resume("approve")
-        })
-
-        const rejectBtn = document.createElement("button")
-        rejectBtn.className = "btn-reject"
-        rejectBtn.textContent = "Reject"
-        rejectBtn.addEventListener("click", () => {
-          removeApprovalPrompt(el)
-          resume("reject")
-        })
-
-        actions.appendChild(approveBtn)
-        actions.appendChild(rejectBtn)
+        const choices =
+          Array.isArray(options) && options.length
+            ? options
+            : [
+                { value: "approve", label: "Approve" },
+                { value: "reject", label: "Reject" },
+              ]
+        for (const option of choices) {
+          if (typeof option?.value !== "string" || typeof option?.label !== "string") continue
+          const button = document.createElement("button")
+          button.className = option.value === "reject" ? "btn-reject" : "btn-approve"
+          button.textContent = option.label
+          button.addEventListener("click", () => {
+            removeApprovalPrompt(el)
+            resume(option.value)
+          })
+          actions.appendChild(button)
+        }
         el.appendChild(actions)
         messages.insertBefore(el, typing.parentElement === messages ? typing : statusText)
         messages.scrollTop = messages.scrollHeight
@@ -927,8 +948,12 @@
           pendingTaskId = taskId
           const msgParts = result?.status?.message?.parts ?? []
           const description = partsToText(msgParts)
+          const options =
+            result?.status?.message?.metadata?.["sap.cds.agents.input-required"]?.options
+          const actionRequest = msgParts.find((part) => part.kind === "data")?.data
+            ?.actionRequests?.[0]
           flushPendingThinkingUpdate()
-          addApprovalPrompt(description)
+          addApprovalPrompt(description, options, actionRequest)
           return
         }
 

package/lib/protocol/agent-card.js

@@ -1,12 +1,8 @@
 import cds from "@sap/cds"
 import { createRequire } from "node:module"
 const { path } = cds.utils
-import {
-  getDescription,
-  getFilteredEntities,
-  getFilteredActions,
-  slugified,
-} from "../utils/utils.js"
+import { getFilteredEntities, getFilteredActions } from "@cap-js/mcp/lib/utils/tools-shared.js"
+import { getDescription, slugified } from "../utils/utils.js"
 import {
   scanSkills,
   parseAgentMetadata,

package/lib/telemetry/chat-tracing.js

@@ -62,7 +62,7 @@ export function _patchChatModelProto(proto) {
     const provider = _resolveProvider()
     const node = opts?.runName || "agent"
     const messages = Array.isArray(input) ? input : undefined
-    const cacheControl = _detectCacheControl(messages)
+    const cacheControl = _detectCacheRequest({ messages, opts, modelOptions: this.options })
     const streaming = this.streaming || this.orchestrationConfig?.streaming || false
     const mAttrs = _metricAttrs(model, node)
 
@@ -162,8 +162,18 @@ function _metricAttrs(model, node) {
   }
 }
 
-/** Detect cache_control presence in messages (set by injectCacheControl in aicore). */
-function _detectCacheControl(messages) {
+function _detectCacheRequest({ messages, opts, modelOptions }) {
+  const params = modelOptions?.params
+  return Boolean(
+    _messagesHaveCacheControl(messages) ||
+    opts?.cache_control ||
+    modelOptions?.promptCaching ||
+    params?.prompt_cache_retention ||
+    params?.prompt_cache_options,
+  )
+}
+
+function _messagesHaveCacheControl(messages) {
   if (!Array.isArray(messages)) return false
   return messages.some((m) => {
     if (!Array.isArray(m.content)) return false

package/lib/telemetry/metrics.js

@@ -53,6 +53,12 @@ export const llmInvocations = meter.createCounter("agent.llm.invocations", {
 export const toolInvocations = meter.createCounter("agent.tool.invocations", {
   description: "Tool invocation count",
 })
+export const hitlGates = meter.createCounter("agent.hitl.gates", {
+  description: "HITL action gates requested",
+})
+export const hitlDecisions = meter.createCounter("agent.hitl.decisions", {
+  description: "HITL decisions by action",
+})
 
 /** Common attributes for all agent metrics */
 export function attrs(srv) {