@agent-native/core 0.96.0 → 0.98.0

package/dist/agent/production-agent.js

@@ -10,6 +10,7 @@ import { preUploadAttachments } from "../file-upload/pre-upload-attachments.js";
 import { isMcpActionResult } from "../mcp-client/app-result.js";
 import { extractMcpToolResultImages } from "../mcp-client/index.js";
 import { isMcpToolAllowedForRequest } from "../mcp-client/visibility.js";
+import { shouldInferSentimentForTurn } from "../observability/sentiment.js";
 import { completeRun as completeProgressRun, startRun as startProgressRun, updateRunProgress, } from "../progress/registry.js";
 import { getFrontmatterValue, parseFrontmatter, } from "../resources/metadata.js";
 import { canUseDeployCredentialFallbackForRequest, getProviderCredentialAuthFailure, readDeployCredentialEnv, } from "../server/credential-provider.js";
@@ -18,24 +19,23 @@ import { getRequestRunContext, ensureRequestRunContext, getRequestContext, getRe
 import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { isReasoningEffort, normalizeReasoningEffortForRequest, stepDownReasoningEffort, } from "../shared/reasoning-effort.js";
 import { actionPreparationContinuationNote } from "./action-continuation-guidance.js";
-import { applyContextDirectives } from "./context-xray/apply-directives.js";
-import { loadContextDirectives } from "./context-xray/directives-store.js";
-import { buildManifest, writeContextManifest, } from "./context-xray/manifest.js";
-import { computeProtectedSegmentIds } from "./context-xray/segments.js";
 import { AGENT_CHAT_BACKGROUND_RUN_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, backgroundRuntimeDiagnosticDetail, dispatchPathTargetsNetlifyBackgroundFunction, isAgentChatDurableBackgroundEnabled, isAgentChatForegroundSelfChainEnabled, resolveAgentChatProcessRunDispatchPath, shouldUseBackgroundFunctionTimeoutForWorker, } from "./durable-background.js";
+import { applyContextXrayTransformForIteration } from "./engine/context-directives-transform.js";
+import { attemptContinuationDispatch } from "./engine/continuation-dispatch-retry.js";
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, userFacingLlmCredentialError, } from "./engine/credential-errors.js";
 import { resolveEngine, registerBuiltinEngines, getStoredModelForEngine, normalizeModelForEngine, isResolvedEngineUsableForRequest, } from "./engine/index.js";
 import { resolveEmptyResponseRetryMaxOutputTokens, resolveMainChatMaxOutputTokens, resolveMaxOutputTokensForEngine, } from "./engine/output-tokens.js";
 import { PROVIDER_TO_ENV } from "./engine/provider-env-vars.js";
+import { loadPriorTurnToolCallJournal } from "./engine/tool-call-journal-seed.js";
 import { backfillEngineMessagesToolResults, stringifyToolUseInputForGateway, unmatchedToolResultReplayText, } from "./engine/translate-anthropic.js";
 import { EngineError } from "./engine/types.js";
 import { getDefaultMaxIterations, MAX_AGENT_MAX_ITERATIONS, MIN_AGENT_MAX_ITERATIONS, normalizeMaxIterations, readAgentLoopSettings, } from "./loop-settings.js";
 import { maybeCompactThread, buildObservationalContext, hasObservationalMemory, serializeObservationalMemoryBlock, } from "./observational-memory/index.js";
 import { ProcessorChain, TripWire, toolCallsFromContent, } from "./processors.js";
 import { startRun, subscribeToRun, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, tryClaimRunSlot, } from "./run-manager.js";
-import { writeLedgerEntry, readLedgerEntry, clearLedgerForThread, getCurrentTurnEventsForThread, insertRun, updateRunHeartbeat, updateRunStatusIfRunning, setRunError, setRunTerminalReason, claimBackgroundRun, readBackgroundRunClaim, recordRunDiagnostic, countRunsForTurn, RUN_DIAG_STAGE, UNCLAIMED_BACKGROUND_RUN_GRACE_MS, } from "./run-store.js";
+import { writeLedgerEntry, readLedgerEntry, clearLedgerForThread, insertRun, updateRunHeartbeat, updateRunStatusIfRunning, setRunError, setRunTerminalReason, claimBackgroundRun, readBackgroundRunClaim, recordRunDiagnostic, countRunsForTurn, RUN_DIAG_STAGE, UNCLAIMED_BACKGROUND_RUN_GRACE_MS, } from "./run-store.js";
 import { buildCurrentTimeUserContext } from "./runtime-context.js";
