@agent-native/core 0.97.0 → 0.98.0

package/corpus/core/src/integrations/plugin.ts

@@ -617,6 +617,13 @@ export function createIntegrationsPlugin(
       ...localActions,
       ...callAgentEntry,
     } as typeof localActions;
+    // Keep the app's own actions visible on the first request to the model;
+    // defer the framework additions merged in above (integration memory,
+    // call-agent) behind the tool-search entry `handleWebhook` /
+    // `startGoogleDocsPoller` attach to `actions`. The run loop's mid-run
+    // tool expansion still lets the model discover and call them after a
+    // search — see `filterInitialEngineTools` / `expandActiveTools`.
+    const initialToolNames = Object.keys(localActions);
 
     const h3 = getH3App(nitroApp);
     const P = `${FRAMEWORK_ROUTE_PREFIX}/integrations`;
@@ -1544,6 +1551,7 @@ export function createIntegrationsPlugin(
                 adapter,
                 systemPrompt: baseSystemPrompt + resources,
                 actions,
+                initialToolNames,
                 model,
                 apiKey: getApiKey(),
                 engine: options?.engine,
@@ -2385,6 +2393,7 @@ export function createIntegrationsPlugin(
             // where providers such as Discord enforce a 3-second deadline.
             systemPrompt: baseSystemPrompt,
             actions,
+            initialToolNames,
             model,
             apiKey: getApiKey(),
             engine: options?.engine,
@@ -2509,6 +2518,7 @@ export function createIntegrationsPlugin(
         void startGoogleDocsPoller({
           systemPrompt: baseSystemPrompt,
           actions,
+          initialToolNames,
           model: model ?? "",
           apiKey: getApiKey(),
           ownerEmail: "integration@google-docs",

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

@@ -21,6 +21,7 @@ import type { AgentEngine, EngineMessage } from "../agent/engine/types.js";
 import {
   runAgentLoop,
   actionsToEngineTools,
+  filterInitialEngineTools,
   getOwnerActiveApiKey,
   getOwnerApiKey,
   engineToProvider,
@@ -35,6 +36,7 @@ import {
   buildAssistantMessage,
   extractThreadMeta,
 } from "../agent/thread-data-builder.js";
+import { attachToolSearch } from "../agent/tool-search.js";
 import { createThread, getThread } from "../chat-threads/store.js";
 import { updateThreadData } from "../chat-threads/store.js";
 import { isLocalDatabase } from "../db/client.js";
@@ -113,6 +115,17 @@ export interface WebhookHandlerOptions {
   systemPrompt: string;
   /** Action entries for the agent */
   actions: Record<string, ActionEntry>;
+  /**
+   * Tool names to expose on the FIRST engine request. When provided, every
+   * other name in `actions` (framework additions such as
+   * `list-integration-memory` / `call-agent` merged in by
+   * `createIntegrationsPlugin`) is deferred behind the attached `tool-search`
+   * entry instead of being serialized on every inbound message — the run
+   * loop's mid-run tool expansion (`expandActiveTools` in `runAgentLoop`)
+   * still lets the model discover and call them after a search. Omit to keep
+   * the full `actions` set visible up front (current behavior).
+   */
+  initialToolNames?: string[];
   /** Model to use. Defaults to the resolved engine's default model. */
   model?: string;
   /** Anthropic API key */
@@ -573,6 +586,7 @@ async function processIncomingMessage(
     adapter,
     systemPrompt,
     actions,
+    initialToolNames,
     model,
     apiKey,
     ownerEmail,
@@ -763,10 +777,20 @@ async function processIncomingMessage(
   // A2A delegation. Without this, getRequestOrgId() returns undefined and
   // call-agent can't look up the org's a2a_secret or org_domain.
   let orgId: string | null | undefined;
+  let runnableActions: Record<string, ActionEntry>;
   let tools: ReturnType<typeof actionsToEngineTools>;
+  let availableTools: ReturnType<typeof actionsToEngineTools>;
   try {
     orgId = opts.orgId ?? (await resolveOrgIdForEmail(ownerEmail));
-    tools = actionsToEngineTools(actions);
+    // Attach tool-search on a shallow copy so framework additions merged in
+    // by `createIntegrationsPlugin` (integration memory, `call-agent`) can be
+    // deferred behind it without mutating the plugin's long-lived registry.
+    // `runAgentLoop`'s `expandActiveTools` re-expands from `availableTools`
+    // after a tool-search call, so anything filtered out of the initial
+    // `tools` list stays reachable.
+    runnableActions = attachToolSearch({ ...actions });
+    availableTools = actionsToEngineTools(runnableActions);
+    tools = filterInitialEngineTools(availableTools, initialToolNames);
   } catch (error) {
     await releaseApplicableIntegrationBudgets(budgetReservations.reservations);
     throw error;
@@ -855,8 +879,9 @@ async function processIncomingMessage(
               model: resolvedModel,
               systemPrompt: effectiveSystemPrompt,
               tools,
+              availableTools,
               messages,
-              actions,
+              actions: runnableActions,
               send: async (event) => {
                 if (progress) {
                   await Promise.resolve(progress.onEvent(event)).catch(

package/corpus/core/src/jobs/scheduler.ts

@@ -8,10 +8,12 @@ import type { AgentEngine } from "../agent/engine/types.js";
 import {
   runAgentLoop,
   actionsToEngineTools,
+  filterInitialEngineTools,
   getOwnerActiveApiKey,
   type ActionEntry,
 } from "../agent/production-agent.js";
 import { startRun, resolveRunSoftTimeoutMs } from "../agent/run-manager.js";
+import { attachToolSearch } from "../agent/tool-search.js";
 import { createThread } from "../chat-threads/store.js";
 import {
   organizationIdFromResourceOwner,
@@ -175,6 +177,18 @@ export function buildJobContent(meta: JobFrontmatter, body: string): string {
 export interface SchedulerDeps {
   getActions: () => Record<string, ActionEntry>;
   getSystemPrompt: (owner: string) => Promise<string>;
+  /**
+   * Tool names to expose on the FIRST engine request for a job run. When
+   * provided, every other action returned by `getActions()` is deferred
+   * behind an attached `tool-search` entry instead of being serialized on
+   * every scheduled tick — `runAgentLoop`'s mid-run tool expansion
+   * (`expandActiveTools`) still lets the model discover and call them after
+   * a search. Omit to keep the full `getActions()` set visible up front
+   * (current behavior). The caller (not this module) knows which of the
+   * merged actions are the app's own vs. framework additions, so this must
+   * be supplied explicitly rather than inferred here.
+   */
+  getInitialToolNames?: () => string[] | undefined;
   /** Optional engine override. Defaults to the resolved request engine. */
   engine?: AgentEngine;
   apiKey?: string;
@@ -463,9 +477,20 @@ async function executeJob(
     },
     async () => {
       try {
-        const actions = deps.getActions();
+        const baseActions = deps.getActions();
         const systemPrompt = await deps.getSystemPrompt(jobUserEmail);
-        const tools = actionsToEngineTools(actions);
+        const initialToolNames = deps.getInitialToolNames?.();
+        // Only attach tool-search (and pay its schema cost) when the caller
+        // actually supplied an initial subset to filter down to — otherwise
+        // this is byte-for-byte the prior unfiltered behavior.
+        const actions = initialToolNames
+          ? attachToolSearch({ ...baseActions })
+          : baseActions;
+        const availableTools = actionsToEngineTools(actions);
+        const tools = filterInitialEngineTools(
+          availableTools,
+          initialToolNames,
+        );
 
         // Prefer the job runner's saved Anthropic key so recurring jobs
         // don't silently bill the shared platform key once a user has
@@ -537,6 +562,7 @@ async function executeJob(
                   model,
                   systemPrompt,
                   tools,
+                  availableTools,
                   messages,
                   actions,
                   send,

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

@@ -218,7 +218,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 +227,7 @@ const messages = {
       showChat: "Show chat",
       hideChat: "Hide chat",
       end: "End voice mode",
+      microphoneSettings: "Microphone settings",
       status: {
         connecting: "Connecting",
         listening: "Listening",
@@ -408,6 +409,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/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> {