@agent-native/core 0.95.1 → 0.97.0

package/corpus/core/src/guards/scan-utils.ts

@@ -0,0 +1,105 @@
+/**
+ * Shared file-walking / offset helpers used by every guard in this
+ * directory. Ported (behavior-for-behavior) from the identical helpers
+ * duplicated across `scripts/guard-*.mjs` — see each guard file for the
+ * specific `scripts/guard-<name>.mjs` it was derived from.
+ *
+ * The original scripts walk directories with `fs/promises` async
+ * generators. Guard functions here are synchronous pure functions (per the
+ * plan's `scan<Name>(options): GuardResult` contract), so this module uses
+ * `fs.readdirSync` instead — same skip-dir semantics, no behavior change.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+/** Directories skipped by every guard's repo/app walk. */
+export const DEFAULT_SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".cache",
+  ".turbo",
+  ".netlify",
+  ".vercel",
+  ".wrangler",
+  ".react-router",
+  ".generated",
+  ".claude",
+  "out",
+  "coverage",
+]);
+
+/** Recursively walk `dir`, yielding absolute file paths. Skips any
+ * directory whose basename is in `skipDirs`. */
+export function* walk(
+  dir: string,
+  skipDirs: Set<string> = DEFAULT_SKIP_DIRS,
+): Generator<string> {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (skipDirs.has(entry.name)) continue;
+      yield* walk(full, skipDirs);
+    } else if (entry.isFile()) {
+      yield full;
+    }
+  }
+}
+
+export function lineColForOffset(
+  contents: string,
+  offset: number,
+): { line: number; col: number } {
+  let line = 1;
+  let lineStart = 0;
+  for (let i = 0; i < offset; i++) {
+    if (contents.charCodeAt(i) === 10) {
+      line++;
+      lineStart = i + 1;
+    }
+  }
+  return { line, col: offset - lineStart + 1 };
+}
+
+export function isCommentLine(lineText: string): boolean {
+  const trimmed = lineText.trimStart();
+  return (
+    trimmed.startsWith("*") ||
+    trimmed.startsWith("//") ||
+    trimmed.startsWith("/*")
+  );
+}
+
+export function relPosix(root: string, file: string): string {
+  return path.relative(root, file).replaceAll("\\", "/");
+}
+
+export function readFileSafe(file: string): string | null {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+/** True if `rel` matches an exact-path entry in `extraExemptPaths`
+ * (posix-relative, exact string match — the same shape the exempt-path
+ * sets used in the original monorepo guards). */
+export function isExtraExempt(
+  rel: string,
+  extraExemptPaths: string[] | undefined,
+): boolean {
+  if (!extraExemptPaths || extraExemptPaths.length === 0) return false;
+  return extraExemptPaths.includes(rel);
+}

package/corpus/core/src/guards/types.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared types for `agent-native doctor`'s guard functions.
+ *
+ * Each guard is a pure function `scan<Name>(options): GuardResult` that
+ * scans a single app root and returns a flat list of findings. Guards do
+ * not print, exit, or read `agent-native.json` themselves — that
+ * orchestration lives in `../cli/doctor.ts` so the functions stay pure and
+ * independently testable/importable (see the `./guards` package export).
+ */
+
+export interface GuardFinding {
+  /** Path to the offending file, relative to the scanned root. */
+  file: string;
+  /** 1-based line number of the offending line. */
+  line: number;
+  /** Human-readable explanation of the finding. */
+  message: string;
+}
+
+export interface GuardResult {
+  /** Stable guard identifier, e.g. "no-drizzle-push". Matches the name used
+   * by `--only` and `agent-native.json`'s `doctor.disabledGuards`. */
+  name: string;
+  findings: GuardFinding[];
+}
+
+export interface GuardScanOptions {
+  /** Absolute path to the app root to scan. */
+  root: string;
+}

package/corpus/core/src/integrations/a2a-continuation-processor.ts

@@ -4,6 +4,7 @@ import type { Task } from "../a2a/types.js";
 import {
   formatLlmCredentialErrorMessage,
   isLlmCredentialError,
+  LLM_MISSING_CREDENTIALS_ERROR_CODE,
 } from "../agent/engine/credential-errors.js";
 import { withConfiguredAppBasePath } from "../server/app-base-path.js";
 import { FRAMEWORK_ROUTE_PREFIX } from "../server/core-routes-plugin.js";
@@ -457,15 +458,44 @@ function formatContinuationFailureMessage(
   continuation: A2AContinuation,
   reason: string,
 ): string {
-  if (isLlmCredentialError(reason)) {
-    return formatLlmCredentialErrorMessage({
-      agentName: continuation.agentName,
-    });
+  const explicitCode = extractFailureCode(reason);
+  const diagnostics = formatContinuationFailureDiagnostics(
+    continuation,
+    reason,
+  );
+  if (isLlmCredentialError(reason, explicitCode)) {
+    return (
+      formatLlmCredentialErrorMessage({
+        agentName: continuation.agentName,
+      }) + diagnostics
+    );
   }
 
   return `The ${continuation.agentName} agent could not finish this request: ${sanitizeFailureReason(
     reason,
-  )}`;
+  )}${diagnostics}`;
+}
+
+function formatContinuationFailureDiagnostics(
+  continuation: A2AContinuation,
+  reason: string,
+): string {
+  return `\n\nError code: \`${continuationFailureCode(reason)}\`\nRequest ID: \`${continuation.integrationTaskId}\`\nContinuation ID: \`${continuation.id}\`\nDownstream task ID: \`${continuation.a2aTaskId}\``;
+}
+
+function continuationFailureCode(reason: string): string {
+  const explicitCode = extractFailureCode(reason);
+  if (explicitCode) return explicitCode;
+  if (isLlmCredentialError(reason, explicitCode)) {
+    return LLM_MISSING_CREDENTIALS_ERROR_CODE;
+  }
+  if (/\btimed out polling\b/i.test(reason)) return "a2a_remote_timeout";
+  return "a2a_downstream_error";
+}
+
+function extractFailureCode(reason: string): string | null {
+  const match = /\bcode\s*[:=]\s*[`"']?([a-z][a-z0-9_]{0,79})\b/i.exec(reason);
+  return match?.[1]?.toLowerCase() ?? null;
 }
 
 function isRemoteWorkExpired(continuation: A2AContinuation): boolean {

package/corpus/core/src/integrations/adapters/slack.ts

@@ -37,6 +37,7 @@ const SLACK_API_TIMEOUT_MS = 10_000;
 const SLACK_PERMALINK_TIMEOUT_MS = 1_000;
 const SLACK_CONTEXT_MESSAGE_LIMIT = 15;
 const SLACK_CONTEXT_TEXT_LIMIT = 2_000;
+const SLACK_CALM_PROGRESS_THRESHOLD_SECONDS = 30;
 
 export interface SlackAdapterOptions {
   /** Resolve the bot token for the exact Slack installation. */
@@ -323,12 +324,10 @@ export function slackAdapter(
     async postProcessingPlaceholder(
       incoming: IncomingMessage,
     ): Promise<{ placeholderRef: string } | null> {
-      // No placeholder reply in the thread — Slack's native assistant
-      // status bar ("agent-native is thinking…", below the composer) is the
-      // loading affordance. A second visible "Working on it…" reply was
-      // redundant and added an extra chunk that we then had to overwrite.
-      // We just set the native status and return null so sendResponse posts
-      // the final reply as a fresh message.
+      // No placeholder reply in the thread — Slack's native assistant status
+      // bar and the task stream are the loading affordance. Keep the status
+      // specific about intent instead of presenting the generic thinking
+      // state while the native plan is opening.
       const token = await resolveBotToken(incoming);
       if (!token) return null;
 
@@ -336,11 +335,16 @@ export function slackAdapter(
       const threadTs = incoming.platformContext.threadTs as string;
       if (!channelId || !threadTs) return null;
 
-      // Best-effort: flip the native Agent "is thinking…" status bar in the
+      // Best-effort: flip the native Agent status bar in the
       // channel input area. Slack accepts chat:write for this method. The
       // canonical manifest separately requests assistant:write for Agent View
       // and app_context_changed events.
-      setSlackAssistantStatus(token, channelId, threadTs, "is thinking…");
+      setSlackAssistantStatus(
+        token,
+        channelId,
+        threadTs,
+        "I’m looking into this now…",
+      );
       return null;
     },
 
@@ -1266,6 +1270,42 @@ function shortTaskTitle(value: unknown): string {
   return text.replace(/[-_]/g, " ").slice(0, 200);
 }
 
+function delegatedTaskTitle(agent: unknown): string {
+  return `Contact ${shortTaskTitle(agent)}`;
+}
+
+function formatElapsedSeconds(elapsedSeconds: number): string {
+  const totalSeconds = Math.max(0, Math.round(elapsedSeconds));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+}
+
+function formatProgressState(state: string): string {
+  if (state === "submitted") return "Queued";
+  if (state === "working") return "Working";
+  return shortTaskTitle(state);
+}
+
+function delegatedProgressDetails(
+  agent: unknown,
+  state: string,
+  elapsedSeconds: number,
+  detail?: string,
+): string {
+  const elapsed = formatElapsedSeconds(elapsedSeconds);
+  const progress = `${formatProgressState(state)} · ${elapsed}`;
+  const update = detail ? shortTaskTitle(detail) : "";
+
+  if (elapsedSeconds >= SLACK_CALM_PROGRESS_THRESHOLD_SECONDS) {
+    const agentName = shortTaskTitle(agent);
+    const context = update ? ` — ${update}.` : ".";
+    return `${progress}${context} This is taking longer than usual, but ${agentName} is still working. I’ll post the result here.`;
+  }
+
+  return update ? `${progress} — ${update}` : progress;
+}
+
 async function postSlackJson(
   token: string,
   method: string,
@@ -1315,18 +1355,18 @@ async function startSlackRunProgress(
       ...(incoming.tenantId ? { recipient_team_id: incoming.tenantId } : {}),
       ...(incoming.senderId ? { recipient_user_id: incoming.senderId } : {}),
       task_display_mode: "plan",
-      markdown_text: "Working on your request…",
+      markdown_text: "I’m looking into this for you.",
       chunks: [
         {
           type: "plan_update",
-          title: "Working on your request",
+          title: "I’m looking into this for you",
         },
         {
           type: "task_update",
           id: "agent-native:context",
-          title: "Understand the request",
+          title: "Review the request",
           status: "in_progress",
-          details: "Loading relevant context",
+          details: "Finding the information needed for an answer",
         },
       ],
     });
@@ -1373,7 +1413,7 @@ function createSlackRunProgress(
   const toolTaskIds = new Map<string, string>();
   const agentTaskIds = new Map<string, string>();
   tasks.set("agent-native:context", {
-    title: "Understand the request",
+    title: "Review the request",
     status: "in_progress",
   });
   let sequence = 0;
@@ -1540,9 +1580,19 @@ function createSlackRunProgress(
             : event.status === "done"
               ? "complete"
               : "error";
-        const title = `Ask ${shortTaskTitle(event.agent)}`;
+        const title = delegatedTaskTitle(event.agent);
         tasks.set(id, { title, status });
-        await append({ type: "task_update", id, title, status });
+        await append({
+          type: "task_update",
+          id,
+          title,
+          status,
+          ...(event.status === "start"
+            ? {
+                details: `I’m contacting ${shortTaskTitle(event.agent)} for an answer.`,
+              }
+            : {}),
+        });
       } else if (event.type === "agent_call_progress") {
         // A2A calls can stay healthy for minutes. Keep the same native Slack
         // task card alive with each real downstream poll rather than creating
@@ -1550,10 +1600,13 @@ function createSlackRunProgress(
         const id =
           agentTaskIds.get(event.agent) ?? taskId("agent", event.agent);
         agentTaskIds.set(event.agent, id);
-        const title = `Ask ${shortTaskTitle(event.agent)}`;
-        const details = event.detail
-          ? shortTaskTitle(event.detail)
-          : `Still ${event.state} after ${event.elapsedSeconds}s`;
+        const title = delegatedTaskTitle(event.agent);
+        const details = delegatedProgressDetails(
+          event.agent,
+          event.state,
+          event.elapsedSeconds,
+          event.detail,
+        );
         tasks.set(id, { title, status: "in_progress" });
         await append({
           type: "task_update",
@@ -1566,9 +1619,9 @@ function createSlackRunProgress(
         await append({
           type: "task_update",
           id: "agent-native:context",
-          title: "Understand the request",
+          title: "Review the request",
           status: "in_progress",
-          details: shortTaskTitle(event.label),
+          details: `Working · ${shortTaskTitle(event.label)}`,
         });
       }
     },

package/corpus/core/src/integrations/webhook-handler.ts

@@ -15,6 +15,7 @@ import {
   normalizeModelForEngine,
   resolveEngine,
 } from "../agent/engine/index.js";
+import { resolveMainChatMaxOutputTokens } from "../agent/engine/output-tokens.js";
 import { PROVIDER_TO_ENV } from "../agent/engine/provider-env-vars.js";
 import type { AgentEngine, EngineMessage } from "../agent/engine/types.js";
 import {
@@ -45,6 +46,7 @@ import {
   readDeployCredentialEnv,
 } from "../server/credential-provider.js";
 import { runWithRequestContext } from "../server/request-context.js";
+import { normalizeReasoningEffortForRequest } from "../shared/reasoning-effort.js";
 import { A2A_CONTINUATION_QUEUED_MARKER } from "./a2a-continuation-marker.js";
 import {
   clearIntegrationAwaitingInput,
@@ -866,6 +868,18 @@ async function processIncomingMessage(
               signal,
               threadId,
               approvedToolCalls: incoming.approvedToolCalls,
+              // Messaging integrations are interactive chat surfaces. They
+              // need the same initial completion headroom as web chat so
+              // reasoning cannot consume the small per-engine default and
+              // leave a user-facing Slack reply empty.
+              maxOutputTokens: resolveMainChatMaxOutputTokens(resolvedModel),
+              // Explicitly resolve the normal chat default so an empty-final
+              // retry can step its reasoning effort down rather than
+              // repeatedly letting the engine choose Medium.
+              reasoningEffort: normalizeReasoningEffortForRequest(
+                resolvedModel,
+                undefined,
+              ),
             });
             return usage;
           },

package/corpus/core/src/localization/default-messages.ts

@@ -216,6 +216,12 @@ const messages = {
       promptTitle: "Talk to your app",
       promptDescription:
         "Voice mode keeps listening while the agent navigates and takes actions.",
+      setupTitle: "Set up voice mode",
+      setupDescription:
+        "Connect Builder to use managed voice with credits, or use your own OpenAI API key.",
+      connectBuilder: "Connect Builder",
+      useOpenAiKey: "Use OpenAI API key",
+      startWithOpenAiKey: "Start with OpenAI key",
       start: "Start voice mode",
       keepDictating: "Keep dictating",
       showChat: "Show chat",

package/corpus/core/src/observability/hosted-model-experiment.ts

@@ -0,0 +1,118 @@
+export const HOSTED_DEFAULT_MODEL_EXPERIMENT_ID =
+  "hosted-default-model-sonnet-5-vs-gpt-5-6-luna-2026-07";
+
+export const HOSTED_DEFAULT_MODEL_CONTROL = {
+  id: "sonnet-5",
+  model: "claude-sonnet-5",
+  weight: 80,
+} as const;
+
+export const HOSTED_DEFAULT_MODEL_TREATMENT = {
+  id: "gpt-5-6-luna",
+  model: "gpt-5-6-luna",
+  weight: 20,
+} as const;
+
+export interface HostedDefaultModelExperimentAssignment {
+  experimentId: string;
+  variantId: string;
+}
+
+export interface HostedDefaultModelExperimentResolution {
+  model: string;
+  assignment: HostedDefaultModelExperimentAssignment;
+}
+
+type HostedExperimentEnv = Record<string, string | undefined>;
+
+const FIRST_PARTY_HOST_SUFFIX = ".agent-native.com";
+const ENABLED_VALUES = new Set(["1", "true", "on", "yes"]);
+const DISABLED_VALUES = new Set(["0", "false", "off", "no"]);
+
+function hostnameFromUrl(value: string | undefined): string | null {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  try {
+    const url = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)
+      ? new URL(trimmed)
+      : new URL(`https://${trimmed}`);
+    return url.hostname.toLowerCase();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The rollout is automatic only on first-party hosted app domains. Operators
+ * can explicitly enable or disable it for preview and emergency rollback.
+ */
+export function isHostedDefaultModelExperimentEnabled(
+  env: HostedExperimentEnv = process.env,
+): boolean {
+  const override =
+    env.AGENT_NATIVE_HOSTED_MODEL_EXPERIMENT?.trim().toLowerCase();
+  if (override && DISABLED_VALUES.has(override)) return false;
+  if (override && ENABLED_VALUES.has(override)) return true;
+
+  const hostnames = [
+    env.APP_URL,
+    env.BETTER_AUTH_URL,
+    env.URL,
+    env.DEPLOY_URL,
+    env.VERCEL_PROJECT_PRODUCTION_URL,
+    env.VERCEL_URL,
+  ]
+    .map(hostnameFromUrl)
+    .filter((hostname): hostname is string => Boolean(hostname));
+
+  return hostnames.some(
+    (hostname) =>
+      hostname === "agent-native.com" ||
+      hostname.endsWith(FIRST_PARTY_HOST_SUFFIX),
+  );
+}
+
+/**
+ * Stable cross-app bucket: the same authenticated user receives the same
+ * variant in every hosted template for the life of this experiment id.
+ */
+export function hostedDefaultModelExperimentBucket(userId: string): number {
+  const input = `${HOSTED_DEFAULT_MODEL_EXPERIMENT_ID}:${userId.trim().toLowerCase()}`;
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < input.length; index++) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0) % 100;
+}
+
+export function resolveHostedDefaultModelExperiment(args: {
+  userId: string | null | undefined;
+  engineName: string;
+  isDefaultModelSelection: boolean;
+  supportedModels?: readonly string[];
+  env?: HostedExperimentEnv;
+}): HostedDefaultModelExperimentResolution | null {
+  const userId = args.userId?.trim();
+  if (!userId) return null;
+  if (args.engineName !== "builder") return null;
+  if (!args.isDefaultModelSelection) return null;
+  if (!isHostedDefaultModelExperimentEnabled(args.env)) return null;
+
+  const variant =
+    hostedDefaultModelExperimentBucket(userId) <
+    HOSTED_DEFAULT_MODEL_TREATMENT.weight
+      ? HOSTED_DEFAULT_MODEL_TREATMENT
+      : HOSTED_DEFAULT_MODEL_CONTROL;
+  if (args.supportedModels && !args.supportedModels.includes(variant.model)) {
+    return null;
+  }
+
+  return {
+    model: variant.model,
+    assignment: {
+      experimentId: HOSTED_DEFAULT_MODEL_EXPERIMENT_ID,
+      variantId: variant.id,
+    },
+  };
+}

