@agent-native/core 0.97.0 → 0.98.1

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

@@ -211,6 +211,7 @@ const messages = {
     cliRequiresDevModeDescription:
       "Run this app locally with pnpm dev or use Builder.io to access the CLI terminal.",
     toggleAgent: "Toggle agent",
+    checkingAiConnection: "Checking AI connection...",
     voiceMode: {
       entryButtonLabel: "Use microphone",
       promptTitle: "Talk to your app",
@@ -218,7 +219,7 @@ const messages = {
         "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.",
+        "Connect Builder to use managed voice with free credits, or use your own OpenAI API key.",
       connectBuilder: "Connect Builder",
       useOpenAiKey: "Use OpenAI API key",
       startWithOpenAiKey: "Start with OpenAI key",
@@ -227,6 +228,47 @@ const messages = {
       showChat: "Show chat",
       hideChat: "Hide chat",
       end: "End voice mode",
+      voiceSettings: "Voice settings",
+      settings: {
+        microphone: "Microphone",
+        defaultMicrophone: "System default",
+        microphoneSwitchFailed:
+          "Could not switch microphones. Your current microphone is still active.",
+        language: "Language",
+        autoLanguage: "Auto",
+        languages: {
+          en: "English",
+          es: "Spanish",
+          fr: "French",
+          de: "German",
+          it: "Italian",
+          pt: "Portuguese",
+          ja: "Japanese",
+          ko: "Korean",
+          zh: "Chinese",
+        },
+        intelligence: "Intelligence",
+        intelligenceLevels: {
+          instant: "Instant",
+          balanced: "Balanced",
+          deep: "Deep",
+        },
+        voiceStyle: "Voice style",
+        voiceChangePending:
+          "Your new voice will apply next time you start voice mode.",
+        voiceDescriptions: {
+          marin: "Warm and natural",
+          cedar: "Clear and grounded",
+          coral: "Friendly and bright",
+          sage: "Calm and thoughtful",
+          verse: "Expressive and versatile",
+          alloy: "Balanced and neutral",
+          ash: "Smooth and confident",
+          ballad: "Warm and expressive",
+          echo: "Clear and direct",
+          shimmer: "Light and upbeat",
+        },
+      },
       status: {
         connecting: "Connecting",
         listening: "Listening",
@@ -241,6 +283,8 @@ const messages = {
         responseFailed: "OpenAI could not complete the voice response.",
         sessionFailed: "The realtime voice session encountered an error.",
         channelDisconnected: "The realtime voice control channel disconnected.",
+        connectionTimedOut:
+          "The realtime voice connection timed out. Try again after the app finishes loading.",
         connectionFailed: "The realtime voice connection failed.",
         offerFailed: "The browser did not create an audio offer.",
       },
@@ -408,6 +452,12 @@ const messages = {
     contentLabel: "Content",
     previewTitle: "Extension preview",
     previewEmpty: "Preview will appear here",
+    loadError: "Couldn't load extensions.",
+    widgetsLoadError: "Couldn't load widgets.",
+    widgetAreasLoadError: "Couldn't load widget areas.",
+    historyLoadError: "Couldn't load extension history.",
+    versionLoadError: "Couldn't load this extension version.",
+    retry: "Retry",
   },
   org: {
     createTitle: "Create your organization",

package/corpus/core/src/mcp/oauth-token.ts

@@ -10,7 +10,12 @@ import {
 
 export { MCP_OAUTH_ACCESS_TOKEN_TTL, MCP_OAUTH_ACCESS_TOKEN_TTL_SECONDS };
 
-export const MCP_OAUTH_SCOPES = ["mcp:read", "mcp:write", "mcp:apps"] as const;
+export const MCP_OAUTH_SCOPES = [
+  "mcp:read",
+  "mcp:write",
+  "mcp:apps",
+  "offline_access",
+] as const;
 
 export const MCP_OAUTH_DEFAULT_SCOPE = MCP_OAUTH_SCOPES.join(" ");
 

package/corpus/core/src/mcp-client/workspace-servers.ts

@@ -265,8 +265,8 @@ async function selectWorkspaceMcpResourceRows(options?: {
         AND wr.scope = ?
         AND wr.path LIKE ?
         AND (
-          (? IS NOT NULL AND wr.org_id = ?)
-          OR (? IS NOT NULL AND wr.org_id IS NULL AND lower(wr.owner_email) = lower(?))
+          (CAST(? AS TEXT) IS NOT NULL AND wr.org_id = ?)
+          OR (CAST(? AS TEXT) IS NOT NULL AND wr.org_id IS NULL AND lower(wr.owner_email) = lower(?))
         )
     `,
     args: [
@@ -304,8 +304,8 @@ async function selectWorkspaceMcpResourceRows(options?: {
         AND wg.status = ?
         AND wg.app_id = ?
         AND (
-          (? IS NOT NULL AND wr.org_id = ?)
-          OR (? IS NOT NULL AND wr.org_id IS NULL AND lower(wr.owner_email) = lower(?))
+          (CAST(? AS TEXT) IS NOT NULL AND wr.org_id = ?)
+          OR (CAST(? AS TEXT) IS NOT NULL AND wr.org_id IS NULL AND lower(wr.owner_email) = lower(?))
         )
         AND (
           (wr.org_id IS NOT NULL AND wg.org_id = wr.org_id)

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

@@ -30,6 +30,7 @@ import {
 
 import { getSession } from "../server/auth.js";
 import { readBody } from "../server/h3-helpers.js";
+import { track } from "../tracking/registry.js";
 import {
   getObservabilityOverview,
   getTraceSummaries,
@@ -47,6 +48,7 @@ import {
   updateExperiment,
   getExperimentResults,
 } from "./store.js";
+import { trackingIdentityProperties } from "./tracking-identity.js";
 import type { FeedbackType, ExperimentStatus } from "./types.js";
 
 function nanoid(size = 21): string {
@@ -205,6 +207,40 @@ export function createObservabilityHandler() {
         userId: owner,
         createdAt: Date.now(),
       });
+      // Emit one content-free analytics event for the explicit thumb itself.
+      // Category follow-ups intentionally do not emit: a thumbs-down followed
+      // by a category would otherwise double-count the same negative signal.
+      if (feedbackType === "thumbs_up" || feedbackType === "thumbs_down") {
+        const runId = body.runId ? String(body.runId) : null;
+        let model: string | undefined;
+        if (runId) {
+          try {
+            const summary = await getTraceSummary(runId, { userId: owner });
+            model = summary?.model || undefined;
+          } catch {
+            // Feedback persistence is authoritative; analytics enrichment is
+            // best-effort and must never make the submission fail.
+          }
+        }
+
+        const threadId = body.threadId ? String(body.threadId) : null;
+        track(
+          "$ai_feedback",
+          {
+            ...trackingIdentityProperties(),
+            source: "agent_observability",
+            sentiment: feedbackType === "thumbs_up" ? "positive" : "negative",
+            feedback_type: feedbackType,
+            run_id: runId,
+            thread_id: threadId,
+            model,
+            $ai_trace_id: runId ?? undefined,
+            $ai_session_id: threadId ?? undefined,
+            $ai_model: model,
+          },
+          { userId: owner },
+        );
+      }
       // Fire-and-forget: recompute satisfaction score for the thread.
       if (body.threadId) {
         import("./feedback.js")

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

@@ -0,0 +1,261 @@
+import type { AgentEngine, EngineEvent } from "../agent/engine/types.js";
+import { trackingIdentityProperties } from "./tracking-identity.js";
+import type { ObservabilityConfig } from "./types.js";
+import { DEFAULT_OBSERVABILITY_CONFIG } from "./types.js";
+
+export const DEFAULT_INFERRED_SENTIMENT_MODEL = "gpt-5-6-luna";
+export const HOSTED_INFERRED_SENTIMENT_SAMPLE_RATE = 1;
+export const INFERRED_SENTIMENT_MAX_CHARS = 2_000;
+export const INFERRED_SENTIMENT_TIMEOUT_MS = 5_000;
+
+export type InferredSentiment = "positive" | "negative" | "neutral";
+
+type SentimentEnv = Record<string, string | undefined>;
+
+const ENABLED_VALUES = new Set(["1", "true", "on", "yes"]);
+const DISABLED_VALUES = new Set(["0", "false", "off", "no"]);
+const FIRST_PARTY_HOST_SUFFIX = ".agent-native.com";
+
+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;
+  }
+}
+
+export function isFirstPartyHostedAgentNative(
+  env: SentimentEnv = process.env,
+): boolean {
+  return [
+    env.APP_URL,
+    env.BETTER_AUTH_URL,
+    env.URL,
+    env.DEPLOY_URL,
+    env.VERCEL_PROJECT_PRODUCTION_URL,
+    env.VERCEL_URL,
+  ]
+    .map(hostnameFromUrl)
+    .some(
+      (hostname) =>
+        hostname === "agent-native.com" ||
+        Boolean(hostname?.endsWith(FIRST_PARTY_HOST_SUFFIX)),
+    );
+}
+
+function parseBooleanOverride(value: string | undefined): boolean | undefined {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return undefined;
+  if (ENABLED_VALUES.has(normalized)) return true;
+  if (DISABLED_VALUES.has(normalized)) return false;
+  return undefined;
+}
+
+function parseSampleRate(value: unknown): number | undefined {
+  if (value === "" || value === null || value === undefined) return undefined;
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed)) return undefined;
+  return Math.min(1, Math.max(0, parsed));
+}
+
+/**
+ * Resolve inference defaults without making self-hosted apps opt in silently.
+ * Explicit opt-out always wins. Otherwise stored app config and deployment
+ * env can override the first-party hosted default.
+ */
+export function resolveInferredSentimentConfig(
+  stored: Partial<ObservabilityConfig> | null | undefined,
+  env: SentimentEnv = process.env,
+): Pick<
+  ObservabilityConfig,
+  | "inferredSentimentEnabled"
+  | "inferredSentimentSampleRate"
+  | "inferredSentimentModel"
+> {
+  const hosted = isFirstPartyHostedAgentNative(env);
+  const storedRate = parseSampleRate(stored?.inferredSentimentSampleRate);
+  const envRate = parseSampleRate(
+    env.AGENT_NATIVE_INFERRED_SENTIMENT_SAMPLE_RATE,
+  );
+  const envEnabled = parseBooleanOverride(env.AGENT_NATIVE_INFERRED_SENTIMENT);
+  const storedModel = stored?.inferredSentimentModel?.trim();
+  const envModel = env.AGENT_NATIVE_INFERRED_SENTIMENT_MODEL?.trim();
+
+  return {
+    inferredSentimentEnabled:
+      envEnabled === false || stored?.inferredSentimentEnabled === false
+        ? false
+        : (envEnabled ?? stored?.inferredSentimentEnabled ?? hosted),
+    inferredSentimentSampleRate:
+      envRate ??
+      storedRate ??
+      (hosted ? HOSTED_INFERRED_SENTIMENT_SAMPLE_RATE : 0),
+    inferredSentimentModel:
+      envModel ||
+      storedModel ||
+      DEFAULT_OBSERVABILITY_CONFIG.inferredSentimentModel,
+  };
+}
+
+/** Stable deterministic sampling keeps retries for the same run consistent. */
+export function shouldSampleInferredSentiment(
+  runId: string,
+  sampleRate: number,
+): boolean {
+  if (sampleRate <= 0) return false;
+  if (sampleRate >= 1) return true;
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < runId.length; index += 1) {
+    hash ^= runId.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0) / 0x1_0000_0000 < sampleRate;
+}
+
+export function shouldInferSentimentForTurn(args: {
+  internalContinuation: boolean;
+  isBackgroundWorker: boolean;
+  backgroundContinuationCount: number;
+  hasUserText: boolean;
+}): boolean {
+  if (!args.hasUserText || args.internalContinuation) return false;
+  return !args.isBackgroundWorker || args.backgroundContinuationCount === 0;
+}
+
+export function parseInferredSentiment(
+  output: string,
+): InferredSentiment | null {
+  const normalized = output.trim().toLowerCase();
+  return normalized === "positive" ||
+    normalized === "negative" ||
+    normalized === "neutral"
+    ? normalized
+    : null;
+}
+
+function truncateInput(text: string): string {
+  return Array.from(text.trim())
+    .slice(0, INFERRED_SENTIMENT_MAX_CHARS)
+    .join("");
+}
+
+async function classifySentiment(args: {
+  engine: AgentEngine;
+  model: string;
+  text: string;
+}): Promise<InferredSentiment | null> {
+  if (
+    !args.engine.preserveCustomModels &&
+    args.engine.supportedModels.length > 0 &&
+    !args.engine.supportedModels.includes(args.model)
+  ) {
+    return null;
+  }
+
+  const input = truncateInput(args.text);
+  if (!input) return null;
+
+  const controller = new AbortController();
+  const timeout = setTimeout(
+    () => controller.abort(),
+    INFERRED_SENTIMENT_TIMEOUT_MS,
+  );
+  let output = "";
+  let finalOutput = "";
+  try {
+    for await (const event of args.engine.stream({
+      model: args.model,
+      systemPrompt:
+        "Classify the user's emotional sentiment. Reply with exactly one lowercase word: positive, negative, or neutral.",
+      messages: [{ role: "user", content: [{ type: "text", text: input }] }],
+      tools: [],
+      abortSignal: controller.signal,
+      maxOutputTokens: 8,
+      temperature: 0,
+      reasoningEffort: "low",
+    })) {
+      const typedEvent = event as EngineEvent;
+      if (typedEvent.type === "text-delta") output += typedEvent.text;
+      if (typedEvent.type === "assistant-content") {
+        finalOutput = typedEvent.parts
+          .filter((part) => part.type === "text")
+          .map((part) => part.text)
+          .join("");
+      }
+      if (typedEvent.type === "stop" && typedEvent.reason === "error") {
+        return null;
+      }
+    }
+    return parseInferredSentiment(finalOutput || output);
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * Best-effort classifier + content-free tracking emit. The main chat path
+ * awaits this only after the user-visible response has finished streaming.
+ */
+export async function inferAndTrackSentiment(args: {
+  /** Test/custom seam. Production intentionally uses the managed Builder engine. */
+  engine?: AgentEngine;
+  classifierModel: string;
+  precedingResponseModel: string;
+  text: string;
+  precedingRunId: string;
+  classificationTriggerRunId: string;
+  threadId: string | null;
+  userId: string | null;
+  sampleRate: number;
+}): Promise<void> {
+  try {
+    if (
+      !shouldSampleInferredSentiment(
+        args.classificationTriggerRunId,
+        args.sampleRate,
+      )
+    ) {
+      return;
+    }
+    const engine =
+      args.engine ??
+      (await import("../agent/engine/builder-engine.js")).createBuilderEngine();
+    const sentiment = await classifySentiment({
+      engine,
+      model: args.classifierModel,
+      text: args.text,
+    });
+    if (!sentiment) return;
+
+    const { track } = await import("../tracking/registry.js");
+    track(
+      "$ai_sentiment",
+      {
+        ...trackingIdentityProperties(),
+        source: "agent_observability",
+        method: "llm",
+        sentiment,
+        model: args.precedingResponseModel,
+        classifier_model: args.classifierModel,
+        classifier_engine: engine.name,
+        attribution: "user_reaction_to_preceding_model",
+        run_id: args.precedingRunId,
+        classification_trigger_run_id: args.classificationTriggerRunId,
+        thread_id: args.threadId,
+        $ai_model: args.precedingResponseModel,
+        $ai_trace_id: args.precedingRunId,
+        $ai_session_id: args.threadId ?? undefined,
+      },
+      { userId: args.userId ?? undefined },
+    );
+  } catch {
+    // Inference and analytics are both optional and must never affect chat.
+  }
+}

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

@@ -263,6 +263,10 @@ export async function ensureObservabilityTables(): Promise<void> {
           "idx_trace_summaries_user",
           `CREATE INDEX IF NOT EXISTS idx_trace_summaries_user ON agent_trace_summaries (user_id, created_at)`,
         );
+        await ensureIndexExists(
+          "idx_trace_summaries_thread_user_created",
+          `CREATE INDEX IF NOT EXISTS idx_trace_summaries_thread_user_created ON agent_trace_summaries (thread_id, user_id, created_at)`,
+        );
         await ensureIndexExists(
           "idx_trace_spans_user",
           `CREATE INDEX IF NOT EXISTS idx_trace_spans_user ON agent_trace_spans (user_id)`,
@@ -360,6 +364,7 @@ export async function ensureObservabilityTables(): Promise<void> {
         `CREATE INDEX IF NOT EXISTS idx_trace_spans_created ON agent_trace_spans (created_at)`,
         `CREATE INDEX IF NOT EXISTS idx_trace_summaries_created ON agent_trace_summaries (created_at)`,
         `CREATE INDEX IF NOT EXISTS idx_trace_summaries_user ON agent_trace_summaries (user_id, created_at)`,
+        `CREATE INDEX IF NOT EXISTS idx_trace_summaries_thread_user_created ON agent_trace_summaries (thread_id, user_id, created_at)`,
         `CREATE INDEX IF NOT EXISTS idx_trace_spans_user ON agent_trace_spans (user_id)`,
         `CREATE INDEX IF NOT EXISTS idx_feedback_thread ON agent_feedback (thread_id)`,
         `CREATE INDEX IF NOT EXISTS idx_feedback_created ON agent_feedback (created_at)`,
@@ -594,6 +599,24 @@ export async function getTraceSummary(
   return rowToTraceSummary(rows[0] as any);
 }
 
+/** Latest completed response in a thread, always scoped to its owner. */
+export async function getLatestTraceSummaryForThread(
+  threadId: string,
+  opts: { userId: string; excludeRunId: string },
+): Promise<TraceSummary | null> {
+  await ensureObservabilityTables();
+  const client = getDbExec();
+  const { rows } = await client.execute({
+    sql: `SELECT * FROM agent_trace_summaries
+      WHERE thread_id = ? AND user_id = ? AND run_id <> ?
+      ORDER BY created_at DESC
+      LIMIT 1`,
+    args: [threadId, opts.userId, opts.excludeRunId],
+  });
+  if (rows.length === 0) return null;
+  return rowToTraceSummary(rows[0] as any);
+}
+
 // ─── Feedback CRUD ───────────────────────────────────────────────────
 
 export async function insertFeedback(entry: FeedbackEntry): Promise<void> {

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

@@ -1,6 +1,7 @@
 import type { AgentLoopUsage } from "../agent/production-agent.js";
 import type { AgentChatEvent, AgentToolInput } from "../agent/types.js";
 import { type AgentSpan, endAgentSpan, startAgentSpan } from "./tracing.js";
+import { trackingIdentityProperties } from "./tracking-identity.js";
 import type { TraceSpan, TraceSummary, ObservabilityConfig } from "./types.js";
 import { DEFAULT_OBSERVABILITY_CONFIG } from "./types.js";
 
@@ -8,61 +9,6 @@ function spanId(): string {
   return `span-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
 
-function normalizeTrackingSlug(value: string | undefined): string | undefined {
-  const raw = value?.trim().toLowerCase();
-  if (!raw) return undefined;
-  return raw
-    .replace(/^@agent-native\//, "")
-    .replace(/[^a-z0-9._-]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-}
-
-function appSlugFromUrl(value: string | undefined): string | undefined {
-  if (!value?.trim()) return undefined;
-  try {
-    const raw = /^[a-z][a-z0-9+.-]*:\/\//i.test(value)
-      ? value
-      : `https://${value}`;
-    const hostname = new URL(raw).hostname.toLowerCase();
-    if (hostname.endsWith(".agent-native.com")) {
-      return normalizeTrackingSlug(
-        hostname.slice(0, -".agent-native.com".length),
-      );
-    }
-    return normalizeTrackingSlug(hostname.split(".")[0]);
-  } catch {
-    return undefined;
-  }
-}
-
-function trackingIdentityProperties(): Record<string, string> {
-  const packageApp = normalizeTrackingSlug(process.env.npm_package_name);
-  const urlApp =
-    appSlugFromUrl(process.env.APP_URL) ||
-    appSlugFromUrl(process.env.BETTER_AUTH_URL) ||
-    appSlugFromUrl(process.env.URL) ||
-    appSlugFromUrl(process.env.DEPLOY_URL) ||
-    appSlugFromUrl(process.env.VERCEL_PROJECT_PRODUCTION_URL) ||
-    appSlugFromUrl(process.env.VERCEL_URL);
-  const app =
-    normalizeTrackingSlug(process.env.AGENT_NATIVE_APP) ||
-    normalizeTrackingSlug(process.env.VITE_AGENT_NATIVE_APP) ||
-    urlApp ||
-    packageApp ||
-    normalizeTrackingSlug(process.env.APP_NAME);
-  const template =
-    normalizeTrackingSlug(process.env.AGENT_NATIVE_TEMPLATE) ||
-    normalizeTrackingSlug(process.env.VITE_AGENT_NATIVE_TEMPLATE) ||
-    normalizeTrackingSlug(process.env.APP_TEMPLATE) ||
-    normalizeTrackingSlug(process.env.VITE_APP_TEMPLATE) ||
-    app;
-
-  return {
-    ...(app ? { app, agent_native_app: app } : {}),
-    ...(template ? { template, agent_native_template: template } : {}),
-  };
-}
-
 function llmProviderFromEngine(
   engineName: string | undefined,
   model: string,
@@ -219,17 +165,19 @@ function redactWalk(value: unknown, seen: WeakSet<object>): unknown {
 }
 
 export async function getObservabilityConfig(): Promise<ObservabilityConfig> {
+  let stored: Partial<ObservabilityConfig> | null = null;
   try {
     const { getSetting } = await import("../settings/store.js");
-    const stored = await getSetting("observability-config");
-    if (stored) {
-      return {
-        ...DEFAULT_OBSERVABILITY_CONFIG,
-        ...stored,
-      } as ObservabilityConfig;
-    }
+    stored = (await getSetting(
+      "observability-config",
+    )) as Partial<ObservabilityConfig> | null;
   } catch {}
-  return DEFAULT_OBSERVABILITY_CONFIG;
+  const { resolveInferredSentimentConfig } = await import("./sentiment.js");
+  return {
+    ...DEFAULT_OBSERVABILITY_CONFIG,
+    ...(stored ?? {}),
+    ...resolveInferredSentimentConfig(stored),
+  };
 }
 
 export async function instrumentAgentLoop(opts: {
@@ -269,6 +217,8 @@ export async function instrumentAgentLoop(opts: {
     variantId: string;
   }>;
   modelSelectionSource?: string;
+  /** Raw user-authored message before prompt/context enrichment. */
+  sentimentInput?: string;
   classifyError?: (error: unknown) =>
     | {
         status?: "success" | "error";
@@ -281,6 +231,17 @@ export async function instrumentAgentLoop(opts: {
   const { runAgentLoop, loopOpts, runId, threadId, userId, config } = opts;
   const runStart = Date.now();
   const parentSpanId = spanId();
+  const precedingResponsePromise =
+    config.inferredSentimentEnabled && opts.sentimentInput && threadId && userId
+      ? import("./store.js")
+          .then(({ getLatestTraceSummaryForThread }) =>
+            getLatestTraceSummaryForThread(threadId, {
+              userId,
+              excludeRunId: runId,
+            }),
+          )
+          .catch(() => null)
+      : Promise.resolve(null);
 
   // Optional OpenTelemetry root span for this run. No-ops unless a host has
   // installed `@opentelemetry/api` and registered a provider. The promise is
@@ -627,6 +588,31 @@ export async function instrumentAgentLoop(opts: {
     }
   }
 
+  // Classify only after the main loop has finished so the tiny managed Luna
+  // request cannot contend with the user's response for a gateway slot. This
+  // short, awaited tail keeps serverless runtimes alive long enough to emit the
+  // event, while the response content has already streamed to the client.
+  if (usage && opts.sentimentInput) {
+    try {
+      const precedingResponse = await precedingResponsePromise;
+      if (precedingResponse) {
+        const { inferAndTrackSentiment } = await import("./sentiment.js");
+        await inferAndTrackSentiment({
+          classifierModel: config.inferredSentimentModel,
+          precedingResponseModel: precedingResponse.model,
+          text: opts.sentimentInput,
+          precedingRunId: precedingResponse.runId,
+          classificationTriggerRunId: runId,
+          threadId,
+          userId,
+          sampleRate: config.inferredSentimentSampleRate,
+        });
+      }
+    } catch {
+      // Optional inference must never alter the result of the main run.
+    }
+  }
+
   return usage!;
 }
 

package/corpus/core/src/observability/tracking-identity.ts

@@ -0,0 +1,55 @@
+function normalizeTrackingSlug(value: string | undefined): string | undefined {
+  const raw = value?.trim().toLowerCase();
+  if (!raw) return undefined;
+  return raw
+    .replace(/^@agent-native\//, "")
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function appSlugFromUrl(value: string | undefined): string | undefined {
+  if (!value?.trim()) return undefined;
+  try {
+    const raw = /^[a-z][a-z0-9+.-]*:\/\//i.test(value)
+      ? value
+      : `https://${value}`;
+    const hostname = new URL(raw).hostname.toLowerCase();
+    if (hostname.endsWith(".agent-native.com")) {
+      return normalizeTrackingSlug(
+        hostname.slice(0, -".agent-native.com".length),
+      );
+    }
+    return normalizeTrackingSlug(hostname.split(".")[0]);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Shared app/template dimensions for central observability tracking events. */
+export function trackingIdentityProperties(): Record<string, string> {
+  const packageApp = normalizeTrackingSlug(process.env.npm_package_name);
+  const urlApp =
+    appSlugFromUrl(process.env.APP_URL) ||
+    appSlugFromUrl(process.env.BETTER_AUTH_URL) ||
+    appSlugFromUrl(process.env.URL) ||
+    appSlugFromUrl(process.env.DEPLOY_URL) ||
+    appSlugFromUrl(process.env.VERCEL_PROJECT_PRODUCTION_URL) ||
+    appSlugFromUrl(process.env.VERCEL_URL);
+  const app =
+    normalizeTrackingSlug(process.env.AGENT_NATIVE_APP) ||
+    normalizeTrackingSlug(process.env.VITE_AGENT_NATIVE_APP) ||
+    urlApp ||
+    packageApp ||
+    normalizeTrackingSlug(process.env.APP_NAME);
+  const template =
+    normalizeTrackingSlug(process.env.AGENT_NATIVE_TEMPLATE) ||
+    normalizeTrackingSlug(process.env.VITE_AGENT_NATIVE_TEMPLATE) ||
+    normalizeTrackingSlug(process.env.APP_TEMPLATE) ||
+    normalizeTrackingSlug(process.env.VITE_APP_TEMPLATE) ||
+    app;
+
+  return {
+    ...(app ? { app, agent_native_app: app } : {}),
+    ...(template ? { template, agent_native_template: template } : {}),
+  };
+}