Is your AI agent silently failing without you knowing?

logger.info("agent.intent", {
  task_id: id,
  request_summary: "send email re: invoice #4471",
  source: "user_email_reply"
})

const r = await sendEmail(...);
logger.info("tool.send_email", {
  status: r.statusCode,         // 200, 201, 202, 4xx, 5xx
  provider_id: r.messageId,     // SES / Postmark / SendGrid id
  latency_ms: r.elapsed
});

async function toolWithRetry(fn, max=2) {
  for (let i = 0; i <= max; i++) {
    const r = await fn();
    if (assertOutcome(r)) return r;  // ← the line you're missing
    logger.warn("tool.retry", { attempt: i+1, why: describeMismatch(r) });
  }
}

function assertOutcome(r) {
  if (r.statusCode >= 500) throw new Error("server error");
  if (!r.body || r.body.error) return false;
  return true;
}

const t0 = Date.now();
const r = await sendEmail(...);
// ... agent reports "done" to user ...
logger.info("side_effect.landed", { id: r.messageId, landed_at: Date.now(), gap_ms: Date.now() - t0 });

// At the top of the request, generate a stable key from the intent:
const idemKey = "ord_" + orderId + "_" + intentHash;
const r = await stripe.charges.create({
  amount, currency, customer,
  idempotency_key: idemKey          // Stripe, Twilio, Plaid, SendGrid all accept this
});
logger.info("tool.charge", { idem_key: idemKey, charge_id: r.id });

// 1. Hash the intent line at tool-call time; log it:
const intentHash = sha256(intentLine);
logger.info("tool.bind", { intent_hash: intentHash, tool: "send_email", args_hash: sha256(JSON.stringify(args)) });
// 2. At review time: any tool whose intent_hash doesn't match a recent intent line
//    is a candidate injection event — flag for human review, do not auto-execute.

// In your LLM call wrapper (after the response):
const promptTokens = r.usage.prompt_tokens;
const completionTokens = r.usage.completion_tokens;
const costUsd = (promptTokens * 0.000003) + (completionTokens * 0.000015); // your model prices
logger.info("llm.call", {
  task_id: id,
  model: "gpt-4o",
  tokens_in: promptTokens,
  tokens_out: completionTokens,
  cost_usd: costUsd,
  // also tag the intent so a runaway cost shows up attached to a specific user request
  intent_hash: intentHash
});

// Before each LLM call:
const MAX_CONTEXT_CHARS = 20000;  // ~5K tokens; tune to your model window
let messages = buildMessages(intent, history, toolResults);
const beforeLen = JSON.stringify(messages).length;
if (beforeLen > MAX_CONTEXT_CHARS) {
  // trim oldest tool results, keep the intent and last 2 turns
  messages = trimToIntentAndRecent(messages, 2);
  logger.warn("context.trimmed", { before_chars: beforeLen, after_chars: JSON.stringify(messages).length, task_id: id });
}
logger.info("llm.context", { task_id: id, context_chars: JSON.stringify(messages).length });
// Without this line, you have no way to know if a single task is ballooning context on retry.

// At tool-call N, log the original intent so you can see when the agent stops checking it:
const intentLine = originalUserRequest;       // capture at task start
const intentHash = sha256(intentLine);
function reaffirmIntent(step) {
  if (step % 3 === 0) {                       // every 3rd tool call
    logger.info("agent.reaffirm_intent", {
      task_id: id,
      step: step,
      intent_hash: intentHash,
      intent_first_60: intentLine.slice(0, 60),
      current_tool: toolName
    });
  }
}
// If intent_hash stops appearing in logs after step 6+, the agent has drifted off-task.

// Track recent (tool, args) pairs in a small ring buffer; abort if a pair repeats:
const recent = [];  // { tool, args_hash, ts }
function guardLoop(tool, args) {
  const argsHash = sha256(JSON.stringify(args));
  recent.push({ tool, args_hash: argsHash, ts: Date.now() });
  if (recent.length > 8) recent.shift();
  const same = recent.filter(r => r.tool === tool && r.args_hash === argsHash).length;
  if (same >= 3) {
    logger.error("tool.loop_detected", { tool, args_hash: argsHash, repeats: same, task_id: id });
    throw new Error("budget_exhausted: tool " + tool + " repeated " + same + "x with same args — abort and escalate to human");
  }
  logger.info("tool.call", { tool, args_hash: argsHash, task_id: id });
}