package/corpus/core/src/observability/routes.ts

@@ -69,6 +69,18 @@ async function resolveOwner(event: H3Event): Promise<string> {
   return session.email;
 }
 
+function canManageExperiments(ownerEmail: string): boolean {
+  // Local development keeps the built-in dashboard usable without additional
+  // setup. Hosted deployments fail closed unless the operator supplies an
+  // explicit allowlist, because experiments affect every user in the app.
+  if (process.env.NODE_ENV !== "production") return true;
+  const admins = (process.env.AGENT_NATIVE_EXPERIMENT_ADMIN_EMAILS ?? "")
+    .split(",")
+    .map((email) => email.trim().toLowerCase())
+    .filter(Boolean);
+  return admins.includes(ownerEmail.trim().toLowerCase());
+}
+
 function parseSince(q: Record<string, any>): number {
   const raw = q.since;
   if (typeof raw === "string" && raw.length > 0) {
@@ -236,6 +248,11 @@ export function createObservabilityHandler() {
       return getEvalStats(parseSince(q), { userId: owner });
     }
 
+    if (parts[0] === "experiments" && !canManageExperiments(owner)) {
+      setResponseStatus(event, 403);
+      return { error: "Experiment administrator access required" };
+    }
+
     // POST /experiments — create experiment. Records the calling user as
     // the owner so subsequent PUT / POST results require the same caller.
     if (method === "POST" && parts.length === 1 && parts[0] === "experiments") {

package/corpus/core/src/observability/store.ts

@@ -972,7 +972,10 @@ export async function updateExperiment(
     sets.push("status = ?");
     args.push(updates.status);
     if (updates.status === "running" && !updates.endedAt) {
-      sets.push("started_at = ?");
+      // Preserve the original exposure window when a paused experiment
+      // resumes; resetting it would silently discard the first run period from
+      // the results.
+      sets.push("started_at = COALESCE(started_at, ?)");
       args.push(Date.now());
     }
   }

package/corpus/core/src/observability/traces.ts

@@ -100,6 +100,11 @@ function emitLlmGenerationTrackingEvent(args: {
   successfulTools: number;
   failedTools: number;
   createdAt: number;
+  experimentAssignments?: Array<{
+    experimentId: string;
+    variantId: string;
+  }>;
+  modelSelectionSource?: string;
 }): void {
   const provider = llmProviderFromEngine(args.engineName, args.model);
   const costUsd = costUsdFromCenticents(args.costCentsX100);
@@ -126,6 +131,7 @@ function emitLlmGenerationTrackingEvent(args: {
     tool_calls: args.toolCalls,
     successful_tools: args.successfulTools,
     failed_tools: args.failedTools,
+    model_selection_source: args.modelSelectionSource,
     created_at: new Date(args.createdAt).toISOString(),
     created_at_ms: args.createdAt,
     $ai_trace_id: args.runId,
@@ -145,6 +151,18 @@ function emitLlmGenerationTrackingEvent(args: {
     $ai_request_count: 1,
     $ai_total_cost_usd: costUsd,
   };
+  if (args.experimentAssignments?.length) {
+    properties.experiment_ids = args.experimentAssignments
+      .map((assignment) => assignment.experimentId)
+      .join(",");
+    properties.experiment_variants = args.experimentAssignments
+      .map((assignment) => assignment.variantId)
+      .join(",");
+    if (args.experimentAssignments.length === 1) {
+      properties.experiment_id = args.experimentAssignments[0].experimentId;
+      properties.experiment_variant = args.experimentAssignments[0].variantId;
+    }
+  }
   if (error) properties.error_message = error;
 
   for (const key of Object.keys(properties)) {
@@ -245,6 +263,12 @@ export async function instrumentAgentLoop(opts: {
    *  reads. */
   userId: string | null;
   config: ObservabilityConfig;
+  metadata?: Record<string, unknown> | null;
+  experimentAssignments?: Array<{
+    experimentId: string;
+    variantId: string;
+  }>;
+  modelSelectionSource?: string;
   classifyError?: (error: unknown) =>
     | {
         status?: "success" | "error";
@@ -268,6 +292,15 @@ export async function instrumentAgentLoop(opts: {
     "agent.thread_id": threadId ?? undefined,
     "agent.user_id": userId ?? undefined,
     "agent.model": loopOpts.model,
+    "agent.model_selection_source": opts.modelSelectionSource,
+    "agent.experiment_id":
+      opts.experimentAssignments?.length === 1
+        ? opts.experimentAssignments[0].experimentId
+        : undefined,
+    "agent.experiment_variant":
+      opts.experimentAssignments?.length === 1
+        ? opts.experimentAssignments[0].variantId
+        : undefined,
   });
 
   const spans: TraceSpan[] = [];
@@ -424,7 +457,7 @@ export async function instrumentAgentLoop(opts: {
   let usage: AgentLoopUsage | undefined;
   let runStatus: "success" | "error" = "success";
   let errorMessage: string | null = null;
-  let runMetadata: Record<string, unknown> | null = null;
+  let runMetadata: Record<string, unknown> | null = opts.metadata ?? null;
   try {
     usage = await runAgentLoop({ ...loopOpts, send: instrumentedSend });
   } catch (err: any) {
@@ -434,7 +467,11 @@ export async function instrumentAgentLoop(opts: {
       classification?.errorMessage === undefined
         ? (err?.message ?? String(err))
         : classification.errorMessage;
-    runMetadata = classification?.metadata ?? null;
+    const errorMetadata = classification?.metadata ?? null;
+    runMetadata =
+      runMetadata || errorMetadata
+        ? { ...(runMetadata ?? {}), ...(errorMetadata ?? {}) }
+        : null;
     throw err;
   } finally {
     const runEnd = Date.now();
@@ -501,6 +538,8 @@ export async function instrumentAgentLoop(opts: {
         successfulTools,
         failedTools,
         createdAt: runStart,
+        experimentAssignments: opts.experimentAssignments,
+        modelSelectionSource: opts.modelSelectionSource,
       });
     }