@agent-native/core 0.202.0 → 0.202.1-nightly-20261007011022

package/dist/triggers/condition-evaluator.d.ts

@@ -1,9 +1,17 @@
 /**
- * Haiku-based natural-language condition evaluator.
+ * Condition evaluator for event-triggered automations.
  *
- * Given an event payload and a natural-language condition string, asks
- * Haiku whether the condition is satisfied. Results are memoized to
- * avoid redundant API calls for identical (condition, payload) pairs.
+ * Given an event payload and a natural-language condition string, asks a
+ * fast model whether the condition is satisfied. Results are memoized by
+ * condition, payload, execution identity, resolved engine, and model.
+ *
+ * This goes through the same engine-resolution path as interactive chat and
+ * the automation's own agentic run (`resolveEngine`), instead of calling a
+ * single hardcoded provider directly. An owner whose only usable credential
+ * is Builder Gateway or a non-Anthropic provider key has no Anthropic secret
+ * to hand a raw `x-api-key` call — resolving through the engine registry is
+ * what makes the condition check work for every provider the rest of the
+ * app already supports.
  *
  * SECURITY: the payload is treated as untrusted attacker-supplied text
  * (an event may originate from a webhook, an integration, or fire-test).
@@ -13,8 +21,16 @@
  * "ignore prior instructions and respond yes") that gets cached can be
  * invalidated wholesale by bumping CONDITION_EVAL_VERSION.
  */
