@agent-native/core 0.204.0 → 0.204.1-nightly-20261008034100

package/dist/observability/store.js

@@ -660,6 +660,64 @@ export async function getTraceSummary(runId, opts = {}) {
         return null;
     return rowToTraceSummary(rows[0]);
 }
+/**
+ * A thread created on a path with no request org keeps `org_id` NULL, and every
+ * review read requires `thread.org_id` to equal the trace's org, so its runs
+ * never reach Human Review. The run that executed under an org is the proof of
+ * which org the thread belongs to: adopt it, for the thread's own owner only
+ * and only while `org_id` is NULL.
+ *
+ * A private thread's `org_id` grants nothing but that review access (owner
+ * access ignores it, shares do not read it, and `visibility = 'org'` is the only
+ * way it scopes sharing), while `thread_data` holds every run's conversation. So
+ * a private thread whose owner's runs span more than one org belongs to none of
+ * them: the second statement unassigns it. Org-visible threads keep their
+ * `org_id`, which is an explicit sharing scope.
+ *
+ * Both statements run after this run's own summary is committed
+ * (`upsertTraceSummary` is awaited first), so of two concurrent runs under
+ * different orgs the one whose statements run later always sees the other's
+ * committed org. If this run's adopt raced ahead of the other run's summary, the
+ * other run's unassign undoes it, or, when that ran before this adopt
+ * committed, this run's own unassign does, since it starts after the adopt.
+ * No lock is needed.
+ *
+ * The multi-org signal is derived from `agent_trace_summaries`, so it is only
+ * as durable as those rows: retention purges them, and a run that never wrote a
+ * summary is invisible to it. A thread unassigned for spanning orgs can
+ * therefore be re-adopted once the other org's summaries age out.
+ */
+export async function adoptTraceOrgForThread(summary) {
+    if (!summary.orgId || !summary.threadId || !summary.userId)
+        return;
+    const client = getDbExec();
+    // The subqueries only run for a thread owned by the caller (the other
+    // predicates short-circuit first) and probe
+    // idx_trace_summaries_thread_user_created by thread_id.
+    await client.execute({
+        sql: `UPDATE chat_threads SET org_id = ?
+      WHERE id = ? AND org_id IS NULL AND LOWER(owner_email) = LOWER(?)
+        AND NOT EXISTS (
+          SELECT 1 FROM agent_trace_summaries other
+          WHERE other.thread_id = chat_threads.id
+            AND LOWER(other.user_id) = LOWER(chat_threads.owner_email)
+            AND other.org_id IS NOT NULL AND other.org_id <> ?
+        )`,
+        args: [summary.orgId, summary.threadId, summary.userId, summary.orgId],
+    });
+    await client.execute({
+        sql: `UPDATE chat_threads SET org_id = NULL
+      WHERE id = ? AND org_id IS NOT NULL AND visibility = 'private'
+        AND LOWER(owner_email) = LOWER(?)
+        AND EXISTS (
+          SELECT 1 FROM agent_trace_summaries other
+          WHERE other.thread_id = chat_threads.id
+            AND LOWER(other.user_id) = LOWER(chat_threads.owner_email)
+            AND other.org_id IS NOT NULL AND other.org_id <> chat_threads.org_id
+        )`,
+        args: [summary.threadId, summary.userId],
+    });
+}
 export async function getOrgScopedThreadData(orgId, ownerEmail, threadIds) {
     const ids = [...new Set(threadIds.filter(Boolean))];
     if (!orgId || !ownerEmail || ids.length === 0)

package/dist/observability/traces.js

@@ -6,7 +6,7 @@ import { MAX_AI_CONTENT_BYTES, MAX_AI_SPANS_PER_RUN, boundAiContent, emitAiSpanE
 import { sanitizeToolErrorMessage, TOOL_ERROR_DETAIL_METADATA_KEY, toolErrorSignature, } from "./trace-error.js";
 import { redactCapturedString, redactSensitiveFields, } from "./trace-redaction.js";
 export { redactSensitiveFields } from "./trace-redaction.js";
-import { recordAgentToolCall, recordGenAiChat } from "./metrics.js";
+import { recordAgentToolCall, recordGenAiChat, recordTraceWriteFailure, } from "./metrics.js";
 import { endAgentSpan, startAgentSpan, withAgentSpanContext, } from "./tracing.js";
 import { trackingIdentityProperties } from "./tracking-identity.js";
 function spanId() {
@@ -1328,7 +1328,7 @@ export async function instrumentAgentLoop(opts) {
                 model: usage?.model ?? loopOpts.model,
                 createdAt: runStart,
             };
-            writeTraceData(spans, summary, runId, config).catch(() => { });
+            writeTraceData(spans, summary, runId, config).catch((error) => reportTraceWriteFailure(runId, "write", error));
             try {
                 // Metrics are unsampled and independent of trace export.
                 for (const [tripIndex, trip] of modelRoundTrips.entries()) {
@@ -1463,6 +1463,7 @@ export async function instrumentAgentLoop(opts) {
             if (precedingResponse) {
                 const { inferAndTrackSentiment } = await import("./sentiment.js");
                 await inferAndTrackSentiment({
+                    runEngine: loopOpts.engine,
                     classifierModel: config.inferredSentimentModel,
                     precedingResponseModel: precedingResponse.model,
                     text: opts.sentimentInput,
@@ -1480,10 +1481,41 @@ export async function instrumentAgentLoop(opts) {
     }
     return usage;
 }
+/**
+ * A trace that fails to persist leaves the run unreviewable and makes a
+ * thumbs-down for it unlinkable, so it is reported once per run and stage,
+ * never silently and never per span.
+ */
+function reportTraceWriteFailure(runId, stage, error, detail = {}) {
+    recordTraceWriteFailure(stage, error);
+    console.warn(`[agent-native] observability: could not persist trace ${stage} for run ${runId}`, {
+        ...detail,
+        error: toolErrorSignature(error instanceof Error ? error.message : String(error)),
+    });
+}
 async function writeTraceData(spans, summary, runId, config) {
-    const { insertTraceSpan, upsertTraceSummary } = await import("./store.js");
-    await Promise.all(spans.map((span) => insertTraceSpan({ ...span, orgId: summary.orgId ?? null }).catch(() => { })));
-    await upsertTraceSummary(summary).catch(() => { });
+    const { adoptTraceOrgForThread, insertTraceSpan, upsertTraceSummary } = await import("./store.js");
+    let spanFailures = 0;
+    let firstSpanError;
+    await Promise.all(spans.map((span) => insertTraceSpan({ ...span, orgId: summary.orgId ?? null }).catch((error) => {
+        spanFailures += 1;
+        firstSpanError ??= error;
+    })));
+    if (spanFailures > 0) {
+        reportTraceWriteFailure(runId, "spans", firstSpanError, {
+            failed: spanFailures,
+            total: spans.length,
+        });
+    }
+    // Adoption reads other runs' summaries to detect a thread spanning orgs, so
+    // it is only sound once this run's own org is on record too.
+    const summaryWritten = await upsertTraceSummary(summary).then(() => true, (error) => {
+        reportTraceWriteFailure(runId, "summary", error);
+        return false;
+    });
+    if (summaryWritten) {
+        await adoptTraceOrgForThread(summary).catch((error) => reportTraceWriteFailure(runId, "thread_org", error));
+    }
     try {
         const { evaluateRun } = await import("./evals.js");
         await evaluateRun(runId, { sampleRate: config.evalSampleRate });

package/dist/org/index.d.ts

@@ -177,10 +177,10 @@ export declare const getMyOrgHandler: import("h3").EventHandlerWithFetch<import(
     soloDeploymentAdmin: boolean | undefined;
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    success: boolean;
+    name?: undefined;
     role?: undefined;
     id?: undefined;
-    name?: undefined;
-    success: boolean;
 } | {
     success?: undefined;
     id: string;

package/dist/progress/actions.js

@@ -15,6 +15,7 @@ function parseLimit(value, fallback = 20) {
 export function createProgressToolEntries(getCurrentUser) {
     return {
         "manage-progress": {
+            confirmsAutomationWork: false,
             tool: {
                 description: `Track multi-step task progress visible to the user in the runs tray.
 

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,9 +75,10 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    deleted?: undefined;
     message?: undefined;
-    found?: undefined;
+    deleted?: undefined;
+    id?: undefined;
+    provider?: undefined;
     providers: {
         id: string;
         label: string;
@@ -88,46 +89,45 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         updatedAt: number;
     }[];
     count: number;
-    provider?: undefined;
+    found?: undefined;
     registered?: undefined;
-    id?: undefined;
     label?: undefined;
 } | {
-    deleted?: undefined;
     message?: undefined;
+    deleted?: undefined;
+    id?: undefined;
     providers?: undefined;
     count?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
     registered?: undefined;
-    id?: undefined;
     label?: undefined;
 } | {
-    deleted?: undefined;
     message?: undefined;
+    deleted?: undefined;
+    provider?: undefined;
     providers?: undefined;
     count?: undefined;
-    provider?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
     message?: undefined;
-    found?: undefined;
+    provider?: undefined;
     providers?: undefined;
     count?: undefined;
-    provider?: undefined;
+    found?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
     deleted?: undefined;
-    found?: undefined;
+    provider?: undefined;
     providers?: undefined;
     count?: undefined;
-    provider?: undefined;
+    found?: undefined;
     registered: boolean;
     id: string;
     label: string;

package/dist/provider-api/actions/provider-api.d.ts

@@ -313,9 +313,7 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
     }, {
         id?: undefined;
         deleted?: undefined;
-        provider?: undefined;
         message?: undefined;
-        found?: undefined;
         providers: {
             id: string;
             label: string;
@@ -326,6 +324,8 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
+        provider?: undefined;
+        found?: undefined;
         registered?: undefined;
         label?: undefined;
     } | {
@@ -340,30 +340,30 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         label?: undefined;
     } | {
         deleted?: undefined;
-        provider?: undefined;
         message?: undefined;
         providers?: undefined;
         count?: undefined;
+        provider?: undefined;
         found: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
     } | {
-        provider?: undefined;
         message?: undefined;
-        found?: undefined;
         providers?: undefined;
         count?: undefined;
+        provider?: undefined;
+        found?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
     } | {
         deleted?: undefined;
-        provider?: undefined;
-        found?: undefined;
         providers?: undefined;
         count?: undefined;
+        provider?: undefined;
+        found?: undefined;
         registered: boolean;
         id: string;
         label: string;

package/dist/provider-api/actions/provider-api.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { defineAction, } from "../../action.js";
 import { getCredentialContext } from "../../server/request-context.js";
+import { rejectFailedProviderResult } from "../result-outcome.js";
 import { stagingExecuteRequest } from "../staging.js";
 import { createCustomProviderRegistrationAction, } from "./custom-provider-registration.js";
 import { buildProviderApiAuditSummary } from "./provider-api-audit.js";
@@ -261,7 +262,7 @@ export function createProviderApiRequestAction(runtime, options = {}) {
                     rethrowStagingError(error);
                 }
             }
-            return runtime.executeRequest(args);
+            return rejectFailedProviderResult(args.provider, await runtime.executeRequest(args));
         },
     });
 }
@@ -291,7 +292,10 @@ export function createProviderApiDocsAction(runtime, options = {}) {
         schema,
         http: options.http ?? { method: "GET" },
         readOnly: true,
-        run: async (rawArgs) => runtime.fetchDocs(rawArgs),
+        run: async (rawArgs) => {
+            const args = rawArgs;
+            return rejectFailedProviderResult(args.provider, await runtime.fetchDocs(args));
+        },
     });
 }
 export function createProviderApiActions(runtime, options = {}) {

package/dist/provider-api/corpus-jobs.d.ts

@@ -73,7 +73,6 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     offset?: unknown;
     limit?: unknown;
 }, {
-    deleted?: undefined;
     jobs: {
         id: string;
         name: string;
@@ -84,6 +83,7 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
         updatedAt: string;
     }[];
     total: number;
+    deleted?: undefined;
     jobId?: undefined;
 } | {
     jobs?: undefined;
@@ -91,9 +91,9 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     deleted: boolean;
     jobId: string;
 } | {
-    deleted?: undefined;
     jobs?: undefined;
     total?: undefined;
+    deleted?: undefined;
     jobId?: undefined;
     hits: Record<string, unknown>[];
     offset: number;

package/dist/provider-api/index.d.ts

@@ -513,3 +513,4 @@ export declare function readGitHubRepositoryFile(args: GitHubRepositoryFileReadA
 export declare function writeGitHubRepositoryFile(args: GitHubRepositoryFileWriteArgs, runtime: ProviderApiRuntimeOptions): Promise<GitHubRepositoryFileWriteResult>;
 export declare function deleteGitHubRepositoryFile(args: GitHubRepositoryFileDeleteArgs, runtime: ProviderApiRuntimeOptions): Promise<GitHubRepositoryFileDeleteResult>;
 export declare function defaultProviderApiCredentialResolver(options: ProviderApiCredentialLookupOptions): Promise<ProviderApiResolvedCredential | null>;
+export declare function providerApiResponseOutcomeForUrl(url: string, response: Pick<ProviderApiHttpResponse, "ok" | "statusText">, body: string): Pick<ProviderApiHttpResponse, "ok" | "statusText">;

package/dist/provider-api/index.js

@@ -3950,6 +3950,24 @@ function providerQuotaExhaustedResponse(detail) {
         },
     };
 }
+export function providerApiResponseOutcomeForUrl(url, response, body) {
+    const target = new URL(url);
+    const config = Object.values(PROVIDER_CONFIGS).find((candidate) => {
+        if (!candidate.bodyOkField)
+            return false;
+        const base = new URL(candidate.defaultBaseUrl);
+        const path = base.pathname.replace(/\/$/, "");
+        return (target.origin === base.origin &&
+            (target.pathname === path || target.pathname.startsWith(`${path}/`)));
+    });
+    return config
+        ? applyBodyEnvelopeOutcome({
+            ok: response.ok,
+            statusText: response.statusText,
+            json: tryParseJson(body),
+        }, config)
+        : response;
+}
 function applyBodyEnvelopeOutcome(response, config) {
     const field = config.bodyOkField;
     if (!field || !response.ok)

package/dist/provider-api/result-outcome.d.ts

@@ -0,0 +1 @@
+export declare function rejectFailedProviderResult<T>(provider: string, result: T): T;

package/dist/provider-api/result-outcome.js

@@ -0,0 +1,20 @@
+import { fail } from "../action.js";
+export function rejectFailedProviderResult(provider, result) {
+    if (!result || typeof result !== "object")
+        return result;
+    const record = result;
+    const response = record.response && typeof record.response === "object"
+        ? record.response
+        : record;
+    if (response.ok !== false)
+        return result;
+    const status = response.status;
+    fail(`${provider}: HTTP ${status} ${response.statusText ?? ""}\n\n${JSON.stringify(response.json ?? response.text ?? response).slice(0, 2000)}`, {
+        statusCode: typeof status === "number" && status >= 400 && status <= 599
+            ? status
+            : 400,
+        errorCode: typeof status === "number" && status >= 400
+            ? `http_${status}`
+            : "provider_api_rejected",
+    });
+}

package/dist/provider-api/staging.js

@@ -23,6 +23,8 @@
  * secret redaction are fully preserved. We read the raw (pre-redacted) JSON
  * here; redaction is applied to the response returned to the model.
  */
+import { fail } from "../action.js";
+import { rejectFailedProviderResult } from "./result-outcome.js";
 import { upsertStagedDataset, deriveColumns, MAX_ROWS_PER_APP, } from "./staged-datasets-store.js";
 function getAtPath(obj, path) {
     if (!path || obj === undefined || obj === null)
@@ -174,18 +176,21 @@ export async function stagingExecuteRequest(args, execute, ctx) {
                     const retryAt = typeof json?.retryAt === "string"
                         ? ` Retry after ${json.retryAt}.`
                         : "";
-                    throw new Error(`Provider API quota exhausted (429).${retryAt}`);
+                    fail(`Provider API quota exhausted (429).${retryAt}`, {
+                        statusCode: 429,
+                        errorCode: "http_429",
+                    });
                 }
                 if (attempt >= 5) {
-                    throw new Error(`Provider returned 429 Too Many Requests after ${attempt + 1} attempts. ` +
-                        `Try again later or reduce the page count.`);
+                    fail(`Provider returned 429 Too Many Requests after ${attempt + 1} attempts. ` +
+                        `Try again later or reduce the page count.`, { statusCode: 429, errorCode: "http_429" });
                 }
                 const waitMs = getRetryAfterMs(response.headers, attempt);
                 await sleepMs(waitMs);
                 attempt++;
                 continue;
             }
-            result = raw;
+            result = rejectFailedProviderResult(args.provider, raw);
             break;
         }
         pages++;
@@ -195,11 +200,7 @@ export async function stagingExecuteRequest(args, execute, ctx) {
         }
         const response = result.response;
         if (!response?.ok) {
-            if (pageIndex === 0) {
-                throw new Error(`Provider API returned status ${response?.status}: ${JSON.stringify(response?.json ?? response?.text).slice(0, 200)}`);
-            }
-            truncated = true;
-            break;
+            fail(`Provider API returned status ${response?.status}: ${JSON.stringify(response?.json ?? response?.text).slice(0, 200)}`, { errorCode: "provider_api_rejected" });
         }
         const body = response.json ??
             (response.text ? tryParseJson(response.text) : null);

package/dist/server/agent-chat/prompt-resources.d.ts

@@ -1,5 +1,6 @@
 import { type JevCandidate } from "../../agent/jev-tool-prefetch.js";
 import { type FrameworkToolGroup } from "../../framework-tools.js";
+import type { ContextStatus } from "../../shared/context-status.js";
 import type { ContextGovernanceTier, ContextManifestSourceRef, ContextSystemProvenance } from "../../shared/context-xray.js";
 import type { BuilderGatewayAuth } from "../credential-provider.js";
 export declare const COMPACT_PROMPT_RESOURCE_MAX_CHARS = 6000;
@@ -72,7 +73,12 @@ export interface PromptSectionBudgetResult {
 }
 export declare function selectPromptSectionsWithinBudget(sections: PromptSection[], maxChars: number): PromptSectionBudgetResult;
 export declare function resourceScopeForOwner(owner: string, currentOwner?: string): string;
-export declare function preloadJevContextForPrompt(options: {
+export interface JevPreloadResult {
+    context: string;
+    status: ContextStatus;
+}
+export declare function preloadJevContextForPrompt(options: Parameters<typeof preloadJevContextWithStatus>[0]): Promise<string>;
+export declare function preloadJevContextWithStatus(options: {
     request: string;
     appId?: string;
     owner?: string;
@@ -87,7 +93,7 @@ export declare function preloadJevContextForPrompt(options: {
     contextPrefetchDeadlineAt?: number;
     dispatchToBackground?: boolean;
     internalContinuation?: boolean;
-}): Promise<string>;
+}): Promise<JevPreloadResult>;
 /**
  * Pre-load the agent's context: AGENTS.md (workspace/template/runtime
  * instructions), the skills index, shared LEARNINGS.md (team notes), a shared

package/dist/server/agent-chat/prompt-resources.js

@@ -866,16 +866,26 @@ function recordAnalyticsPreloadedReferenceCount(input) {
     };
 }
 export async function preloadJevContextForPrompt(options) {
+    return (await preloadJevContextWithStatus(options)).context;
+}
+export async function preloadJevContextWithStatus(options) {
     const request = options.request.trim();
     const apiKey = options.apiKey?.trim();
     const personalApiKey = options.personalApiKey?.trim();
     if (!request || options.maxChars === 0 || options.dispatchToBackground) {
-        return "";
+        return { context: "", status: "empty" };
     }
     const deadlineAt = options.contextPrefetchDeadlineAt ?? Date.now() + JEV_PRELOAD_BUDGET_MS;
     const hasJev = Boolean(apiKey || personalApiKey || options.builderAuth);
     let runtimeCandidates = [];
     let memoryContext = { candidates: [], fallbackIds: [] };
+    // A stage that timed out or threw only matters when nothing was injected: an
+    // empty result is then a loss, not an answer, and the model has to be told.
+    let degraded;
+    const finish = (context, injected) => ({
+        context,
+        status: injected > 0 ? "ok" : (degraded ?? "empty"),
+    });
     try {
         const collection = await withinPromptBudget((signal) => Promise.all([
             hasJev
@@ -895,10 +905,12 @@ export async function preloadJevContextForPrompt(options) {
             memoryContext = collection.value[1];
         }
         else {
+            degraded = "timed_out";
             console.warn("[agent] Prompt context candidates exceeded the preload budget; keeping Analytics retrieval fallback.");
         }
     }
     catch (error) {
+        degraded = "failed";
         console.warn("[agent] Prompt context candidates unavailable; keeping Analytics retrieval fallback.", error instanceof Error ? error.message : "unknown error");
     }
     const candidates = [
@@ -915,7 +927,7 @@ export async function preloadJevContextForPrompt(options) {
             candidates,
             selectedIds: [],
         });
-        return "";
+        return finish("", 0);
     }
     const categoryFor = (candidate) => {
         const kind = candidate.metadata?.kind ?? candidate.kind;
@@ -971,13 +983,24 @@ export async function preloadJevContextForPrompt(options) {
                 }
             }
             else {
+                degraded ??= "timed_out";
                 console.warn("[agent] Jev ranking exceeded the preload budget; using bounded retrieval fallbacks.");
             }
         }
         catch (error) {
+            degraded ??= "failed";
             console.warn("[agent] Jev ranking unavailable; using bounded retrieval fallbacks.", error instanceof Error ? error.message : "unknown error");
         }
     }
+    // A ranking that was attempted and lost is a degraded turn, not an empty
+    // answer; the fallbacks below still run for it.
+    for (const result of rankings.values()) {
+        if (result.status === "failed")
+            degraded = "failed";
+        else if (result.status === "timed_out")
+            degraded ??= "timed_out";
+    }
+    const isRanked = (result) => result?.status === "selected" || result?.status === "no-match";
     const jevSelectedIds = [...rankings.values()]
         .filter((result) => result.status === "selected")
         .flatMap((result) => result.ids);
@@ -1002,13 +1025,13 @@ export async function preloadJevContextForPrompt(options) {
             for (const id of highSimilarityReferenceIds)
                 selected.add(id);
         }
-        else if (!referenceRanking || referenceRanking.status === "unavailable") {
+        else if (!isRanked(referenceRanking)) {
             for (const id of options.fallbackCandidateIds ?? [])
                 selected.add(id);
         }
     }
     const memoryRanking = rankings.get("memory");
-    if ((!hasJev || !memoryRanking || memoryRanking.status === "unavailable") &&
+    if ((!hasJev || !isRanked(memoryRanking)) &&
         memoryContext.fallbackIds.length > 0) {
         for (const id of memoryContext.fallbackIds)
             selected.add(id);
@@ -1061,7 +1084,7 @@ export async function preloadJevContextForPrompt(options) {
             candidates,
             injectedIds: new Set(),
         });
-        return "";
+        return finish("", 0);
     }
     const maxItemChars = options.compact ? 6_000 : JEV_CONTEXT_ITEM_MAX_CHARS;
     const maxTotalChars = Math.min(options.compact ? 16_000 : JEV_CONTEXT_TOTAL_MAX_CHARS, Math.max(0, options.maxChars ?? Number.POSITIVE_INFINITY));
@@ -1109,8 +1132,8 @@ export async function preloadJevContextForPrompt(options) {
         injectedIds,
     });
     if (blocks.length === 0)
-        return "";
-    return `${JEV_CONTEXT_PREFIX}${escapeJevContextFence(blocks.join(JEV_CONTEXT_SEPARATOR))}${JEV_CONTEXT_SUFFIX}`;
+        return finish("", 0);
+    return finish(`${JEV_CONTEXT_PREFIX}${escapeJevContextFence(blocks.join(JEV_CONTEXT_SEPARATOR))}${JEV_CONTEXT_SUFFIX}`, blocks.length);
 }
 /**
  * Pre-load the agent's context: AGENTS.md (workspace/template/runtime

package/dist/server/agent-chat/recurring-jobs-runtime.d.ts

@@ -1,16 +1,31 @@
-type RecurringJobsRuntimeEnvKey = "AGENT_NATIVE_BUILD_RECURRING_JOBS" | "AGENT_NATIVE_DISABLE_RECURRING_JOBS" | "AGENT_NATIVE_ENABLE_LOCAL_RECURRING_JOBS" | "APP_URL" | "BETTER_AUTH_URL" | "CF_PAGES" | "DEPLOY_URL" | "AWS_EXECUTION_ENV" | "AWS_LAMBDA_FUNCTION_NAME" | "NETLIFY" | "NETLIFY_LOCAL" | "NITRO_PRESET" | "NODE_ENV" | "SITE_ID" | "URL" | "VERCEL" | "VITE_APP_URL" | "VITE_WORKSPACE_GATEWAY_URL" | "WORKSPACE_GATEWAY_URL";
+type RecurringJobsRuntimeEnvKey = "A2A_SECRET" | "AGENT_NATIVE_BUILD_RECURRING_JOBS" | "AGENT_NATIVE_DISABLE_RECURRING_JOBS" | "AGENT_NATIVE_ENABLE_LOCAL_RECURRING_JOBS" | "APP_URL" | "BETTER_AUTH_URL" | "CF_PAGES" | "CRON_SECRET" | "DEPLOY_URL" | "AWS_EXECUTION_ENV" | "AWS_LAMBDA_FUNCTION_NAME" | "NETLIFY" | "NETLIFY_LOCAL" | "NITRO_PRESET" | "NODE_ENV" | "SITE_ID" | "URL" | "VERCEL" | "VERCEL_ENV" | "VITE_APP_URL" | "VITE_WORKSPACE_GATEWAY_URL" | "WORKSPACE_GATEWAY_URL";
 type RecurringJobsRuntimeEnv = Partial<Record<RecurringJobsRuntimeEnvKey, string | undefined>>;
-export declare function shouldDisableRecurringJobsRuntime(env?: RecurringJobsRuntimeEnv): boolean;
+/**
+ * Runtime facts the environment cannot carry. A Cloudflare Worker exposes its
+ * bindings only on the request, so the generated worker entry marks the
+ * isolate instead of setting an env var.
+ */
+export interface RecurringJobsPlatform {
+    cloudflareWorker: boolean;
+}
+export declare function shouldDisableRecurringJobsRuntime(env?: RecurringJobsRuntimeEnv, platform?: RecurringJobsPlatform): boolean;
 export declare function isNetlifyRecurringJobsRuntime(env?: RecurringJobsRuntimeEnv): boolean;
 export type RecurringJobsBuildMarker = "enabled" | "disabled";
 export declare const RECURRING_JOBS_BUILD_MARKER_ENV_VAR = "AGENT_NATIVE_BUILD_RECURRING_JOBS";
 export declare function resolveRecurringJobsBuildMarker(env?: RecurringJobsRuntimeEnv): RecurringJobsBuildMarker;
+export type PlatformScheduledTriggerDriver = "netlify-scheduled-function" | "vercel-cron" | "cloudflare-cron-trigger";
+export type ScheduledTriggerDriver = PlatformScheduledTriggerDriver | "in-process";
 export type ScheduledTriggerAvailability = {
     available: true;
-    driver: "netlify-scheduled-function" | "in-process";
+    driver: ScheduledTriggerDriver;
 } | {
     available: false;
     reason: "disabled-by-env" | "no-platform-scheduler" | "local-development";
+} | {
+    available: false;
+    reason: "missing-trigger-secret";
+    driver: PlatformScheduledTriggerDriver;
+    secret: "CRON_SECRET" | "A2A_SECRET";
 };
-export declare function scheduledTriggerAvailability(env?: RecurringJobsRuntimeEnv): ScheduledTriggerAvailability;
+export declare function scheduledTriggerAvailability(env?: RecurringJobsRuntimeEnv, platform?: RecurringJobsPlatform): ScheduledTriggerAvailability;
 export {};