@agent-native/core 0.97.0 → 0.98.0

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 } : {}),
+  };
+}

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

@@ -179,6 +179,16 @@ export interface ObservabilityConfig {
   captureToolArgs: boolean;
   captureToolResults: boolean;
   evalSampleRate: number;
+  /**
+   * Classify the raw user message as positive, negative, or neutral. Off by
+   * default for self-hosted apps; first-party agent-native.com deployments
+   * enable it automatically unless explicitly disabled.
+   */
+  inferredSentimentEnabled: boolean;
+  /** Deterministic fraction of eligible user messages to classify (0-1). */
+  inferredSentimentSampleRate: number;
+  /** Model used by the managed Builder classifier. */
+  inferredSentimentModel: string;
   exporters: ObservabilityExporterConfig[];
 }
 
@@ -194,5 +204,8 @@ export const DEFAULT_OBSERVABILITY_CONFIG: ObservabilityConfig = {
   captureToolArgs: false,
   captureToolResults: false,
   evalSampleRate: 0,
+  inferredSentimentEnabled: false,
+  inferredSentimentSampleRate: 0,
+  inferredSentimentModel: "gpt-5-6-luna",
   exporters: [],
 };

package/corpus/core/src/secrets/storage.ts

@@ -201,6 +201,40 @@ export interface ReadSecretResult {
   updatedAt: number;
 }
 