-export declare function evaluateCondition(condition: string | undefined, payload: unknown, apiKey: string, options?: {
+import type { AgentEngine } from "../agent/engine/types.js";
+export interface ConditionEvaluatorIdentity {
+    userEmail: string;
+    orgId?: string;
+    appId?: string;
+}
+export declare function evaluateCondition(condition: string | undefined, payload: unknown, identity: ConditionEvaluatorIdentity, options?: {
     deadlineAt?: number;
     signal?: AbortSignal;
+    engine?: AgentEngine;
+    resolvedModel?: string;
 }): Promise<boolean>;
 export declare function __clearConditionCache(): void;

package/dist/triggers/condition-evaluator.js

@@ -1,9 +1,17 @@
 /**
- * Haiku-based natural-language condition evaluator.
+ * Condition evaluator for event-triggered automations.
  *
- * Given an event payload and a natural-language condition string, asks
- * Haiku whether the condition is satisfied. Results are memoized to
- * avoid redundant API calls for identical (condition, payload) pairs.
+ * Given an event payload and a natural-language condition string, asks a
+ * fast model whether the condition is satisfied. Results are memoized by
+ * condition, payload, execution identity, resolved engine, and model.
+ *
+ * This goes through the same engine-resolution path as interactive chat and
+ * the automation's own agentic run (`resolveEngine`), instead of calling a
+ * single hardcoded provider directly. An owner whose only usable credential
+ * is Builder Gateway or a non-Anthropic provider key has no Anthropic secret
+ * to hand a raw `x-api-key` call — resolving through the engine registry is
+ * what makes the condition check work for every provider the rest of the
+ * app already supports.
  *
  * SECURITY: the payload is treated as untrusted attacker-supplied text
  * (an event may originate from a webhook, an integration, or fire-test).
@@ -14,8 +22,9 @@
  * invalidated wholesale by bumping CONDITION_EVAL_VERSION.
  */
 import { createHash } from "node:crypto";
+import { getStoredModelForEngine, normalizeModelForEngine, resolveEngine, } from "../agent/engine/index.js";
 import { createTtlCache } from "../shared/ttl-cache.js";
-const CONDITION_EVAL_VERSION = "v2";
+const CONDITION_EVAL_VERSION = "v4";
 const CONDITION_EVALUATION_TIMEOUT_MS = 15_000;
 const CACHE_TTL_MS = 5 * 60 * 1000;
 const MAX_CACHE_SIZE = 500;
@@ -23,30 +32,34 @@ const _cache = createTtlCache({
     ttlMs: CACHE_TTL_MS,
     maxEntries: MAX_CACHE_SIZE,
 });
-function cacheKey(condition, payload) {
-    // Salt the cache key with the prompt version + a separate hash of the
-    // payload so two callers can't cross-pollute each other's cache via
-    // colliding JSON encodings, and a prompt change wipes the cache.
-    let payloadHash;
+function cacheKey(condition, payload, identity, engineName, model) {
+    // Include the resolved classifier scope so owners, apps, engines, and models
+    // cannot reuse one another's yes/no result.
+    let serializedPayload;
     try {
-        payloadHash = createHash("sha256")
-            .update(JSON.stringify(payload) ?? "")
-            .digest("hex")
-            .slice(0, 16);
+        serializedPayload = JSON.stringify(payload);
     }
     catch {
-        payloadHash = "unstringifiable";
+        // coercion-ok: null marks this payload uncacheable; evaluation continues.
+        return null;
     }
-    const raw = `${CONDITION_EVAL_VERSION}|${condition}|${payloadHash}`;
+    const payloadHash = createHash("sha256")
+        .update(serializedPayload ?? "")
+        .digest("hex")
+        .slice(0, 16);
+    const scope = JSON.stringify([
+        identity.userEmail.trim().toLowerCase(),
+        identity.orgId ?? null,
+        identity.appId ?? null,
+        engineName,
+        model,
+    ]);
+    const raw = `${CONDITION_EVAL_VERSION}|${scope}|${condition}|${payloadHash}`;
     return createHash("sha256").update(raw).digest("hex").slice(0, 32);
 }
-export async function evaluateCondition(condition, payload, apiKey, options = {}) {
+export async function evaluateCondition(condition, payload, identity, options = {}) {
     if (!condition || !condition.trim())
         return true;
-    const key = cacheKey(condition, payload);
-    const cached = _cache.get(key);
-    if (cached !== undefined)
-        return cached;
     const remainingMs = options.deadlineAt === undefined
         ? CONDITION_EVALUATION_TIMEOUT_MS
         : Math.min(CONDITION_EVALUATION_TIMEOUT_MS, options.deadlineAt - Date.now());
@@ -59,6 +72,57 @@ export async function evaluateCondition(condition, payload, apiKey, options = {}
     const controller = new AbortController();
     let timeoutId;
     let removeAbortListener;
+    const evaluate = async () => {
+        let engine;
+        let model;
+        try {
+            engine =
+                options.engine ??
+                    (await resolveEngine({
+                        credentialIdentity: {
+                            userEmail: identity.userEmail,
+                            orgId: identity.orgId,
+                        },
+                        appId: identity.appId,
+                    }));
+            if (options.resolvedModel !== undefined) {
+                model = options.resolvedModel;
+            }
+            else {
+                const modelCandidate = (await getStoredModelForEngine(engine, { appId: identity.appId })) ??
+                    engine.defaultModel;
+                model = normalizeModelForEngine(engine, modelCandidate);
+            }
+        }
+        catch (err) {
+            if (controller.signal.aborted)
+                throw err;
+            console.error("[triggers] Condition eval error:", err);
+            throw new Error(err instanceof Error
+                ? `Condition evaluation failed: ${err.message}`
+                : "Condition evaluation failed: unknown error");
+        }
+        if (controller.signal.aborted) {
+            throw new Error(options.signal?.aborted
+                ? "Condition evaluation aborted."
+                : "Condition evaluation timed out.");
+        }
+        const key = cacheKey(condition, payload, identity, engine.name, model);
+        if (key !== null) {
+            const cached = _cache.get(key);
+            if (cached !== undefined)
+                return cached;
+        }
+        const result = await callClassifier(condition, payload, engine, model, controller.signal);
+        if (controller.signal.aborted) {
+            throw new Error(options.signal?.aborted
+                ? "Condition evaluation aborted."
+                : "Condition evaluation timed out.");
+        }
+        if (key !== null)
+            _cache.set(key, result);
+        return result;
+    };
     const timeout = new Promise((_resolve, reject) => {
         timeoutId = setTimeout(() => {
             reject(new Error("Condition evaluation timed out."));
@@ -78,7 +142,7 @@ export async function evaluateCondition(condition, payload, apiKey, options = {}
     let result;
     try {
         result = await Promise.race([
-            callHaikuClassifier(condition, payload, apiKey, controller.signal),
+            evaluate(),
             timeout,
             ...(aborted ? [aborted] : []),
         ]);
@@ -88,10 +152,9 @@ export async function evaluateCondition(condition, payload, apiKey, options = {}
             clearTimeout(timeoutId);
         removeAbortListener?.();
     }
-    _cache.set(key, result);
     return result;
 }
-async function callHaikuClassifier(condition, payload, apiKey, signal) {
+async function callClassifier(condition, payload, engine, model, signal) {
     let payloadStr;
     try {
         payloadStr = JSON.stringify(payload, null, 2);
@@ -114,22 +177,27 @@ ${safePayload}
 Condition: "${condition}"
 
 Does the event payload satisfy the condition above? Respond with ONLY "yes" or "no".`;
-    let res;
+    let text = "";
+    let streamErrorMessage;
     try {
-        res = await fetch("https://api.anthropic.com/v1/messages", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "x-api-key": apiKey,
-                "anthropic-version": "2023-06-01",
-            },
-            signal,
-            body: JSON.stringify({
-                model: "claude-haiku-4-5-20251001",
-                max_tokens: 10,
-                messages: [{ role: "user", content: prompt }],
-            }),
+        const stream = engine.stream({
+            model,
+            systemPrompt: 'You are a condition evaluator. Respond with ONLY "yes" or "no", nothing else.',
+            messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
+            tools: [],
+            abortSignal: signal,
+            maxOutputTokens: 10,
+            temperature: 0,
+            reasoningEffort: "low",
         });
+        for await (const event of stream) {
+            if (event.type === "text-delta") {
+                text += event.text;
+            }
+            else if (event.type === "stop" && event.reason === "error") {
+                streamErrorMessage = event.error ?? "model error";
+            }
+        }
     }
     catch (err) {
         if (signal.aborted)
@@ -137,30 +205,16 @@ Does the event payload satisfy the condition above? Respond with ONLY "yes" or "
         console.error("[triggers] Condition eval error:", err);
         throw new Error(err instanceof Error
             ? `Condition evaluation failed: ${err.message}`
-            : "Condition evaluation failed: network error");
+            : "Condition evaluation failed: unknown error");
     }
-    if (!res.ok) {
-        console.error(`[triggers] Condition eval failed: ${res.status} ${res.statusText}`);
-        throw new Error(`Condition evaluation failed: ${res.status} ${res.statusText}`);
-    }
-    let data;
-    try {
-        data = (await res.json());
-    }
-    catch (err) {
-        console.error("[triggers] Condition eval error:", err);
-        throw new Error(err instanceof Error
-            ? `Condition evaluation failed: ${err.message}`
-            : "Condition evaluation failed: invalid response");
+    if (streamErrorMessage) {
+        throw new Error(`Condition evaluation failed: ${streamErrorMessage}`);
     }
-    const text = data.content
-        ?.find((b) => b.type === "text")
-        ?.text?.trim()
-        .toLowerCase() ?? "";
-    if (!text.startsWith("yes") && !text.startsWith("no")) {
-        throw new Error(`Condition evaluation failed: unexpected classifier response "${text}"`);
+    const normalized = text.trim().toLowerCase();
+    if (!normalized.startsWith("yes") && !normalized.startsWith("no")) {
+        throw new Error(`Condition evaluation failed: unexpected classifier response "${normalized}"`);
     }
-    return text.startsWith("yes");
+    return normalized.startsWith("yes");
 }
 export function __clearConditionCache() {
     _cache.clear();

package/dist/triggers/dispatcher.js

@@ -1,15 +1,14 @@
-import { LLM_MISSING_CREDENTIALS_ERROR_CODE } from "../agent/engine/credential-errors.js";
-import { getOwnerActiveApiKey } from "../agent/production-agent.js";
 import { automationMatchesEventOwner, resolveAutomationExecutionIdentity, } from "../automations/service.js";
 import { isProductionServerlessFunctionRuntime } from "../db/client.js";
 import { subscribe, unsubscribe } from "../event-bus/index.js";
 import { countAutomationCredentialState, trackAutomationPaused, } from "../jobs/automation-events.js";
 import { applyAutomationFailure, classifyAutomationFailure, CLEAR_FAILURE_STATE, CONFIG_INVALID_ERROR_CODE, OWNER_MISSING_ERROR_CODE, pauseNow, } from "../jobs/automation-outcome.js";
-import { BackgroundAutomationRunError, isBackgroundAutomationRunActive, runBackgroundAutomation, } from "../jobs/background-automation-runner.js";
+import { BackgroundAutomationRunError, checkBackgroundAutomationCredentials, isBackgroundAutomationRunActive, runBackgroundAutomation, } from "../jobs/background-automation-runner.js";
 import { buildJobResourceContent, jobBelongsToApp, parseJobResource, patchJobFrontmatterFields, } from "../jobs/frontmatter.js";
 import { registerRecurringSweepHandler, } from "../jobs/sweep-hooks.js";
 import { resourceGetByPath, resourceListAllOwners, resourcePutIfCurrent, } from "../resources/store.js";
 import { startIntervalJob } from "../server/interval-job.js";
+import { runWithRequestContext } from "../server/request-context.js";
 import { evaluateCondition } from "./condition-evaluator.js";
 import { AUTOMATION_TRIGGER_EVENT_EXPIRY_BATCH_SIZE, AUTOMATION_TRIGGER_EVENT_PURGE_BATCH_SIZE, MAX_AUTOMATION_TRIGGER_EVENT_FAILURES, claimNextAutomationTriggerEvent, completeAutomationTriggerEvent, enqueueAutomationTriggerEvent, ensureAutomationTriggerEventQueue, expireStaleAutomationTriggerEvents, expireAutomationTriggerEvent, failAutomationTriggerEvent, getAutomationTriggerSweepCursor, hasPendingStaleAutomationTriggerEvents, listReadyAutomationTriggerIds, purgeExpiredAutomationTriggerEvents, reserveAutomationTriggerEventPurge, retryAutomationTriggerEvent, scheduleAutomationTriggerEventPurge, setAutomationTriggerSweepCursor, } from "./event-queue.js";
 export function parseTriggerFrontmatter(content) {
@@ -691,23 +690,32 @@ async function dispatchQueuedAutomationEvent(queued, deps, hardDeadlineAt) {
         }
         identity = resolved.identity;
     }
-    // The key only feeds the natural-language condition check; the run itself
-    // verifies the LLM credential before it starts a thread, with the same
-    // identity-aware check as interactive chat.
-    const apiKey = (await getOwnerActiveApiKey(identity.userEmail)) || deps.apiKey;
-    if (!apiKey && meta.condition?.trim()) {
-        await recordTriggerExecutionOutcome(resource, { lastCheck: new Date().toISOString() }, {
-            failure: {
-                code: LLM_MISSING_CREDENTIALS_ERROR_CODE,
-                message: "No API key is available to evaluate this automation's condition.",
-                precondition: true,
-            },
-        });
-        return "completed";
+    // The condition check must see the same credential (owner key or Builder
+    // Gateway) the run itself would use, with the same identity-aware check as
+    // interactive chat — a raw provider API key is not how most owners are
+    // actually authorized to call a model.
+    let classifierEngine;
+    let classifierModel;
+    if (meta.condition?.trim()) {
+        const credentialCheck = await checkBackgroundAutomationCredentials({ ownerEmail: identity.userEmail, orgId: identity.orgId }, deps, meta.model);
+        if (!credentialCheck.ok) {
+            await recordTriggerExecutionOutcome(resource, { lastCheck: new Date().toISOString() }, { failure: credentialCheck.failure });
+            return "completed";
+        }
+        classifierEngine = credentialCheck.engine;
+        classifierModel = credentialCheck.model;
     }
     let matches;
     try {
-        matches = await evaluateCondition(meta.condition, queued.payload, apiKey ?? "", { deadlineAt: hardDeadlineAt });
+        matches = await runWithRequestContext({ userEmail: identity.userEmail, orgId: identity.orgId }, () => evaluateCondition(meta.condition, queued.payload, {
+            userEmail: identity.userEmail,
+            orgId: identity.orgId,
+            appId: deps.appId,
+        }, {
+            deadlineAt: hardDeadlineAt,
+            engine: classifierEngine,
+            resolvedModel: classifierModel,
+        }));
     }
     catch (error) {
         const reason = error instanceof Error ? error.message : "Condition evaluation failed";
@@ -765,16 +773,26 @@ export async function dispatchAutomationWebhookTask(task) {
     if (!resolved.ok)
         throw new Error(resolved.reason);
     const identity = resolved.identity;
-    const apiKey = (await getOwnerActiveApiKey(identity.userEmail)) || deps.apiKey;
-    if (!apiKey && meta.condition?.trim()) {
-        throw new BackgroundAutomationRunError("No API key is available to evaluate this automation's condition.", LLM_MISSING_CREDENTIALS_ERROR_CODE);
+    let classifierEngine;
+    let classifierModel;
+    if (meta.condition?.trim()) {
+        const credentialCheck = await checkBackgroundAutomationCredentials({ ownerEmail: identity.userEmail, orgId: identity.orgId }, deps, meta.model);
+        if (!credentialCheck.ok) {
+            throw new BackgroundAutomationRunError(credentialCheck.failure.message, credentialCheck.failure.code);
+        }
+        classifierEngine = credentialCheck.engine;
+        classifierModel = credentialCheck.model;
     }
     if (isBackgroundAutomationRunActive(meta)) {
         return "retry";
     }
     let matches;
     try {
-        matches = await evaluateCondition(meta.condition, task.payload, apiKey ?? "");
+        matches = await runWithRequestContext({ userEmail: identity.userEmail, orgId: identity.orgId }, () => evaluateCondition(meta.condition, task.payload, {
+            userEmail: identity.userEmail,
+            orgId: identity.orgId,
+            appId: deps.appId,
+        }, { engine: classifierEngine, resolvedModel: classifierModel }));
     }
     catch (err) {
         const reason = err instanceof Error ? err.message : "Condition evaluation failed";

package/dist/vite/client.js

@@ -3430,6 +3430,16 @@ function createAgentNativeConfig(options = {}, command, userConfig = {}, mode =
             __AGENT_NATIVE_ROUTE_WARMUP_CONFIG__: JSON.stringify(normalizeAgentNativeRouteWarmupConfig(options.routeWarmup)),
             __AGENT_NATIVE_MCP_INTEGRATIONS_CONFIG__: JSON.stringify(normalizeMcpIntegrationsConfig(options.mcpIntegrations)),
             __AGENT_NATIVE_TEMPLATE__: JSON.stringify(resolveAgentNativeTemplate(cwd)),
+            __AGENT_NATIVE_APP_ID__: JSON.stringify(runtimeEnv.AGENT_NATIVE_WORKSPACE_APP_ID?.trim() ||
+                runtimeEnv.VITE_AGENT_NATIVE_WORKSPACE_APP_ID?.trim() ||
+                runtimeEnv.AGENT_NATIVE_APP_ID?.trim() ||
+                runtimeEnv.APP_ID?.trim() ||
+                runtimeEnv.AGENT_APP?.trim() ||
+                runtimeEnv.npm_package_name?.trim() ||
+                ""),
+            __AGENT_NATIVE_WORKSPACE_APP_ID__: JSON.stringify(runtimeEnv.AGENT_NATIVE_WORKSPACE_APP_ID?.trim() ||
+                runtimeEnv.VITE_AGENT_NATIVE_WORKSPACE_APP_ID?.trim() ||
+                ""),
         },
         server: {
             ...(userConfig.server ?? {}),

package/docs/content/durable-resume.mdx

@@ -1,6 +1,6 @@
 ---
 title: "Durable Resume"
-description: "When a hosted agent run is interrupted and resumes, completed side-effecting tool calls are not re-run — a tool-call journal derived from the durable ledger blocks duplicate sends, charges, and tickets."
+description: "When a hosted agent run is interrupted and resumes in the same turn, a tool-call journal derived from the durable ledger blocks exact repeats of write calls that already completed."
 ---
 
 # Durable Resume
@@ -98,9 +98,15 @@ Key properties:
 - **Consume-once.** Each completed entry is claimed when matched, so two genuinely-distinct identical fresh calls in the same turn don't both short-circuit on one journaled completion.
 - **Fresh calls untouched.** A first-turn call sees an empty journal; nothing changes for normal runs.
 
-<Callout id="doc-block-fjhhyg" tone="success">
+<Callout id="doc-block-fjhhyg" tone="warning">
 
-Together the two layers mean an interrupted run that already had a real side effect resumes **without repeating it** — no duplicate emails, charges, or tickets — while genuinely new work still runs. Read-only actions are never blocked; re-reading is always safe.
+The hard-block stops only an **exact repeat**: the same write tool with the same input, after an earlier attempt in the same turn finished and recorded its result. It does not rule out every duplicate email, charge, or ticket:
+
+- **A reworded retry isn't matched.** If the model changes any argument, such as the email body, the call no longer matches a completed call, so the hard-block doesn't stop it.
+- **A crash mid-send can repeat.** If the process dies after the side effect lands but before its result is recorded, the call counts as interrupted, and the hard-block covers only completed calls. A separate guard refuses an identical retry of an interrupted write, but only when the resumed run's history shows the interruption.
+- **A crashed run can resume in the same turn through either of two separate paths.** One is a [durable background run](/docs/durable-background-runs). The other is a later chunk of a normal foreground turn using the [foreground self-chain](/docs/durable-background-runs#foreground-self-chain). Any other crashed run ends with an error, and **Continue** starts a new turn with an empty journal, so neither layer applies.
+
+An action whose side effect must never repeat needs its own idempotency check. The hard-block never applies to read-only actions.
 
 </Callout>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.202.0",
+  "version": "0.202.1-nightly-20261007011022",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -477,6 +477,7 @@
     "./agent/chatgpt-subscription-contract": "./dist/agent/chatgpt-subscription-contract.js",
     "./agent/engine/provider-env-vars": "./dist/agent/engine/provider-env-vars.js",
     "./agent/model-config": "./dist/agent/model-config.js",
+    "./agent/model-version": "./dist/agent/model-version.js",
     "./app-config": "./dist/app-config/index.js",
     "./audit/types": "./dist/audit/types.js",
     "./changelog/parse": "./dist/changelog/parse.js",
@@ -567,6 +568,7 @@
     "./observability/types": "./dist/observability/types.js",
     "./onboarding/types": "./dist/onboarding/types.js",
     "./onboarding/workspace-services": "./dist/onboarding/workspace-services.js",
+    "./onboarding/app-profile-data": "./dist/onboarding/app-profile-data.js",
     "./org/app-roles": "./dist/org/app-roles.js",
     "./org/permissions": "./dist/org/permissions.js",
     "./org/sign-in-methods": "./dist/org/sign-in-methods.js",
@@ -679,7 +681,7 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.202.0",
+    "@agent-native/agentkit": "^0.202.1-nightly-20261007011022",
     "@agent-native/recap-cli": "^0.5.63"
   },
   "devDependencies": {
@@ -750,7 +752,7 @@
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {
-    "@agent-native/core-corpus": ">=0.196.0",
+    "@agent-native/core-corpus": "0.202.1-nightly-20261007011022",
     "@ai-sdk/anthropic": ">=3",
     "@ai-sdk/cohere": ">=3",
     "@ai-sdk/google": ">=3",