@agent-native/core 0.220.0-nightly-20261024064224 → 0.220.0

package/dist/a2a/handlers.js

@@ -264,7 +264,7 @@ export async function processA2ATaskFromQueue(taskId, config, event) {
             }, A2A_PROCESSING_HEARTBEAT_MS);
             heartbeat.unref?.();
             try {
-                await processClaimedA2ATask(taskId, claimed, config, workerAbort.signal, event);
+                await processClaimedA2ATask(taskId, claimed, config, workerAbort.signal, event, fence.generation);
             }
             finally {
                 clearInterval(heartbeat);
@@ -285,7 +285,7 @@ export async function processA2ATaskFromQueue(taskId, config, event) {
         }
     }
 }
-async function processClaimedA2ATask(taskId, claimed, config, signal, event) {
+async function processClaimedA2ATask(taskId, claimed, config, signal, event, processingAttemptId) {
     const message = claimed.history?.[0];
     if (!message) {
         await settleProcessingA2ATask(taskId, {
@@ -378,7 +378,7 @@ async function processClaimedA2ATask(taskId, claimed, config, signal, event) {
                     ? { orgScope: "personal" }
                     : {}),
             ...(requestOrigin ? { requestOrigin } : {}),
-        }, () => runHandlerAndPersist(taskId, message, config, contextId, callerMetadata, event, sourceContext, verifiedEmail, signal));
+        }, () => runHandlerAndPersist(taskId, message, config, contextId, callerMetadata, event, sourceContext, verifiedEmail, signal, processingAttemptId));
     }
     catch (err) {
         try {
@@ -471,11 +471,12 @@ function jsonRpcError(id, code, message) {
 function jsonRpcResult(id, result) {
     return { jsonrpc: "2.0", id, result };
 }
-function makeHandlerContext(taskId, contextId, metadata, event, sourceContext, ownerEmail, signal) {
+function makeHandlerContext(taskId, contextId, metadata, event, sourceContext, ownerEmail, signal, processingAttemptId) {
     const artifacts = [];
     const pendingFileArtifacts = [];
     const context = {
         taskId,
+        processingAttemptId,
         contextId,
         metadata,
         event,
@@ -573,8 +574,8 @@ async function withA2ARequestContext(metadata, event, fn) {
         ...(requestOrigin ? { requestOrigin } : {}),
     }, fn);
 }
-async function runHandlerAndPersist(taskId, message, config, contextId, metadata, event, sourceContext, ownerEmail, signal) {
-    const { context, artifacts, persistFileArtifacts } = makeHandlerContext(taskId, contextId, metadata, event, sourceContext, ownerEmail, signal);
+async function runHandlerAndPersist(taskId, message, config, contextId, metadata, event, sourceContext, ownerEmail, signal, processingAttemptId) {
+    const { context, artifacts, persistFileArtifacts } = makeHandlerContext(taskId, contextId, metadata, event, sourceContext, ownerEmail, signal, processingAttemptId);
     try {
         signal?.throwIfAborted();
         const result = getHandler(config)(message, context);

package/dist/a2a/types.d.ts

@@ -149,6 +149,7 @@ export interface A2ACorrelationMetadata {
 }
 export interface A2AHandlerContext {
     taskId: string;
+    processingAttemptId?: string;
     contextId?: string;
     metadata?: Record<string, unknown>;
     event?: unknown;

package/dist/automation/index.d.ts

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

package/dist/collab/routes.d.ts

@@ -13,12 +13,12 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
     };
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
+    error?: undefined;
     liveCopy: "derived" | "not_derived" | "unchanged";
     liveCopyReason?: string;
-    error?: undefined;
     ok: boolean;
 } | {
     error?: undefined;

package/dist/collab/struct-routes.d.ts

@@ -2,22 +2,22 @@ export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("
     ok?: undefined;
     error: string;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;
 export declare const postCollabPatch: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     ok?: undefined;
     error: string;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;
 export declare const getCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     docId?: undefined;
     data?: undefined;
 } | {
+    error?: undefined;
     docId: string;
     data: any;
-    error?: undefined;
 }>>;

package/dist/file-upload/actions/upload-image.d.ts

@@ -42,8 +42,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url: string;
     id: string;
     provider: string;
-    configured?: undefined;
     error?: undefined;
+    configured?: undefined;
 } | {
     url?: undefined;
     id?: undefined;

package/dist/jobs/actions/manage-recurring-job.d.ts

@@ -13,10 +13,10 @@ declare const _default: import("../../action.js").ActionDefinition<{
     enabled?: undefined;
     nextRun?: undefined;
 } | {
+    deleted?: undefined;
     resourceId: string;
     name: string;
     enabled: boolean;
     nextRun: string;
-    deleted?: undefined;
 }>;
 export default _default;

package/dist/mcp/org-directory.d.ts

@@ -21,17 +21,18 @@
  *
  * ## Resolution + safety model
  *
- *   - The directory origin is read from env: `AGENT_NATIVE_ORG_DIRECTORY_URL`
- *     (dedicated) or `AGENT_NATIVE_IDENTITY_HUB_URL` (Dispatch is also the
- *     identity hub). When *neither* is set the feature is simply inactive —
- *     `fetchOrgApps()` returns `[]` and nothing changes anywhere (asserted by
- *     a test). This makes the whole feature opt-in and back-compat.
+ *   - A selected org's bound workspace URL wins for org-scoped requests; the
+ *     deployment's `AGENT_NATIVE_ORG_DIRECTORY_URL` or
+ *     `AGENT_NATIVE_IDENTITY_HUB_URL` is the fallback when no binding exists.
+ *     When neither is set the feature is inactive — `fetchOrgApps()` returns
+ *     `[]` and nothing changes anywhere (asserted by a test).
  *   - `fetchOrgAppsResult()` preserves directory availability for callers
  *     that cannot mistake a failed lookup for an empty directory.
  *     `fetchOrgApps()` remains the best-effort compatibility wrapper: on ANY
  *     error it returns `[]` and NEVER throws, so cross-app verbs still degrade
  *     silently to their exact current local-only behavior.
- *   - Credentialed requests require HTTPS and use manual redirects. A short
+ *   - Mounted `/dispatch` requests retry at the host root only after a 404.
+ *     Credentialed requests require HTTPS and use manual redirects. A short
  *     in-memory TTL cache (default 60s) is keyed by directory origin and
  *     caller identity/org scope so sibling app lists never cross tenants.
  *     Successful responses are cached for 60s; transient unavailable results
@@ -51,7 +52,7 @@ export interface OrgApp {
     whenToUse?: string[];
     aliases?: string[];
 }
-export type OrgDirectoryUnavailableReason = "not-configured" | "authentication" | "unauthorized" | "authorization" | "invalid-origin" | "missing-route" | "timeout" | "network" | "invalid-response" | "ssrf-blocked" | "server-error" | "http-error";
+export type OrgDirectoryUnavailableReason = "not-configured" | "authentication" | "unauthorized" | "authorization" | "invalid-origin" | "missing-route" | "timeout" | "network" | "invalid-response" | "ssrf-blocked" | "workspace-url-unavailable" | "server-error" | "http-error";
 export type OrgDirectoryFetchResult = {
     status: "available";
     apps: OrgApp[];

package/dist/mcp/org-directory.js

@@ -127,11 +127,92 @@ function serviceScopedCacheKey(origin, orgId, includeDirectoryApp = false, stric
     ].join("|");
 }
 async function fetchOrgAppsResultInternal(opts, strictValidation = true) {
+    const env = opts?.env ?? process.env;
+    const directoryBase = await resolveDirectoryBaseUrl(opts, env);
+    if (!directoryBase.ok)
+        return directoryBase.result;
+    const result = await fetchOrgAppsAtBaseUrl({ ...opts, directoryBaseUrl: directoryBase.url }, strictValidation);
+    if (result.status !== "unavailable" || result.reason !== "missing-route") {
+        return result;
+    }
+    const rootUrl = new URL(directoryBase.url).origin;
+    if (rootUrl === directoryBase.url.replace(/\/+$/, ""))
+        return result;
+    return fetchOrgAppsAtBaseUrl({ ...opts, directoryBaseUrl: rootUrl }, strictValidation);
+}
+async function resolveDirectoryBaseUrl(opts, env) {
+    if (opts?.directoryBaseUrl !== undefined) {
+        const url = normalizeDirectoryBaseUrl(opts.directoryBaseUrl);
+        return url
+            ? { ok: true, url }
+            : {
+                ok: false,
+                result: { status: "unavailable", reason: "invalid-origin" },
+            };
+    }
+    const serviceOrgId = opts?.serviceOrgId?.trim();
+    let orgId = serviceOrgId || undefined;
+    try {
+        if (!orgId) {
+            const { getRequestOrgId } = await import("../server/request-context.js");
+            orgId = getRequestOrgId();
+        }
+        if (orgId) {
+            const { getOrgWorkspaceUrl } = await import("../org/context.js");
+            const workspaceUrl = await getOrgWorkspaceUrl(orgId);
+            if (workspaceUrl) {
+                const url = normalizeOrgWorkspaceDirectoryBaseUrl(workspaceUrl);
+                return url
+                    ? { ok: true, url }
+                    : {
+                        ok: false,
+                        result: { status: "unavailable", reason: "invalid-origin" },
+                    };
+            }
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            result: { status: "unavailable", reason: "workspace-url-unavailable" },
+        };
+    }
+    const configuredUrl = configuredOrgDirectoryUrl(env);
+    const url = resolveOrgDirectoryOrigin(env);
+    if (url)
+        return { ok: true, url };
+    return {
+        ok: false,
+        result: {
+            status: "unavailable",
+            reason: configuredUrl ? "invalid-origin" : "not-configured",
+        },
+    };
+}
+function normalizeOrgWorkspaceDirectoryBaseUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" ||
+            url.username ||
+            url.password ||
+            url.search ||
+            url.hash ||
+            (url.pathname !== "/" && url.pathname !== "")) {
+            return null;
+        }
+        return `${url.origin}/dispatch`;
+    }
+    catch {
+        // coercion-ok: Invalid bindings become typed invalid-origin failures above.
+        return null;
+    }
+}
+async function fetchOrgAppsAtBaseUrl(opts, strictValidation) {
     const env = opts?.env ?? process.env;
     const hasExplicitBaseUrl = opts?.directoryBaseUrl !== undefined;
     const hasConfiguredEnvUrl = configuredOrgDirectoryUrl(env) !== null;
     const origin = hasExplicitBaseUrl
-        ? normalizeDirectoryBaseUrl(opts?.directoryBaseUrl ?? "")
+        ? normalizeDirectoryBaseUrl(opts.directoryBaseUrl ?? "")
         : resolveOrgDirectoryOrigin(env);
     if (!origin) {
         return {

package/dist/notifications/routes.d.ts

@@ -1,21 +1,21 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
     count: number;
-    ok?: undefined;
     updated?: undefined;
     error?: undefined;
+    ok?: undefined;
 } | {
     count?: undefined;
     updated: number;
-    ok?: undefined;
     error?: undefined;
+    ok?: undefined;
 } | {
     count?: undefined;
+    updated?: undefined;
     error: string;
     ok?: undefined;
-    updated?: undefined;
 } | {
     count?: undefined;
-    ok: boolean;
     updated?: undefined;
+    ok: boolean;
     error?: undefined;
 }>>;

package/dist/observability/routes.d.ts

@@ -27,43 +27,43 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    ok?: undefined;
     error: string;
     message: string;
     summary?: undefined;
     spans?: undefined;
-} | {
     ok?: undefined;
+} | {
     message?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     error?: undefined;
-} | {
     ok?: undefined;
+} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing: true;
     id: string;
     error?: undefined;
-} | {
     ok?: undefined;
+} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing?: undefined;
     id: string;
     error?: undefined;
-} | {
     ok?: undefined;
+} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     error: any;
+    ok?: undefined;
 } | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/secrets/routes.d.ts

@@ -57,39 +57,39 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
     errorCode?: undefined;
-    status?: undefined;
     ok?: undefined;
+    status?: undefined;
 } | {
     error: string;
     errorCode: string;
-    status?: undefined;
     ok?: undefined;
+    status?: undefined;
 } | {
+    error?: undefined;
     errorCode?: undefined;
     ok: boolean;
     status: string;
-    error?: undefined;
 } | {
+    ok?: undefined;
     error: string;
     removed?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    ok?: undefined;
     error: string;
     note?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note?: undefined;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note: string;
-    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -117,11 +117,11 @@ export declare function createAdHocSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;

package/dist/server/agent-chat-plugin.d.ts

@@ -1,5 +1,5 @@
 import type { Message as A2AMessage } from "../a2a/types.js";
-import { type ActionEntry, type AgentActionSurfaceDetails, type AgentActionSurfaceResolution } from "../agent/production-agent.js";
+import { type ActionEntry, type AgentActionSurfaceDetails, type AgentActionSurfaceResolution, type AgentLoopUsage } from "../agent/production-agent.js";
 import { type ActiveRun } from "../agent/run-manager.js";
 import { foldAgentChatRunCompletion } from "../agent/thread-data-builder.js";
 import type { AgentChatEvent, AgentChatScope } from "../agent/types.js";
@@ -79,6 +79,15 @@ export declare function createSerializedA2ATaskStatusWriter(taskId: string, writ
     flush: () => Promise<void>;
 };
 export declare function runA2AAgentLoopWithRunManager(runOptions: Parameters<typeof runA2AAgentLoop>[0], pluginOptions: Pick<AgentChatPluginOptions, "delegatedRunPolicy" | "finalResponseGuard" | "runSoftTimeoutMs">, timeoutOptions: Parameters<typeof runA2AAgentLoop>[2], delegatedOptions?: Parameters<typeof runA2AAgentLoop>[3], taskSignal?: AbortSignal): Promise<Awaited<ReturnType<typeof runA2AAgentLoop>>>;
+export declare function runA2AWithUsageLedger<T>(run: Promise<T>, input: {
+    usage: AgentLoopUsage;
+    ownerEmail: string;
+    orgId: string | null;
+    appId?: string;
+    taskId: string;
+    processingAttemptId?: string;
+    persistUsage?: (record: import("../usage/store.js").UsageRecord) => Promise<void>;
+}): Promise<T>;
 export declare function resolveA2ARecoverableArtifactSecret(orgId?: string | null | undefined): Promise<string | undefined>;
 export declare function buildLeanRunPolicyPrompt(codeEditingSurfaceRestriction: string, prodCodeExecPromptNote: string): string;
 export declare function filterPromptActionsToSurface(actions: Record<string, ActionEntry>, allowedActionNames?: readonly string[]): Record<string, ActionEntry>;

package/dist/server/agent-chat-plugin.js

@@ -20,7 +20,7 @@ import { SYSTEM_PROMPT_CACHE_SPLIT } from "../agent/engine/prompt-cache.js";
 import { PROVIDER_TO_ENV } from "../agent/engine/provider-env-vars.js";
 import { currentExecutionFence, withExecutionFence, } from "../agent/execution-fence.js";
 import { hostedHarnessSystemPrompt } from "../agent/harness/hosted.js";
-import { createProductionAgentHandler, endsAtContinuationBoundary, actionsToEngineTools, executeAgentToolCall, filterActionsByAllowedNames, normalizeAgentActionSurfaceResolution, getActiveRunForThreadAsync, getJevContextCredentials, abortRunDurably, abortRunAndTurnDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably, subscribeToRun, } from "../agent/production-agent.js";
+import { createProductionAgentHandler, endsAtContinuationBoundary, actionsToEngineTools, executeAgentToolCall, filterActionsByAllowedNames, normalizeAgentActionSurfaceResolution, getActiveRunForThreadAsync, getJevContextCredentials, abortRunDurably, abortRunAndTurnDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably, subscribeToRun, mergeAgentLoopUsage, } from "../agent/production-agent.js";
 import { applyProviderModelSelection, providerForEngineName, resolveProviderModelSelectionAtScope, } from "../agent/provider-model-selection.js";
 import { startRun } from "../agent/run-manager.js";
 import { callerHasRunAccess, callerHasThreadAccess, } from "../agent/run-ownership.js";
@@ -519,6 +519,56 @@ export async function runA2AAgentLoopWithRunManager(runOptions, pluginOptions, t
     }
     return result;
 }
+export async function runA2AWithUsageLedger(run, input) {
+    const outcome = await run.then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+    let usageError;
+    let usageFailed = false;
+    if (input.usage.usageReported) {
+        try {
+            const record = {
+                ownerEmail: input.ownerEmail,
+                inputTokens: input.usage.inputTokens,
+                outputTokens: input.usage.outputTokens,
+                cacheReadTokens: input.usage.cacheReadTokens,
+                cacheWriteTokens: input.usage.cacheWriteTokens,
+                builderCreditsUsed: input.usage.builderCreditsUsed,
+                engineName: input.usage.engineName,
+                model: input.usage.model,
+                app: input.appId,
+                orgId: input.orgId ?? undefined,
+                label: "a2a",
+                // A replay in the same lease replaces its receipt; later leases
+                // retain their own usage segments under a different ref.
+                refId: input.processingAttemptId
+                    ? `${input.taskId}:${input.processingAttemptId}`
+                    : input.taskId,
+                runId: input.taskId,
+                threadId: input.taskId,
+                taskId: input.taskId,
+            };
+            if (input.persistUsage) {
+                await input.persistUsage(record);
+            }
+            else {
+                const { recordUsage } = await import("../usage/store.js");
+                await recordUsage(record);
+            }
+        }
+        catch (error) {
+            usageFailed = true;
+            usageError = error;
+        }
+    }
+    if (!outcome.ok) {
+        if (usageFailed) {
+            throw new AggregateError([outcome.error, usageError], "A2A run and usage persistence both failed.");
+        }
+        throw outcome.error;
+    }
+    if (usageFailed)
+        throw usageError;
+    return outcome.value;
+}
 const A2A_ACTIVITY_CHECKPOINT_MIN_INTERVAL_MS = 2_000;
 export async function resolveA2ARecoverableArtifactSecret(orgId = getRequestOrgId()) {
     const globalSecret = process.env.A2A_SECRET?.trim();
@@ -828,12 +878,12 @@ export function createAgentChatPlugin(options) {
         const initPromise = (async () => {
             const { awaitBootstrap } = await import("./framework-request-handler.js");
             await awaitBootstrap(nitroApp);
-            const appProfileAppId = options?.appId ??
+            const runtimeAppId = options?.appId ??
                 getAppConfig().app.id ??
                 getAppConfig().app.template ??
                 getAppConfig().app.workspaceId ??
-                getAppConfig().app.packageName ??
-                "app";
+                getAppConfig().app.packageName;
+            const appProfileAppId = runtimeAppId ?? "app";
             // Never make route readiness wait on an org-global stale-run sweep.
             // `/runs/active` reaps the requested run on demand, and the periodic
             // recovery sweep below handles abandoned runs with no connected client.
@@ -2171,6 +2221,14 @@ export function createAgentChatPlugin(options) {
                     const a2aEvents = [];
                     const a2aToolResults = [];
                     let a2aOutcome;
+                    const a2aUsage = {
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        cacheReadTokens: 0,
+                        cacheWriteTokens: 0,
+                        engineName: a2aEngine.name,
+                        model,
+                    };
                     let lastRecoverableArtifactText = "";
                     let activityState = createA2AAgentActivityState();
                     let lastActivityCheckpointAt = 0;
@@ -2209,7 +2267,7 @@ export function createAgentChatPlugin(options) {
                         correlation.callerThreadId ??
                         context.taskId;
                     console.log(`[A2A] Starting agent loop: ${a2aToolSurface.tools.length}/${a2aToolSurface.availableTools.length} initial tools, prompt ${systemPrompt.length} chars`);
-                    await runA2AAgentLoopWithRunManager({
+                    const a2aRun = runA2AAgentLoopWithRunManager({
                         engine: a2aEngine,
                         model,
                         systemPrompt,
@@ -2225,7 +2283,7 @@ export function createAgentChatPlugin(options) {
                         orgId: getRequestOrgId() ?? null,
                         // Without it, every action with an `access` policy is refused
                         // for lack of an application identity.
-                        appId: options?.appId,
+                        appId: runtimeAppId,
                         executionMode: "act",
                         runId: context.taskId,
                         networkProtocol: "a2a",
@@ -2239,6 +2297,12 @@ export function createAgentChatPlugin(options) {
                         onOutcome: (outcome) => {
                             a2aOutcome = outcome;
                         },
+                        onUsage: (usage) => {
+                            mergeAgentLoopUsage(a2aUsage, {
+                                ...usage,
+                                usageReported: true,
+                            });
+                        },
                         send: (event) => {
                             a2aEvents.push(event);
                             const nextActivityState = applyA2AAgentActivityEvent(activityState, event);
@@ -2318,6 +2382,14 @@ export function createAgentChatPlugin(options) {
                             },
                         },
                     }, context.signal);
+                    await runA2AWithUsageLedger(a2aRun, {
+                        usage: a2aUsage,
+                        ownerEmail: userEmail,
+                        orgId: getRequestOrgId() ?? null,
+                        appId: runtimeAppId,
+                        taskId: context.taskId,
+                        processingAttemptId: context.processingAttemptId,
+                    });
                     // The continuation can observe terminal output immediately, so make
                     // its latest mutation checkpoint durable first.
                     checkpointActivity(true);

package/dist/server/agent-discovery.js

@@ -577,59 +577,21 @@ function mergeDiscoveredAgent(agentsById, candidate) {
 async function discoverOrgDirectoryApps(selfAppId) {
     const selfId = selfAppId ? normalizeAgentId(selfAppId) : undefined;
     try {
-        const { fetchOrgAppsResult, resolveOrgDirectoryOrigin } = await import("../mcp/org-directory.js");
-        const configuredBaseUrl = resolveOrgDirectoryOrigin();
-        let result = await fetchOrgAppsResult({ selfId });
-        let baseUrl = configuredBaseUrl;
-        if (result.status === "unavailable" && result.reason === "not-configured") {
-            const orgId = getRequestOrgId();
-            if (!orgId) {
-                return {
-                    status: "setup-required",
-                    reason: "organization-not-selected",
-                };
-            }
-            const { getOrgWorkspaceUrl } = await import("../org/context.js");
-            const workspaceUrl = await getOrgWorkspaceUrl(orgId);
-            if (!workspaceUrl) {
-                return { status: "setup-required", reason: "workspace-url-not-set" };
-            }
-            let workspaceOrigin;
-            try {
-                const parsed = new URL(workspaceUrl);
-                if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
-                    parsed.username ||
-                    parsed.password ||
-                    parsed.search ||
-                    parsed.hash ||
-                    (parsed.pathname !== "/" && parsed.pathname !== "")) {
-                    return { status: "setup-required", reason: "invalid-workspace-url" };
-                }
-                workspaceOrigin = parsed.origin;
-            }
-            catch {
-                return { status: "setup-required", reason: "invalid-workspace-url" };
-            }
-            baseUrl = `${workspaceOrigin}/dispatch`;
-            result = await fetchOrgAppsResult({ directoryBaseUrl: baseUrl, selfId });
-        }
-        if (result.status === "unavailable" &&
-            result.reason === "missing-route" &&
-            baseUrl) {
-            const rootUrl = new URL(baseUrl).origin;
-            if (rootUrl !== baseUrl.replace(/\/+$/, "")) {
-                result = await fetchOrgAppsResult({
-                    directoryBaseUrl: rootUrl,
-                    selfId,
-                });
-            }
-        }
+        const { fetchOrgAppsResult } = await import("../mcp/org-directory.js");
+        const result = await fetchOrgAppsResult({ selfId });
         if (result.status === "available")
             return result;
         if (result.reason === "authorization")
             return { status: "forbidden" };
-        if (result.reason === "not-configured" ||
-            result.reason === "invalid-origin") {
+        if (result.reason === "not-configured") {
+            return {
+                status: "setup-required",
+                reason: getRequestOrgId()
+                    ? "workspace-url-not-set"
+                    : "organization-not-selected",
+            };
+        }
+        if (result.reason === "invalid-origin") {
             return { status: "setup-required", reason: result.reason };
         }
         return { status: "unavailable", reason: result.reason };

package/dist/server/agent-engine-api-key-route.d.ts

@@ -67,12 +67,12 @@ export declare function createAgentEngineApiKeyHandler(): import("h3").EventHand
     code: any;
 } | {
     errorCode?: undefined;
-    error?: undefined;
     code?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
     defaultModel?: import("./agent-engine-default-model-route.js").SavedKeyDefaultModelOutcome;
+    error?: undefined;
 }>>;
 export {};

package/dist/server/agent-engine-default-model-route.d.ts

@@ -8,17 +8,17 @@ export declare const AGENT_ENGINE_API_KEY_ACTION_NAME = "agent-engine-api-key";
  * resolveEngine's credential detection.
  */
 export declare function createAgentEngineDisconnectHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
     scope?: undefined;
 } | {
     ok: boolean;
     error: any;
     scope?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     scope: "org" | "user";
-    error?: undefined;
 }>>;
 export interface DefaultModelSelectionRequest {
     engine: string;

package/dist/server/agent-engine-ollama-models-route.d.ts

@@ -1,9 +1,9 @@
 export declare function createAgentEngineOllamaModelsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    ok?: undefined;
     error: string;
     models?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     models: string[];
-    error?: undefined;
 }>>;

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

@@ -588,8 +588,8 @@ export declare function createPublicRemoteAgentsHandler(discover?: PublicAgentDi
     error: string;
     agents?: undefined;
 } | {
-    agents: Omit<import("./agent-discovery.js").DiscoveredAgent, "auth" | "kind">[];
     error?: undefined;
+    agents: Omit<import("./agent-discovery.js").DiscoveredAgent, "auth" | "kind">[];
 }>>;
 export declare function getBuilderConnectErrorDisposition(error: unknown, connectAttemptId: string | null): "correlated" | "legacy" | null;
 export declare function getBuilderConnectErrorKey(ownerEmail: string, connectAttemptId?: string | null): string;

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

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

package/dist/triggers/actions/manage-automation.d.ts

@@ -67,6 +67,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     triggerType: "event" | "manual" | "schedule" | "webhook";
     body: string;
 }, {
+    updated?: undefined;
+    deleted?: undefined;
     created: boolean;
     resourceId: string;
     name: string;
@@ -87,17 +89,17 @@ declare const _default: import("../../action.js").ActionDefinition<{
     executionCwd: string;
     mcpTools: string[];
     webhookPath: string;
-    deleted?: undefined;
-    updated?: undefined;
     changed?: undefined;
     previouslyEnabled?: undefined;
     requestedEnabled?: undefined;
 } | {
+    updated?: undefined;
+    enabled?: undefined;
+    nextRun?: undefined;
     created?: undefined;
     deleted: boolean;
     resourceId: string;
     name: string;
-    updated?: undefined;
     scope?: undefined;
     triggerType?: undefined;
     event?: undefined;
@@ -105,8 +107,6 @@ declare const _default: import("../../action.js").ActionDefinition<{
     timezone?: undefined;
     condition?: undefined;
     body?: undefined;
-    enabled?: undefined;
-    nextRun?: undefined;
     createdBy?: undefined;
     model?: undefined;
     reasoningEffort?: undefined;
@@ -119,8 +119,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     requestedEnabled?: undefined;
     webhookPath?: undefined;
 } | {
-    created?: undefined;
     deleted?: undefined;
+    created?: undefined;
     updated: boolean;
     resourceId: string;
     name: string;

package/dist/usage/store.js

@@ -252,48 +252,51 @@ export async function recordUsage(recordOrOwner, inputTokens, outputTokens, mode
     const resolvedLabel = label ?? "chat";
     const resolvedRef = refId ?? "";
     const resolvedOrgId = orgId ?? getRequestOrgId() ?? null;
-    if (resolvedRef) {
-        await client.execute({
-            sql: `DELETE FROM token_usage
-        WHERE label = ? AND ref_id = ?
-          AND (org_id IS NULL OR org_id = ?)`,
-            args: [resolvedLabel, resolvedRef, resolvedOrgId],
-        });
-    }
     const resolvedCostSource = costSource ?? (costCentsX100 == null ? "estimated" : "reported");
     const costX100 = resolvedCostSource === "unavailable"
         ? 0
         : (costCentsX100 ??
             calculateCost(inTok, outTok, modelName, cacheReadTokens, cacheWriteTokens));
     const id = Date.now() * 1000 + Math.floor(Math.random() * 1000);
+    const insertArgs = [
+        id,
+        ownerEmail,
+        inTok,
+        outTok,
+        cacheReadTokens,
+        cacheWriteTokens,
+        costX100,
+        builderCreditsUsed ?? null,
+        engineName ?? null,
+        resolvedCostSource,
+        modelName,
+        resolvedLabel,
+        resolvedApp,
+        resolvedRef,
+        resolvedOrgId,
+        runId ?? null,
+        threadId ?? null,
+        taskId ?? null,
+        integrationScopeId ?? null,
+        sourcePlatform ?? null,
+        sourceId ?? null,
+        Date.now(),
+    ];
+    const replaceRefSql = resolvedRef
+        ? `WITH prior_usage AS (
+        DELETE FROM token_usage
+        WHERE label = ? AND ref_id = ?
+          AND (org_id IS NULL OR org_id = ?)
+        RETURNING id
+      ) `
+        : "";
     await client.execute({
-        sql: `INSERT INTO token_usage
+        sql: `${replaceRefSql}INSERT INTO token_usage
       (id, owner_email, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, cost_cents_x100, builder_credits_used, engine_name, cost_source, model, label, app, ref_id, org_id, run_id, thread_id, task_id, integration_scope_id, source_platform, source_id, created_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        args: [
-            id,
-            ownerEmail,
-            inTok,
-            outTok,
-            cacheReadTokens,
-            cacheWriteTokens,
-            costX100,
-            builderCreditsUsed ?? null,
-            engineName ?? null,
-            resolvedCostSource,
-            modelName,
-            resolvedLabel,
-            resolvedApp,
-            resolvedRef,
-            resolvedOrgId,
-            runId ?? null,
-            threadId ?? null,
-            taskId ?? null,
-            integrationScopeId ?? null,
-            sourcePlatform ?? null,
-            sourceId ?? null,
-            Date.now(),
-        ],
+        args: resolvedRef
+            ? [resolvedLabel, resolvedRef, resolvedOrgId, ...insertArgs]
+            : insertArgs,
     });
     void import("./alerts-store.js")
         .then(({ enqueueUsageAlertEvaluation }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.220.0-nightly-20261024064224",
+  "version": "0.220.0",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -730,8 +730,8 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.220.0-nightly-20261024064224",
-    "@agent-native/recap-cli": "^0.5.88"
+    "@agent-native/agentkit": "^0.220.0",
+    "@agent-native/recap-cli": "^0.5.89"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",
@@ -801,7 +801,7 @@
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {
-    "@agent-native/core-corpus": "0.220.0-nightly-20261024064224",
+    "@agent-native/core-corpus": ">=0.196.0",
     "@ai-sdk/anthropic": ">=3",
     "@ai-sdk/cohere": ">=3",
     "@ai-sdk/google": ">=3",