+type AppSecretsReadQuery = { sql: string; args: unknown[] };
+
+/**
+ * True only when the database says the app_secrets table itself is missing.
+ * Other query failures must propagate unchanged: attempting schema bootstrap
+ * for connectivity, permission, or syntax errors both hides the real failure
+ * and can introduce DDL onto a latency-sensitive read path.
+ */
+function isMissingAppSecretsTableError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  const code = String((error as Error & { code?: unknown }).code ?? "");
+  const message = error.message.toLowerCase();
+  const namesAppSecrets = /(?:app_secrets|"app_secrets")/.test(message);
+
+  if (code === "42P01") return namesAppSecrets;
+  return (
+    namesAppSecrets &&
+    (message.includes("no such table") ||
+      (message.includes("relation") && message.includes("does not exist")))
+  );
+}
+
+/** Execute a read without schema probes on the normal path. */
+async function executeAppSecretsRead(query: AppSecretsReadQuery) {
+  const client = getDbExec();
+  try {
+    return await client.execute(query);
+  } catch (error) {
+    if (!isMissingAppSecretsTableError(error)) throw error;
+    await ensureTable();
+    return client.execute(query);
+  }
+}
+
 /**
  * Read a secret's plaintext value. Returns null when not found. The caller
  * is responsible for never logging the returned value.
@@ -208,10 +242,8 @@ export interface ReadSecretResult {
 export async function readAppSecret(
   ref: SecretRef,
 ): Promise<ReadSecretResult | null> {
-  await ensureTable();
   const { key, scope, scopeId } = ref;
-  const client = getDbExec();
-  const { rows } = await client.execute({
+  const { rows } = await executeAppSecretsRead({
     sql: `SELECT encrypted_value, updated_at FROM app_secrets WHERE scope = ? AND scope_id = ? AND key = ? LIMIT 1`,
     args: [scope, scopeId, key],
   });
@@ -230,6 +262,38 @@ export async function readAppSecret(
   }
 }
 
+/** Read several keys from one scope in a single database round trip. */
+export async function readAppSecrets(args: {
+  keys: readonly string[];
+  scope: SecretScope;
+  scopeId: string;
+}): Promise<Map<string, ReadSecretResult>> {
+  const keys = [...new Set(args.keys.filter(Boolean))];
+  if (keys.length === 0) return new Map();
+
+  const placeholders = keys.map(() => "?").join(", ");
+  const { rows } = await executeAppSecretsRead({
+    sql: `SELECT key, encrypted_value, updated_at FROM app_secrets WHERE scope = ? AND scope_id = ? AND key IN (${placeholders})`,
+    args: [args.scope, args.scopeId, ...keys],
+  });
+  const results = new Map<string, ReadSecretResult>();
+  for (const row of rows) {
+    const key = String(row.key ?? "");
+    if (!key) continue;
+    try {
+      const value = decryptValue(row.encrypted_value as string);
+      results.set(key, {
+        value,
+        last4: last4(value),
+        updatedAt: Number(row.updated_at ?? 0),
+      });
+    } catch {
+      // Match readAppSecret: corrupted or stale ciphertext behaves as missing.
+    }
+  }
+  return results;
+}
+
 /**
  * Return just the metadata for a secret (no value). Used by the list route so
  * the UI can show the "Set" pill and last-4 without the decrypted value going

package/corpus/core/src/server/agent-chat/action-filters-a2a.ts

@@ -0,0 +1,199 @@
+import { getHeader } from "h3";
+
+import {
+  appendA2AArtifactLinks,
+  type A2AArtifactResponseOptions,
+  type A2AToolResultSummary,
+} from "../../a2a/artifact-response.js";
+import { collectFinalResponseTextFromAgentEvents } from "../../a2a/response-text.js";
+import type { EngineTool } from "../../agent/engine/types.js";
+import {
+  filterInitialEngineTools,
+  type ActionEntry,
+} from "../../agent/production-agent.js";
+import { runAgentLoopDirectWithSoftTimeout } from "../../agent/run-loop-with-resume.js";
+import type { AgentChatEvent } from "../../agent/types.js";
+import { withConfiguredAppBasePath } from "../app-base-path.js";
+import type { AgentChatPluginOptions } from "./plugin-options.js";
+
+// ---------------------------------------------------------------------------
+// Action-visibility filters (read-only / agent-exposed / public-agent-safe)
+// and the A2A (agent-to-agent) final-response assembly + delegated-run
+// helpers that share those filters.
+// ---------------------------------------------------------------------------
+
+export function filterReadOnlyActions(
+  actions: Record<string, ActionEntry>,
+): Record<string, ActionEntry> {
+  return Object.fromEntries(
+    Object.entries(actions).filter(([, entry]) => entry.readOnly === true),
+  );
+}
+
+/** Drop actions that opted out of agent exposure via `agentTool: false`. They
+ *  remain callable from the frontend / HTTP (mounted separately from this
+ *  agent tool surface — see `httpActions`) but never appear in any agent tool
+ *  list (in-app assistant, MCP, A2A, job/trigger runners) or actions prompt.
+ *  Default-allow: only an explicit `false` is excluded. */
+export function filterAgentTools(
+  actions: Record<string, ActionEntry>,
+): Record<string, ActionEntry> {
+  return Object.fromEntries(
+    Object.entries(actions).filter(([, entry]) => entry.agentTool !== false),
+  );
+}
+
+export function filterPublicAgentActions(
+  actions: Record<string, ActionEntry>,
+): Record<string, ActionEntry> {
+  return Object.fromEntries(
+    Object.entries(actions).filter(([, entry]) => {
+      const config = entry.publicAgent;
+      return (
+        config?.expose === true &&
+        config.readOnly === true &&
+        config.requiresAuth !== true &&
+        config.isConsequential !== true
+      );
+    }),
+  );
+}
+
+export function buildPublicAgentA2ASkills(
+  actions: Record<string, ActionEntry>,
+): Array<{
+  id: string;
+  name: string;
+  description: string;
+  publicAgent: ActionEntry["publicAgent"];
+}> {
+  return Object.entries(filterPublicAgentActions(actions)).map(
+    ([name, entry]) => ({
+      id: name,
+      name,
+      description: entry.tool.description,
+      publicAgent: entry.publicAgent,
+    }),
+  );
+}
+
+export function resolveArtifactBaseUrl(
+  event: any | undefined,
+): string | undefined {
+  const fromEnv =
+    process.env.APP_URL ||
+    process.env.URL ||
+    process.env.DEPLOY_URL ||
+    process.env.BETTER_AUTH_URL;
+  if (fromEnv) return withConfiguredAppBasePath(String(fromEnv));
+
+  try {
+    const proto = getHeader(event, "x-forwarded-proto") || "https";
+    const host = getHeader(event, "host");
+    if (host) return withConfiguredAppBasePath(`${proto}://${host}`);
+  } catch {}
+
+  return undefined;
+}
+
+export function assembleA2AFinalResponse(
+  events: readonly AgentChatEvent[],
+  toolResults: readonly A2AToolResultSummary[],
+  options: A2AArtifactResponseOptions & { event?: any } = {},
+): { responseText: string; finalText: string } {
+  const terminalError = getA2ATerminalErrorEvent(events);
+  const responseText = collectFinalResponseTextFromAgentEvents(events, {
+    fallbackToPreToolText: !terminalError,
+  });
+  const finalText = appendA2AArtifactLinks(responseText, [...toolResults], {
+    baseUrl: options.baseUrl ?? resolveArtifactBaseUrl(options.event),
+    includeReferencedArtifacts: true,
+  });
+  if (terminalError && !finalText.trim()) {
+    throw new Error(formatA2ATerminalError(terminalError));
+  }
+  return { responseText, finalText };
+}
+
+function getA2ATerminalErrorEvent(
+  events: readonly AgentChatEvent[],
+): Extract<AgentChatEvent, { type: "error" }> | null {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.type === "clear") continue;
+    if (event.type === "done") return null;
+    if (event.type === "error") return event;
+    if (event.type === "auto_continue") {
+      return {
+        type: "error",
+        error: `Agent stopped before finishing (${event.reason}).`,
+        errorCode: event.reason,
+        recoverable: true,
+      };
+    }
+  }
+  return null;
+}
+
+function formatA2ATerminalError(
+  event: Extract<AgentChatEvent, { type: "error" }>,
+): string {
+  const parts = [
+    event.error || "Agent failed before producing a final response.",
+    event.errorCode ? `code: ${event.errorCode}` : "",
+    event.details ? `details: ${event.details}` : "",
+  ].filter(Boolean);
+  return parts.join("\n");
+}
+
+type A2AAgentLoopRunner = typeof runAgentLoopDirectWithSoftTimeout;
+
+/**
+ * Run an A2A-delegated agent turn with the same final-response guard used by
+ * the app's interactive chat surface.
+ *
+ * Keeping this in one helper prevents delegated calls from silently bypassing
+ * template guarantees such as Analytics' requirement to query real data
+ * before presenting metrics or exhaustive provider conclusions.
+ */
+export function runA2AAgentLoop(
+  runOptions: Parameters<A2AAgentLoopRunner>[0],
+  pluginOptions: Pick<
+    AgentChatPluginOptions,
+    "finalResponseGuard" | "runSoftTimeoutMs"
+  >,
+  timeoutOptions: Parameters<A2AAgentLoopRunner>[2],
+  runner: A2AAgentLoopRunner = runAgentLoopDirectWithSoftTimeout,
+) {
+  return runner(
+    {
+      ...runOptions,
+      finalResponseGuard: pluginOptions.finalResponseGuard,
+    },
+    pluginOptions.runSoftTimeoutMs,
+    timeoutOptions,
+  );
+}
+
+/**
+ * Keep delegated A2A turns on the same compact initial tool surface as
+ * interactive chat. `tool-search` remains in the initial set, while the
+ * complete registry is supplied separately so the run loop can load a matched
+ * schema after a tool-search result.
+ */
+export function createA2AEngineToolSurface(
+  availableTools: EngineTool[],
+  initialToolNames?: string[],
+): { tools: EngineTool[]; availableTools: EngineTool[] } {
+  return {
+    tools: filterInitialEngineTools(availableTools, initialToolNames),
+    availableTools,
+  };
+}
+
+export function resolveInitialToolNames(
+  templateActions: Record<string, ActionEntry>,
+  configured?: string[],
+): string[] {
+  return configured ?? Object.keys(templateActions);
+}