-import { classifyToolCallJournal, findCompletedJournalEntry, } from "./tool-call-journal.js";
+import { findCompletedJournalEntry } from "./tool-call-journal.js";
 import { redactSensitiveFields, sanitizeToolErrorText, sanitizeToolErrorValue, } from "./tool-error-redaction.js";
 import { describeToolResultImages, extractAgentImagesFromActionResult, } from "./tool-result-images.js";
 import { createToolSearchEntry, TOOL_SEARCH_ACTION_NAME, } from "./tool-search.js";
@@ -597,6 +597,7 @@ const RUN_BUDGET_EXHAUSTED_MESSAGE = "I ran out of time before finishing this st
     "I stopped rather than keep retrying silently. " +
     "Check any completed tool cards above before retrying, ideally as one smaller follow-up.";
 const MAX_TEXT_ATTACHMENT_CHARS = 60_000;
+const MAX_TEXT_ATTACHMENTS_TOTAL_CHARS = 80_000;
 const MAX_SELECTION_CONTEXT_CHARS = 8_000;
 const MAX_RESOURCE_INVENTORY_ITEMS = 40;
 const MAX_RESOURCE_INVENTORY_DESCRIPTION_CHARS = 160;
@@ -817,19 +818,22 @@ function unwrapTextAttachmentEnvelope(text) {
     const match = text.match(/^<attachment\b[^>]*>\n([\s\S]*)\n<\/attachment>$/);
     return match ? match[1] : text;
 }
-function truncateTextAttachment(text, attachmentName) {
-    if (text.length <= MAX_TEXT_ATTACHMENT_CHARS)
+function truncateTextAttachment(text, attachmentName, maxChars = MAX_TEXT_ATTACHMENT_CHARS) {
+    if (text.length <= maxChars)
         return text;
-    const omitted = text.length - MAX_TEXT_ATTACHMENT_CHARS;
+    const omitted = text.length - maxChars;
     const readHint = attachmentName
         ? ` Use the \`read-attachment\` tool with name="${escapeAttachmentAttribute(attachmentName)}" to read the rest.`
         : "";
-    return `${text.slice(0, MAX_TEXT_ATTACHMENT_CHARS)}\n\n[Attachment truncated after ${MAX_TEXT_ATTACHMENT_CHARS.toLocaleString()} characters; ${omitted.toLocaleString()} characters omitted.${readHint}]`;
+    if (maxChars === 0) {
+        return `[Attachment content omitted from the initial request; ${omitted.toLocaleString()} characters available.${readHint}]`;
+    }
+    return `${text.slice(0, maxChars)}\n\n[Attachment truncated after ${maxChars.toLocaleString()} characters; ${omitted.toLocaleString()} characters omitted.${readHint}]`;
 }
-function formatTextAttachment(att) {
+function formatTextAttachment(att, maxChars = MAX_TEXT_ATTACHMENT_CHARS) {
     if (typeof att.text !== "string" || att.text.length === 0)
         return null;
-    const text = truncateTextAttachment(unwrapTextAttachmentEnvelope(att.text), att.name);
+    const text = truncateTextAttachment(unwrapTextAttachmentEnvelope(att.text), att.name, maxChars);
     const attrs = [
         `name="${escapeAttachmentAttribute(att.name || "attachment")}"`,
         att.contentType
@@ -855,6 +859,7 @@ function dataUrlToFilePart(att) {
 export function buildUserContentWithAttachments(opts) {
     const userContent = [];
     const textAttachments = [];
+    let remainingTextAttachmentChars = MAX_TEXT_ATTACHMENTS_TOTAL_CHARS;
     for (const att of opts.attachments ?? []) {
         const uploadedUrl = att.url;
         if (att.referenceOnly === true && uploadedUrl) {
@@ -907,9 +912,14 @@ export function buildUserContentWithAttachments(opts) {
             userContent.push(filePart);
             continue;
         }
-        const textAttachment = formatTextAttachment(att);
+        const rawTextAttachment = typeof att.text === "string"
+            ? unwrapTextAttachmentEnvelope(att.text)
+            : "";
+        const attachmentCharBudget = Math.min(MAX_TEXT_ATTACHMENT_CHARS, remainingTextAttachmentChars);
+        const textAttachment = formatTextAttachment(att, attachmentCharBudget);
         if (textAttachment) {
             textAttachments.push(textAttachment);
+            remainingTextAttachmentChars -= Math.min(rawTextAttachment.length, attachmentCharBudget);
         }
     }
     userContent.push({
@@ -1623,61 +1633,32 @@ export function filterInitialEngineTools(tools, initialToolNames) {
     const names = new Set(initialToolNames);
     names.add(TOOL_SEARCH_ACTION_NAME);
     for (const tool of tools) {
-        if (isDefaultLeanInitialToolName(tool.name)) {
+        if (isDefaultInitialToolName(tool.name)) {
             names.add(tool.name);
         }
     }
     return tools.filter((tool) => names.has(tool.name));
 }
-const DEFAULT_LEAN_INITIAL_TOOL_NAMES = new Set([
-    // Broad provider/API/corpus primitives should be callable as soon as the
-    // prompt teaches them; waiting for a discovery round-trip caused prod runs to
-    // waste turns on provider work that was described but not loaded.
-    "data-source-status",
-    "provider-api-catalog",
-    "provider-api-docs",
-    "provider-api-request",
-    "provider-corpus-job",
-    "provider-corpus-jobs",
-    "query-staged-dataset",
-    "list-staged-datasets",
-    "delete-staged-dataset",
-    "run-code",
-    "get-code-execution",
-    "list-extensions",
-    "get-extension",
-    "update-extension",
-    "list-extension-history",
-    "get-extension-history-version",
-    // Common first-class integration shortcuts. These are included only when the
-    // current app/mode registry actually exposes them.
-    "bigquery",
-    "search-bigquery-schema",
-    "bigquery-table-info",
-    "ga4",
-    "amplitude",
-    "prometheus",
-    "grafana",
-    "sentry",
-    "stripe",
-    "account-deep-dive",
-    "slack-messages",
-    "hubspot-deals",
-    "hubspot-records",
-    "hubspot-pipelines",
-    "hubspot-metrics",
-    "gong-calls",
-    "github-repo-files",
-    "jira",
-    "jira-search",
-    "gcloud",
-    "notion-search",
-    "pylon-search",
+export function buildFirstRequestPayloadDetail(input) {
+    if (!input.isFirstRequest)
+        return "";
+    return (` first_request_system_chars=${input.systemPrompt.length}` +
+        ` first_request_message_chars=${JSON.stringify(input.messages).length}` +
+        ` first_request_tool_count=${input.tools.length}` +
+        ` first_request_tool_chars=${JSON.stringify(input.tools).length}` +
+        ` first_request_available_tool_count=${input.availableToolCount}`);
+}
+const DEFAULT_INITIAL_TOOL_NAMES = new Set([
+    // Keep only the small discovery/runtime surface universal. App actions are
+    // supplied by the plugin's effective starter list, while provider, MCP,
+    // extension, and other uncommon schemas stay reachable through tool-search.
+    "resources",
+    "docs-search",
+    "get-framework-context",
+    "read-attachment",
 ]);
-function isDefaultLeanInitialToolName(name) {
-    if (DEFAULT_LEAN_INITIAL_TOOL_NAMES.has(name))
-        return true;
-    return (name.startsWith("provider-api-") || name.startsWith("provider-corpus-"));
+function isDefaultInitialToolName(name) {
+    return DEFAULT_INITIAL_TOOL_NAMES.has(name);
 }
 function extractToolSearchResultNames(value) {
     if (!value || typeof value !== "object")
@@ -2081,50 +2062,15 @@ export async function runAgentLoop(opts) {
     const duplicateReadOnlyToolCalls = new Map();
     const writeToolInterruptions = seedWriteToolInterruptionsFromHistory(messages, actions);
     const repeatedToolErrors = new Map();
-    // Tool-call journal hard-block (resume safety). Snapshot the per-turn journal
-    // ONCE here, before any tool runs in this chunk, so it reflects only PRIOR
-    // run chunks of this logical turn. A write tool whose exact call already
-    // completed in an earlier interrupted chunk must not re-fire its side effect;
-    // when matched, runToolCall returns the journaled result instead of executing.
-    // Loaded eagerly (not lazily mid-loop) so the current chunk's own
-    // asynchronously-persisted tool_done events can never leak in and make a
-    // same-chunk call wrongly short-circuit. Best-effort: any ledger failure
-    // leaves the journal empty and all calls run normally. Fresh first-turn calls
-    // see an empty journal and are unaffected.
-    let toolCallJournal = null;
+    // Tool-call journal hard-block (resume safety). See
+    // `loadPriorTurnToolCallJournal` for the full rationale — snapshotted ONCE
+    // here, before any tool runs in this chunk, and its prior-chunk tool
+    // calls/results are folded into `toolCallHistory` / `toolResultHistory` so
+    // final response guards see evidence from earlier chunks of this turn.
     const consumedJournalKeys = new Set();
-    if (opts.threadId) {
-        try {
-            const priorEvents = await getCurrentTurnEventsForThread(opts.threadId);
-            if (priorEvents.length > 0) {
-                // A logical turn can span multiple background continuation runs. Final
-                // response guards must see successful reads from earlier chunks, not
-                // only tools executed after the latest handoff. Otherwise a guard can
-                // reject a grounded answer (or a successfully-created artifact) after
-                // the evidence-producing query completed in a predecessor run.
-                for (const event of priorEvents) {
-                    if (event.type === "tool_start") {
-                        toolCallHistory.push({
-                            name: event.tool,
-                            input: event.input,
-                        });
-                    }
-                    else if (event.type === "tool_done") {
-                        toolResultHistory.push({
-                            name: event.tool,
-                            content: event.result,
-                            isError: event.isError === true,
-                        });
-                    }
-                }
-                toolCallJournal = classifyToolCallJournal(priorEvents);
-            }
-        }
-        catch {
-            // Journal is a hardening layer, never a gate — a failed ledger read just
-            // means no hard-block this turn.
-        }
-    }
+    const { toolCallJournal, priorToolCalls: journaledPriorToolCalls, priorToolResults: journaledPriorToolResults, } = await loadPriorTurnToolCallJournal(opts.threadId);
+    toolCallHistory.push(...journaledPriorToolCalls);
+    toolResultHistory.push(...journaledPriorToolResults);
     let finalGuardRetries = 0;
     let emptyFinalResponseRetries = 0;
     let iterations = 0;
@@ -2164,34 +2110,13 @@ export async function runAgentLoop(opts) {
         const toolCallErrors = new Map();
         let contextMessages = messages;
         if (opts.threadId) {
-            try {
-                const directives = await loadContextDirectives(opts.threadId, {
-                    ownerEmail: opts.ownerEmail ?? null,
-                });
-                const protectedSegmentIds = computeProtectedSegmentIds(messages);
-                const { messages: transformedMessages, appliedStatus } = applyContextDirectives(messages, directives, {
-                    protectedSegmentIds,
-                });
-                const manifest = await buildManifest({
-                    threadId: opts.threadId,
-                    ...(opts.turnId ? { turnId: opts.turnId } : {}),
-                    model,
-                    rawMessages: messages,
-                    sentMessages: transformedMessages,
-                    appliedStatus,
-                    directives,
-                    protectedSegmentIds,
-                    source: "structured",
-                    enforceable: true,
-                });
-                contextMessages = transformedMessages;
-                void writeContextManifest(opts.threadId, manifest).catch((err) => {
-                    console.warn("[context-xray] failed to write manifest:", err instanceof Error ? err.message : String(err));
-                });
-            }
-            catch (err) {
-                console.warn("[context-xray] context transform skipped:", err instanceof Error ? err.message : String(err));
-            }
+            contextMessages = await applyContextXrayTransformForIteration({
+                threadId: opts.threadId,
+                ownerEmail: opts.ownerEmail,
+                turnId: opts.turnId,
+                model,
+                messages,
+            });
             // Observational Memory (consumer): for long threads that have already been
             // compacted, fold the reflections+observations in as a leading context
             // block and prefer the recent-raw-message window over the full raw
@@ -4119,7 +4044,6 @@ export async function chainServerDrivenContinuation(opts) {
         workerProvenInBackgroundFunction: opts.workerProvenInBackgroundFunction === true,
     });
     const maxDispatchAttempts = dispatchBudget.maxDispatchAttempts;
-    const dispatchResponseTimeoutMs = dispatchBudget.dispatchResponseTimeoutMs;
     const continuationMarker = {
         runId: nextRunId,
         turnId: effectiveTurnId,
@@ -4181,93 +4105,28 @@ export async function chainServerDrivenContinuation(opts) {
                 ...continuationBody,
                 [AGENT_CHAT_BACKGROUND_RUN_FIELD]: continuationMarker,
             };
-        let dispatched = false;
-        let lastDispatchErr;
-        // Proactive nested-chain safety margin — see `MAX_NESTED_SELF_DISPATCH_DEPTH`.
-        // Skip the nested dispatch attempt entirely once this segment's hop count
-        // reaches the cap; a nested attempt at this depth is expected to trip
-        // Netlify's loop protection, so there is nothing to gain by trying it and
-        // burning this worker's remaining wall clock on a doomed call. Falls
-        // straight into the same deferred-recovery path below as an exhausted
-        // retry budget.
-        const nestedDepthExceeded = opts.backgroundContinuationCount >= MAX_NESTED_SELF_DISPATCH_DEPTH;
-        if (nestedDepthExceeded) {
-            lastDispatchErr = new Error(`proactive nested-dispatch depth cap reached (backgroundContinuationCount=${opts.backgroundContinuationCount} >= MAX_NESTED_SELF_DISPATCH_DEPTH=${MAX_NESTED_SELF_DISPATCH_DEPTH}) — deferring to the unclaimed-background-run sweep instead of risking Netlify loop protection`);
-        }
-        for (let attempt = 0; !nestedDepthExceeded && attempt < maxDispatchAttempts && !dispatched; attempt++) {
-            try {
-                if (attempt > 0) {
-                    // Uncapped budgets (durable-background and true-foreground) keep
-                    // the original `500 * 2 ** attempt` schedule unchanged. The capped
-                    // budget (proven-in-background-function) instead uses a schedule
-                    // starting at 500ms and doubling per gap, capped at
-                    // `backoffCapMs` — see `resolveContinuationDispatchBudget` for why
-                    // this stays well inside the worker's remaining wall clock even
-                    // with 5 attempts.
-                    const backoffMs = Number.isFinite(dispatchBudget.backoffCapMs)
-                        ? Math.min(500 * 2 ** (attempt - 1), dispatchBudget.backoffCapMs)
-                        : 500 * 2 ** attempt;
-                    await d.sleep(backoffMs);
-                    // Keep the pre-inserted successor row visibly alive while we
-                    // retry: the awaited attempts + backoff can outlast
-                    // UNCLAIMED_BACKGROUND_RUN_GRACE_MS (25s), and without a fresh
-                    // heartbeat the unclaimed-run reaper / sweep could error a handoff
-                    // we are still delivering.
-                    if (nextRowInserted) {
-                        await d.updateRunHeartbeat(nextRunId).catch(() => { });
-                    }
-                }
-                await d.fireInternalDispatch({
-                    event: opts.event,
-                    // Durable chain: same path resolution as the initial dispatch —
-                    // on hosted Netlify the background function's DEFAULT url (no
-                    // custom config.path; async via background:true; never shadowed
-                    // because /.netlify/* is excluded from the /* catch-all) so each
-                    // chunk keeps the 15-min budget; off-Netlify the in-process
-                    // framework route. Foreground self-chain: always the framework
-                    // `_process-run` route on the regular function (see the fn doc).
-                    path: continuationDispatchPath,
-                    taskId: nextRunId,
-                    body: dispatchBody,
-                    awaitResponse: true,
-                    responseTimeoutMs: dispatchResponseTimeoutMs,
-                });
-                dispatched = true;
-            }
-            catch (dispatchErr) {
-                lastDispatchErr = dispatchErr;
-                // Regular-function targets (foreground self-chain) respond only
-                // after the successor chunk FINISHES, so an await timeout is not
-                // proof of a dead handoff. The successor's ATOMIC CLAIM is: a row
-                // that left `dispatch_mode='background'` (claimed) or is already
-                // terminal proves the handoff landed — stop retrying. A duplicate
-                // delivery would lose the claim and no-op anyway; skipping it saves
-                // wall-clock this close to the invocation deadline.
-                if (!opts.chainViaDurableBackground && nextRowInserted) {
-                    const claim = await d
-                        .readBackgroundRunClaim(nextRunId)
-                        .catch(() => null);
-                    if (claim &&
-                        ((claim.dispatchMode && claim.dispatchMode !== "background") ||
-                            (claim.status && claim.status !== "running"))) {
-                        dispatched = true;
-                        break;
-                    }
-                }
-                console.error(`[agent-chat] background continuation dispatch attempt ${attempt + 1} failed:`, dispatchErr instanceof Error ? dispatchErr.message : dispatchErr);
-                // Netlify loop protection (see `isLoopProtectionDispatchError`) is a
-                // property of this same live, nested call chain — retrying the exact
-                // same nested self-dispatch within the next few seconds will not
-                // change that, so further attempts are a guaranteed-doomed use of
-                // this worker's remaining wall clock. Stop immediately (instead of
-                // burning the full `maxDispatchAttempts` budget) and fall into the
-                // same deferred-recovery path below, which hands the successor to the
-                // sweep — a genuinely different, non-nested invocation.
-                if (isLoopProtectionDispatchError(dispatchErr)) {
-                    break;
-                }
-            }
-        }
+        // Attempts to deliver the dispatch, retrying with backoff up to the
+        // resolved budget. See `attemptContinuationDispatch` for the full
+        // per-attempt rationale (nested-depth cap, claim-check on failure,
+        // Netlify loop-protection short-circuit) — moved verbatim, unchanged.
+        const { dispatched, lastDispatchErr, nestedDepthExceeded } = await attemptContinuationDispatch({
+            event: opts.event,
+            chainViaDurableBackground: opts.chainViaDurableBackground,
+            backgroundContinuationCount: opts.backgroundContinuationCount,
+            nextRunId,
+            nextRowInserted,
+            continuationDispatchPath,
+            dispatchBody,
+            dispatchBudget,
+            isLoopProtectionDispatchError,
+            maxNestedSelfDispatchDepth: MAX_NESTED_SELF_DISPATCH_DEPTH,
+            deps: {
+                sleep: d.sleep,
+                updateRunHeartbeat: d.updateRunHeartbeat,
+                fireInternalDispatch: d.fireInternalDispatch,
+                readBackgroundRunClaim: d.readBackgroundRunClaim,
+            },
+        });
         if (!dispatched) {
             if (nextRowInserted) {
                 // Classify WHY this handoff is being deferred — distinct, greppable
@@ -5089,6 +4948,13 @@ export function createProductionAgentHandler(options) {
             ...historyMessages,
             { role: "user", content: userContent },
         ];
+        const firstRequestPayloadDetail = buildFirstRequestPayloadDetail({
+            isFirstRequest: history.length === 0,
+            systemPrompt: requestSystemPrompt,
+            messages,
+            tools: requestTools,
+            availableToolCount: availableRequestTools.length,
+        });
         // Atomically claim the run slot for this thread. The claim checks SQL for
         // a live (non-stale) running row so two near-simultaneous POSTs on
         // different serverless isolates both see the correct state — a plain
@@ -5586,7 +5452,8 @@ export function createProductionAgentHandler(options) {
             .map(([k, v]) => `${k}=${v}`)
             .join(" ") +
             ` total=${Date.now() - setupT0}` +
-            (backgroundRuntimeDetail ? ` ${backgroundRuntimeDetail}` : "");
+            (backgroundRuntimeDetail ? ` ${backgroundRuntimeDetail}` : "") +
+            firstRequestPayloadDetail;
         startRun(runId, effectiveThreadId, async (rawSend, signal) => {
             const send = (event) => {
                 rawSend(event);
@@ -5829,6 +5696,11 @@ export function createProductionAgentHandler(options) {
             // `processors` opt + ProcessorChain/TripWire) is the deliverable and is
             // already callable directly by sub-agents, A2A, MCP, and tests; this is
             // only the HTTP-handler convenience plumbing.
+            const userVisibleSentimentInput = typeof displayMessage === "string" && displayMessage.trim().length > 0
+                ? displayMessage
+                : typeof message === "string" && message.trim().length > 0
+                    ? message
+                    : undefined;
             const agentLoopOpts = {
                 engine,
                 model: effectiveModel,
@@ -5913,6 +5785,14 @@ export function createProductionAgentHandler(options) {
                         },
                         experimentAssignments,
                         modelSelectionSource,
+                        sentimentInput: shouldInferSentimentForTurn({
+                            internalContinuation: Boolean(internalContinuation),
+                            isBackgroundWorker,
+                            backgroundContinuationCount,
+                            hasUserText: Boolean(userVisibleSentimentInput),
+                        })
+                            ? userVisibleSentimentInput
+                            : undefined,
                         classifyError: () => {
                             if (agentLoopOpts.signal.aborted &&
                                 agentLoopOpts.signal.reason === "run_timeout") {