@agent-native/core 0.176.5 → 0.176.6-nightly-20260903194620

package/dist/automation/index.d.ts

@@ -186,8 +186,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
-    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
+    error?: undefined;
 }>;

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/observability/traces.js

@@ -1,7 +1,7 @@
 import { captureError } from "../server/capture-error.js";
 import { getRequestContext } from "../server/request-context.js";
 import { MAX_AI_CONTENT_BYTES, MAX_AI_SPANS_PER_RUN, boundAiContent, emitAiSpanEvent, emitAiTraceEvent, resolveAiError, toAiErrorDetail, toPostHogMessages, } from "./posthog-ai.js";
-import { endAgentSpan, startAgentSpan } from "./tracing.js";
+import { endAgentSpan, startAgentSpan, withAgentSpanContext, } from "./tracing.js";
 import { trackingIdentityProperties } from "./tracking-identity.js";
 function spanId() {
     return `span-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
@@ -384,10 +384,9 @@ export async function instrumentAgentLoop(opts) {
     // don't have to thread it down by hand.
     const browserSessionId = opts.browserSessionId ?? getRequestContext()?.browserSessionId;
     // Optional OpenTelemetry root span for this run. No-ops unless a host has
-    // installed `@opentelemetry/api` and registered a provider. The promise is
-    // resolved before the loop runs so child tool/model spans can parent under
-    // it conceptually (we keep them flat in the same tracer, which is enough
-    // for the dashboards an embedding app would build).
+    // installed `@opentelemetry/api` and registered a provider. The root is
+    // installed as the active context while the loop runs so child tool/model
+    // spans have a real parent relationship in the exported trace.
     const otelRunSpanPromise = startAgentSpan("agent.run", {
         "agent.run_id": runId,
         "agent.thread_id": threadId ?? undefined,
@@ -401,6 +400,7 @@ export async function instrumentAgentLoop(opts) {
             ? opts.experimentAssignments[0].variantId
             : undefined,
     });
+    let otelRunSpan = null;
     const spans = [];
     let toolInvocationCounter = 0;
     // Keyed by counter to handle concurrent calls to the same tool name
@@ -433,6 +433,82 @@ export async function instrumentAgentLoop(opts) {
     /** The call currently streaming, or the last one that streamed — text and
      *  usage arriving between calls belong to the call that just finished. */
     const currentRoundTrip = () => modelRoundTrips[modelRoundTrips.length - 1];
+    let calculateCost;
+    const calculateUsageCost = (callUsage) => {
+        if (!calculateCost || !callUsage)
+            return undefined;
+        try {
+            return calculateCost(callUsage.inputTokens, callUsage.outputTokens, callUsage.model, callUsage.cacheReadTokens, callUsage.cacheWriteTokens);
+        }
+        catch {
+            // coercion-ok: cost estimation is enrichment and cannot fail tracing.
+            return undefined;
+        }
+    };
+    const pendingOtelModelSpans = new Map();
+    const openOtelModelSpans = new Set();
+    const modelSpansAwaitingFinalError = new Set();
+    const modelSpanAttributes = (index) => {
+        const trip = modelRoundTrips[index];
+        const callUsage = trip?.usage;
+        return {
+            "llm.model": callUsage?.model ?? loopOpts.model,
+            "llm.call_index": index,
+            "llm.stop_reason": trip?.stopReason,
+            "llm.input_tokens": callUsage?.inputTokens,
+            "llm.output_tokens": callUsage?.outputTokens,
+            "llm.cache_read_tokens": callUsage?.cacheReadTokens,
+            "llm.cache_write_tokens": callUsage?.cacheWriteTokens,
+            "llm.cost_cents_x100": calculateUsageCost(callUsage),
+        };
+    };
+    const startOtelModelSpan = (index) => {
+        const entry = {
+            spanPromise: Promise.resolve(null),
+            span: null,
+            endResult: undefined,
+            ended: false,
+        };
+        entry.spanPromise = startAgentSpan("llm.call", {
+            "llm.model": loopOpts.model,
+            "llm.call_index": index,
+        }, otelRunSpan);
+        pendingOtelModelSpans.set(index, entry);
+        void entry.spanPromise.then((span) => {
+            if (!span || entry.ended)
+                return;
+            if (entry.endResult) {
+                entry.ended = true;
+                endAgentSpan(span, entry.endResult);
+            }
+            else {
+                entry.span = span;
+                openOtelModelSpans.add(span);
+            }
+        });
+    };
+    const finishOtelModelSpan = (index, result) => {
+        const entry = pendingOtelModelSpans.get(index);
+        if (!entry || entry.ended)
+            return;
+        entry.endResult = result;
+        if (!entry.span)
+            return;
+        entry.ended = true;
+        openOtelModelSpans.delete(entry.span);
+        endAgentSpan(entry.span, result);
+    };
+    const finishAwaitingOtelModelSpans = (finalErrorMessage = null) => {
+        for (const tripIndex of modelSpansAwaitingFinalError) {
+            finishOtelModelSpan(tripIndex, {
+                status: "error",
+                errorMessage: finalErrorMessage ?? "Model stream ended before completion.",
+                attributes: modelSpanAttributes(tripIndex),
+                endTime: modelRoundTrips[tripIndex]?.end,
+            });
+        }
+        modelSpansAwaitingFinalError.clear();
+    };
     const modelStreamIntervals = [];
     let modelStreamOpenedAt = null;
     /** Tool span id → the round-trip that requested it. */
@@ -507,6 +583,7 @@ export async function instrumentAgentLoop(opts) {
             // counted as a successful delegated generation. A later clear/done means
             // the wrapper recovered and finished cleanly, so reset in that case.
             if (event.type === "clear" || event.type === "done") {
+                finishAwaitingOtelModelSpans();
                 runStatus = "success";
                 errorMessage = null;
                 cutOffReason = null;
@@ -539,8 +616,13 @@ export async function instrumentAgentLoop(opts) {
                 // The emitter brackets these itself, so a repeated start or an
                 // unmatched end is a no-op here rather than a fabricated interval.
                 if (event.status === "start") {
+                    // A reasonless closure is emitted before the agent loop decides
+                    // whether to retry. If another attempt starts, the old attempt is
+                    // definitely final and must not span the retry backoff.
+                    finishAwaitingOtelModelSpans();
                     if (modelStreamOpenedAt === null) {
                         modelStreamOpenedAt = Date.now();
+                        const tripIndex = modelRoundTrips.length;
                         modelRoundTrips.push({
                             spanId: spanId(),
                             start: modelStreamOpenedAt,
@@ -561,17 +643,25 @@ export async function instrumentAgentLoop(opts) {
                                 : {}),
                             assistantText: [],
                         });
+                        startOtelModelSpan(tripIndex);
                     }
                 }
                 else if (modelStreamOpenedAt !== null) {
                     const end = Date.now();
                     modelStreamIntervals.push({ start: modelStreamOpenedAt, end });
+                    const tripIndex = modelRoundTrips.length - 1;
                     const trip = currentRoundTrip();
                     if (trip) {
                         trip.end = end;
                         if (event.reason)
                             trip.stopReason = event.reason;
                     }
+                    if (event.reason === undefined || event.reason === "error") {
+                        // The engine emits this from a `finally`, before the outer catch
+                        // has classified a provider error. Defer ending the span so that
+                        // the real error message wins over a generic stream-ended value.
+                        modelSpansAwaitingFinalError.add(tripIndex);
+                    }
                     modelStreamOpenedAt = null;
                 }
             }
@@ -604,7 +694,7 @@ export async function instrumentAgentLoop(opts) {
                     toolCallIdToCounter.set(event.id, counter);
                 void startAgentSpan("tool.call", {
                     "tool.name": event.tool,
-                }).then((span) => {
+                }, otelRunSpan).then((span) => {
                     if (!span)
                         return;
                     // If `tool_done` already ran for this call, end the span now with the
@@ -769,7 +859,8 @@ export async function instrumentAgentLoop(opts) {
         ? [...loopOpts.messages]
         : loopOpts.messages;
     try {
-        usage = await runAgentLoop({
+        otelRunSpan = await otelRunSpanPromise;
+        usage = await withAgentSpanContext(otelRunSpan, () => runAgentLoop({
             ...loopOpts,
             runId,
             send: instrumentedSend,
@@ -782,7 +873,7 @@ export async function instrumentAgentLoop(opts) {
                     trip.usage = callUsage;
                 loopOpts.onUsage?.(callUsage);
             },
-        });
+        }));
     }
     catch (err) {
         const classification = opts.classifyError?.(err) ?? null;
@@ -814,6 +905,9 @@ export async function instrumentAgentLoop(opts) {
             // model was still running when the run stopped, so the interval closes at
             // the run's end rather than being dropped.
             const failedInsideModelCall = modelStreamOpenedAt !== null;
+            const interruptedModelRoundTrip = modelStreamOpenedAt !== null && modelRoundTrips.length > 0
+                ? modelRoundTrips.length - 1
+                : null;
             if (modelStreamOpenedAt !== null) {
                 modelStreamIntervals.push({ start: modelStreamOpenedAt, end: runEnd });
                 const trip = currentRoundTrip();
@@ -890,7 +984,6 @@ export async function instrumentAgentLoop(opts) {
             let costCentsX100 = 0;
             // Held for the per-generation costs below, which price each round-trip
             // from its own tokens rather than splitting the run total.
-            let calculateCost;
             try {
                 ({ calculateCost } = await import("../usage/store.js"));
                 if (usage) {
@@ -937,8 +1030,8 @@ export async function instrumentAgentLoop(opts) {
                 llmCallCount =
                     usage?.llmCalls ??
                         // Compatibility for custom loop implementations that predate the
-                        // attempt counter: a measured run still counts as one call.
-                        1;
+                        // attempt counter: observed brackets still count every attempt.
+                        (modelRoundTrips.length > 0 ? modelRoundTrips.length : 1);
                 const runUsage = usage ?? {
                     inputTokens: 0,
                     outputTokens: 0,
@@ -1308,13 +1401,34 @@ export async function instrumentAgentLoop(opts) {
                 createdAt: runStart,
             };
             writeTraceData(spans, summary, runId, config).catch(() => { });
-            // OpenTelemetry export (no-op unless a provider is registered). Emit a
-            // self-contained `llm.call` span carrying model + token usage, end any
-            // tool spans still open (loop threw mid-tool), and end the run span. Awaited
-            // so the spans are emitted before the function returns; cheap when no-op.
+            // OpenTelemetry export (no-op unless a provider is registered). Bracketed
+            // model calls have already emitted live spans; engines without brackets
+            // get one aggregate generation. End any tool/model spans still open and
+            // then end the run span. Awaited so spans are emitted before return.
             try {
-                if (usage) {
-                    endAgentSpan(await startAgentSpan("llm.call", {}), {
+                if (interruptedModelRoundTrip !== null) {
+                    finishOtelModelSpan(interruptedModelRoundTrip, {
+                        status: "error",
+                        errorMessage: errorMessage ?? "Model stream interrupted before completion.",
+                        attributes: modelSpanAttributes(interruptedModelRoundTrip),
+                        endTime: runEnd,
+                    });
+                }
+                for (const [tripIndex, trip] of modelRoundTrips.entries()) {
+                    if (trip.stopReason && trip.stopReason !== "error") {
+                        finishOtelModelSpan(tripIndex, {
+                            status: "success",
+                            errorMessage: null,
+                            attributes: modelSpanAttributes(tripIndex),
+                            endTime: trip.end,
+                        });
+                    }
+                }
+                finishAwaitingOtelModelSpans(errorMessage);
+                await Promise.all([...pendingOtelModelSpans.values()].map((entry) => entry.spanPromise));
+                if (usage && modelRoundTrips.length === 0) {
+                    const aggregateLlmSpan = await withAgentSpanContext(otelRunSpan, () => startAgentSpan("llm.call", {}, otelRunSpan));
+                    endAgentSpan(aggregateLlmSpan, {
                         status: runStatus,
                         errorMessage,
                         attributes: {
@@ -1327,6 +1441,13 @@ export async function instrumentAgentLoop(opts) {
                         },
                     });
                 }
+                for (const modelSpan of openOtelModelSpans) {
+                    endAgentSpan(modelSpan, {
+                        status: "error",
+                        errorMessage: "Agent run ended before model_stream completed.",
+                    });
+                }
+                openOtelModelSpans.clear();
                 for (const toolSpan of openOtelToolSpans) {
                     endAgentSpan(toolSpan, {
                         status: "error",
@@ -1334,10 +1455,11 @@ export async function instrumentAgentLoop(opts) {
                     });
                 }
                 openOtelToolSpans.clear();
-                endAgentSpan(await otelRunSpanPromise, {
+                endAgentSpan(otelRunSpan, {
                     status: runStatus,
                     errorMessage,
                     attributes: {
+                        "agent.llm_calls": llmCallCount,
                         "agent.tool_calls": toolCallCount,
                         "agent.successful_tools": successfulTools,
                         "agent.failed_tools": failedTools,

package/dist/observability/tracing.d.ts

@@ -36,7 +36,7 @@ export interface AgentSpan {
         name?: string;
         message: string;
     }): void;
-    end(): void;
+    end(endTime?: unknown): void;
 }
 /** OTel `SpanStatusCode` values, inlined so we don't need the api types here. */
 export declare const SPAN_STATUS_OK = 1;
@@ -44,14 +44,30 @@ export declare const SPAN_STATUS_ERROR = 2;
 interface AgentTracer {
     startSpan(name: string, options?: {
         attributes?: Record<string, string | number | boolean>;
-    }): AgentSpan;
+    }, context?: unknown): AgentSpan;
+}
+interface AgentTraceRuntime {
+    tracer: AgentTracer;
+    context?: {
+        active(): unknown;
+        with<T>(context: unknown, callback: () => T): T;
+    };
+    trace?: {
+        setSpan(context: unknown, span: AgentSpan): unknown;
+    };
 }
 /**
  * Start a span. When OTel isn't installed (or no provider is registered) this
  * returns `null` and the caller simply skips span bookkeeping — there is no
  * runtime cost beyond the cached null check.
  */
-export declare function startAgentSpan(name: string, attributes?: Record<string, string | number | boolean | null | undefined>): Promise<AgentSpan | null>;
+export declare function startAgentSpan(name: string, attributes?: Record<string, string | number | boolean | null | undefined>, parentSpan?: AgentSpan | null): Promise<AgentSpan | null>;
+/**
+ * Run a callback with the supplied span installed as the active OTel span so
+ * spans created by the callback become descendants of it. The bridge is
+ * deliberately best-effort: telemetry setup must never change agent behavior.
+ */
+export declare function withAgentSpanContext<T>(span: AgentSpan | null, callback: () => T): T;
 /**
  * Finish a span, setting OK/ERROR status and recording the error message when
  * present. Safe to call with `null` (no-op) and never throws.
@@ -60,6 +76,7 @@ export declare function endAgentSpan(span: AgentSpan | null, result?: {
     status?: "success" | "error";
     errorMessage?: string | null;
     attributes?: Record<string, string | number | boolean | null | undefined>;
+    endTime?: number;
 }): void;
 /** For tests — reset the cached tracer so a fresh provider can be detected. */
 export declare function __resetAgentTracerCache(): void;
@@ -69,4 +86,6 @@ export declare function __resetAgentTracerCache(): void;
  * to simulate "no tracer available".
  */
 export declare function __setAgentTracerForTests(tracer: AgentTracer | null): void;
+/** For tests — inject a runtime with an active-context implementation. */
+export declare function __setAgentTraceRuntimeForTests(runtime: AgentTraceRuntime | null): void;
 export {};

package/dist/observability/tracing.js

@@ -24,28 +24,36 @@ const TRACER_NAME = "@agent-native/core/agent-loop";
 export const SPAN_STATUS_OK = 1;
 export const SPAN_STATUS_ERROR = 2;
 /**
- * Cached tracer. `undefined` = not yet resolved; `null` = resolved to
- * "no tracer available" (api package missing or load failed).
+ * Cached OTel runtime. `undefined` = not yet resolved; `null` = resolved to
+ * "no runtime available" (api package missing or load failed).
  */
-let cachedTracer;
+let cachedRuntime;
 /**
  * Resolve the OpenTelemetry tracer if `@opentelemetry/api` is installed.
  * Returns `null` (cached) when the package is unavailable so callers can
  * branch to a no-op cheaply on every subsequent call.
  */
-async function resolveTracer() {
-    if (cachedTracer !== undefined)
-        return cachedTracer;
+async function resolveRuntime() {
+    if (cachedRuntime !== undefined)
+        return cachedRuntime;
     try {
         // Optional dependency — guarded import. Absent ⇒ no-op everywhere.
         const otel = await import("@opentelemetry/api");
         const tracer = otel?.trace?.getTracer?.(TRACER_NAME);
-        cachedTracer = tracer ?? null;
+        cachedRuntime = tracer
+            ? {
+                tracer: tracer,
+                ...(otel?.context?.active && otel?.context?.with
+                    ? { context: otel.context }
+                    : {}),
+                ...(otel?.trace?.setSpan ? { trace: otel.trace } : {}),
+            }
+            : null;
     }
     catch {
-        cachedTracer = null;
+        cachedRuntime = null;
     }
-    return cachedTracer;
+    return cachedRuntime;
 }
 /** Drop sentinel/zero token counts so spans aren't cluttered with noise. */
 function pruneAttributes(attributes) {
@@ -62,19 +70,54 @@ function pruneAttributes(attributes) {
  * returns `null` and the caller simply skips span bookkeeping — there is no
  * runtime cost beyond the cached null check.
  */
-export async function startAgentSpan(name, attributes = {}) {
-    const tracer = await resolveTracer();
-    if (!tracer)
+export async function startAgentSpan(name, attributes = {}, parentSpan = null) {
+    const runtime = await resolveRuntime();
+    if (!runtime)
         return null;
     try {
-        return tracer.startSpan(name, {
+        let parentContext;
+        if (parentSpan && runtime.context && runtime.trace) {
+            try {
+                parentContext = runtime.trace.setSpan(runtime.context.active(), parentSpan);
+            }
+            catch {
+                // coercion-ok: explicit OTel parent setup must never break the agent loop.
+            }
+        }
+        return runtime.tracer.startSpan(name, {
             attributes: pruneAttributes(attributes),
-        });
+        }, parentContext);
     }
     catch {
         return null;
     }
 }
+/**
+ * Run a callback with the supplied span installed as the active OTel span so
+ * spans created by the callback become descendants of it. The bridge is
+ * deliberately best-effort: telemetry setup must never change agent behavior.
+ */
+export function withAgentSpanContext(span, callback) {
+    if (!span)
+        return callback();
+    const runtime = cachedRuntime;
+    if (!runtime?.context || !runtime.trace)
+        return callback();
+    let callbackEntered = false;
+    try {
+        const context = runtime.trace.setSpan(runtime.context.active(), span);
+        return runtime.context.with(context, () => {
+            callbackEntered = true;
+            return callback();
+        });
+    }
+    catch (error) {
+        if (callbackEntered)
+            throw error;
+        // coercion-ok: optional OTel context setup must never break the agent loop.
+        return callback();
+    }
+}
 /**
  * Finish a span, setting OK/ERROR status and recording the error message when
  * present. Safe to call with `null` (no-op) and never throws.
@@ -104,7 +147,7 @@ export function endAgentSpan(span, result = {}) {
     }
     finally {
         try {
-            span.end();
+            span.end(result.endTime);
         }
         catch {
             // ignore
@@ -113,7 +156,7 @@ export function endAgentSpan(span, result = {}) {
 }
 /** For tests — reset the cached tracer so a fresh provider can be detected. */
 export function __resetAgentTracerCache() {
-    cachedTracer = undefined;
+    cachedRuntime = undefined;
 }
 /**
  * For tests — inject a tracer directly (e.g. an in-memory test provider's
@@ -121,5 +164,9 @@ export function __resetAgentTracerCache() {
  * to simulate "no tracer available".
  */
 export function __setAgentTracerForTests(tracer) {
-    cachedTracer = tracer;
+    cachedRuntime = tracer ? { tracer } : null;
+}
+/** For tests — inject a runtime with an active-context implementation. */
+export function __setAgentTraceRuntimeForTests(runtime) {
+    cachedRuntime = runtime;
 }

package/dist/resources/handlers.d.ts

@@ -48,8 +48,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
 }>;
 /** DELETE /_agent-native/resources/:id — delete a resource */
 export declare function handleDeleteResource(event: any): Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/secrets/routes.d.ts

@@ -37,17 +37,17 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
     ok?: undefined;
     status?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     status: string;
+    error?: undefined;
 } | {
     ok?: undefined;
     error: string;
     removed?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 /**
  * POST /_agent-native/secrets/:key/test — validate an optional candidate value
@@ -58,13 +58,13 @@ export declare function createTestSecretHandler(): import("h3").EventHandlerWith
     error: string;
     note?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     note?: undefined;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     note: string;
+    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -95,11 +95,11 @@ export interface AdHocSecretPayload {
 export declare function createAdHocSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<AdHocSecretPayload[] | {
     error: string;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;

package/dist/server/core-routes-plugin.d.ts

@@ -113,6 +113,12 @@ export interface DbHealthProbeResult {
          * matching".
          */
         identityMismatch?: boolean;
+        /**
+         * What this runtime believes its own app is (`app.slug ?? app.id`), or
+         * `null` when the bundle cannot derive one. A null here is why a
+         * mismatch cannot be claimed, and is itself a finding worth reading.
+         */
+        runningApp?: string | null;
     };
     /**
      * Hosted-realtime wiring, so a deploy can be verified without signing in.

package/dist/server/core-routes-plugin.js

@@ -402,6 +402,7 @@ export async function runDbHealthProbe(exec = getDbExec, options = {}) {
     // read must never be reported as "nothing recorded".
     let identity;
     let identityMismatch;
+    let runningApp;
     if (db) {
         identity = await withHealthDeadline(readDatabaseIdentity(dbExec).catch((err) => ({
             state: "unreadable",
@@ -409,9 +410,15 @@ export async function runDbHealthProbe(exec = getDbExec, options = {}) {
         })), { state: "timeout" });
         // Only "recorded" can ever prove a mismatch — the other three states mean
         // the check couldn't confirm one, not that it confirmed there wasn't.
+        // And only a KNOWN running identity can disagree with the recorded one:
+        // a hosted bundle that cannot derive its own slug/id must report the gap
+        // (`runningApp: null`), not a mismatch that blocks every production
+        // cutover — which is exactly what the first crm promotion did.
+        runningApp = resolveRunningAppIdentity();
         identityMismatch =
             identity.state === "recorded" &&
-                identity.app !== resolveRunningAppIdentity();
+                runningApp !== null &&
+                identity.app !== runningApp;
     }
     const database = getDatabaseRuntimeFingerprint();
     // Measured on the connection `SELECT 1` just warmed, so the number reflects
@@ -449,7 +456,7 @@ export async function runDbHealthProbe(exec = getDbExec, options = {}) {
             appName: database.appName,
             authTokenConfigured: database.authTokenConfigured,
             netlifyDatabaseUrlConfigured: database.netlifyDatabaseUrlConfigured,
-            ...(identity ? { identity, identityMismatch } : {}),
+            ...(identity ? { identity, identityMismatch, runningApp } : {}),
         },
         ...(schema ? { schema } : {}),
         ...(pressure ? { pressure } : {}),

package/dist/server/realtime-token.d.ts

@@ -59,8 +59,8 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
-    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
+    error?: undefined;
 }>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.176.5",
+  "version": "0.176.6-nightly-20260903194620",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {