@agent-native/core 0.225.1-nightly-20261106122820 → 0.225.1

package/dist/agent/optional-placeholders.js

@@ -83,14 +83,14 @@ function resolveObjectSchemaBranch(schema, value) {
     const index = discriminatedBranchIndex(branches, value);
     return index >= 0 ? branches[index] : undefined;
 }
-function stripOptionalToolPlaceholders(schema, value, emptyValues) {
+function stripOptionalToolPlaceholders(schema, value, emptyValues, depth = 0) {
     if (!schema)
         return { value, changed: false };
     if (Array.isArray(value)) {
         const itemSchema = leafBranches(schema).find((branch) => branch.items)?.items;
         if (!itemSchema)
             return { value, changed: false };
-        const results = value.map((item) => stripOptionalToolPlaceholders(itemSchema, item, emptyValues));
+        const results = value.map((item) => stripOptionalToolPlaceholders(itemSchema, item, emptyValues, depth + 1));
         return results.some((result) => result.changed)
             ? { value: results.map((result) => result.value), changed: true }
             : { value, changed: false };
@@ -119,6 +119,14 @@ function stripOptionalToolPlaceholders(schema, value, emptyValues) {
             }
             continue;
         }
+        // Top-level only: a nested null may be a deliberate clear.
+        if (emptyValues.stripNull &&
+            depth === 0 &&
+            entry === null &&
+            !required.has(key)) {
+            placeholders.push(key);
+            continue;
+        }
         if (!required.has(key) && isStructurallyEmptyToolValue(entry)) {
             if (schemaRejectsToolValue(propertySchema, entry)) {
                 if (emptyValues.nullOnly && entry !== null)
@@ -128,9 +136,12 @@ function stripOptionalToolPlaceholders(schema, value, emptyValues) {
                 continue;
             }
             // A valid `false` sets a value, and `[]` on an action that says an empty
-            // list erases nothing is padding. Elsewhere `[]` could wipe a stored
+            // list erases nothing is padding. `null` on an optional field is absent:
+            // models fill every unused field with it, so it never marks a call as
+            // clearing data. Elsewhere `[]` could wipe a stored
             // list. An empty equal to the schema's own default changes nothing.
             if (entry !== false &&
+                entry !== null &&
                 !(emptyValues.listsEraseNothing &&
                     Array.isArray(entry) &&
                     entry.length === 0) &&
@@ -139,7 +150,7 @@ function stripOptionalToolPlaceholders(schema, value, emptyValues) {
                     JSON.stringify(propertySchema.default) === JSON.stringify(entry)))
                 emptyValues.valid = true;
         }
-        const nested = stripOptionalToolPlaceholders(propertySchema, entry, emptyValues);
+        const nested = stripOptionalToolPlaceholders(propertySchema, entry, emptyValues, depth + 1);
         if (nested.changed) {
             normalized ??= { ...record };
             normalized[key] = nested.value;
@@ -175,7 +186,15 @@ export function normalizeOptionalToolPlaceholders(schema, input, entry, { nullOn
         nullOnly,
         listsEraseNothing: entry.emptyListsEraseNothing === true,
     };
-    const result = stripOptionalToolPlaceholders(schema, input, emptyValues);
+    let result = stripOptionalToolPlaceholders(schema, input, emptyValues);
+    // A padded call means its nulls are padding too, including on nullable
+    // fields where a lone null would be a deliberate clear.
+    if (emptyValues.invalid && !emptyValues.valid) {
+        result = stripOptionalToolPlaceholders(schema, input, {
+            ...emptyValues,
+            stripNull: true,
+        });
+    }
     // Only a declared read is exempt: a dynamic plan-mode effect classifies the
     // raw input, which defaults can turn into a write.
     if (emptyValues.valid &&

package/dist/agent/production-agent.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { AGENT_NATIVE_SUBMISSION_EXPIRES_AT_METADATA_KEY, AGENT_NATIVE_SUBMISSION_TTL_MS_METADATA_KEY, MAX_AGENT_REQUEST_ATTACHMENT_DATA_CHARS, parseQueueMessageInput, persistableFilePart, fingerprintAgentSubmissionAttachment, submissionAttachmentsMatch, } from "@agent-native/agentkit/protocol";
+import { AGENT_NATIVE_SUBMISSION_EXPIRES_AT_METADATA_KEY, AGENT_NATIVE_SUBMISSION_TTL_MS_METADATA_KEY, MAX_AGENT_REQUEST_ATTACHMENT_DATA_CHARS, parseQueueMessageInput, persistableFilePart, fingerprintAgentSubmissionAttachment, isPersistableAttachmentUrl, submissionAttachmentsMatch, } from "@agent-native/agentkit/protocol";
 import Ajv from "ajv";
 import Ajv2020 from "ajv/dist/2020.js";
 import { defineEventHandler, getHeader, setResponseHeader, setResponseStatus, getMethod, } from "h3";
@@ -1412,23 +1412,6 @@ export { DurableAttachmentReferenceRequiredError };
 function isDataUrlReference(value) {
     return typeof value === "string" && /^\s*data:/i.test(value);
 }
-function hasDurableAttachmentUrl(value) {
-    if (typeof value !== "string")
-        return false;
-    const normalized = value.trim();
-    if (!normalized ||
-        isDataUrlReference(normalized) ||
-        isRawBase64Payload(normalized) ||
-        !URL.canParse(normalized)) {
-        return false;
-    }
-    const url = new URL(normalized);
-    return (url.protocol === "https:" &&
-        !url.username &&
-        !url.password &&
-        !url.search &&
-        !url.hash);
-}
 const OMIT_DURABLE_DISPATCH_VALUE = Symbol("omit-durable-dispatch-value");
 const DURABLE_ATTACHMENT_PAYLOAD_FIELDS = /^(?:base64|bytes|body|data|dataurl|image|payload)$/i;
 const DURABLE_ATTACHMENT_REFERENCE_FIELDS = /^(?:preview|referenceUrl|src|thumbnail|url)$/i;
@@ -1516,7 +1499,7 @@ function sanitizeDurableAttachment(value, attachmentContext = false, requiredAtt
             (attachmentReferenceField &&
                 typeof value === "string" &&
                 (isInlineBase64Payload(value) ||
-                    (value.trim().length > 0 && !hasDurableAttachmentUrl(value)))))) {
+                    (value.trim().length > 0 && !isPersistableAttachmentUrl(value)))))) {
         return OMIT_DURABLE_DISPATCH_VALUE;
     }
     if (Array.isArray(value)) {
@@ -1537,12 +1520,12 @@ function sanitizeDurableAttachment(value, attachmentContext = false, requiredAtt
     const isAttachment = attachmentContext || typedAttachment;
     const hasInlinePayload = isAttachment && containsDurableAttachmentPayload(item, true);
     const hasDurableReference = item.type === "image"
-        ? hasDurableAttachmentUrl(item.url)
-        : hasDurableAttachmentUrl(item.url) ||
-            hasDurableAttachmentUrl(item.referenceUrl);
+        ? isPersistableAttachmentUrl(item.url)
+        : isPersistableAttachmentUrl(item.url) ||
+            isPersistableAttachmentUrl(item.referenceUrl);
     const hasInlineReference = [item.url, item.referenceUrl].some((reference) => typeof reference === "string" &&
         reference.trim().length > 0 &&
-        !hasDurableAttachmentUrl(reference));
+        !isPersistableAttachmentUrl(reference));
     if ((requiredAttachment || typedAttachment) &&
         (hasInlinePayload || hasInlineReference) &&
         !hasDurableReference) {
@@ -9040,11 +9023,12 @@ async function queueableAttachments(attachments, ownerEmail, requestAttachmentIn
                     ? { fileId: record.id }
                     : {}),
         });
-        if (!part.fileId &&
-            inlineData &&
+        let uploadAttempted = false;
+        if (inlineData &&
             (!part.url || !record.uploadProvider || record.storageUploadFailed)) {
             const parsedData = parseBase64DataUrl(inlineData);
             if (parsedData) {
+                uploadAttempted = true;
                 const uploaded = await uploadFile({
                     data: new Uint8Array(Buffer.from(parsedData.data, "base64")),
                     filename: attachment.name,
@@ -9059,15 +9043,16 @@ async function queueableAttachments(attachments, ownerEmail, requestAttachmentIn
                         name: attachment.name,
                         ...(mediaType ? { mediaType } : {}),
                         url: uploaded.url,
+                        ...(part.fileId ? { fileId: part.fileId } : {}),
                     });
                 }
             }
         }
         if (requestAttachmentIndexes.has(index)) {
-            if (!part.url || !hasDurableAttachmentUrl(part.url))
+            if (!part.url || !isPersistableAttachmentUrl(part.url))
                 return null;
             const referenceUrl = attachment.referenceUrl;
-            if (referenceUrl && !hasDurableAttachmentUrl(referenceUrl))
+            if (referenceUrl && !isPersistableAttachmentUrl(referenceUrl))
                 return null;
             requestFiles.push({
                 type: "image",
@@ -9078,8 +9063,13 @@ async function queueableAttachments(attachments, ownerEmail, requestAttachmentIn
             });
             continue;
         }
-        if (!part.url && !part.fileId)
-            return null;
+        if (!part.url) {
+            // A failed upload is transient (null -> retryable); an id with no
+            // uploadable bytes can never become a reference.
+            if (uploadAttempted)
+                return null;
+            throw new DurableAttachmentReferenceRequiredError();
+        }
         files.push(part);
     }
     return { attachments: files, requestAttachments: requestFiles };
@@ -9128,12 +9118,12 @@ function validateQueuedPromotionRequestAttachments(value) {
                 return null;
             }
         }
-        if ((typeof url === "string" && !hasDurableAttachmentUrl(url)) ||
+        if ((typeof url === "string" && !isPersistableAttachmentUrl(url)) ||
             (typeof attachment.referenceUrl === "string" &&
-                !hasDurableAttachmentUrl(attachment.referenceUrl)) ||
+                !isPersistableAttachmentUrl(attachment.referenceUrl)) ||
             (typeof data !== "string" &&
-                !hasDurableAttachmentUrl(url) &&
-                !hasDurableAttachmentUrl(attachment.referenceUrl))) {
+                !isPersistableAttachmentUrl(url) &&
+                !isPersistableAttachmentUrl(attachment.referenceUrl))) {
             return null;
         }
         attachments.push(attachment);
@@ -10339,7 +10329,21 @@ export function createProductionAgentHandler(options) {
                 setResponseStatus(event, 404);
                 return { error: "Thread not found" };
             }
-            const attachmentsForQueue = await queueableAttachments(requestAttachments, ownerEmail, submissionRequestAttachmentIndexes);
+            let attachmentsForQueue;
+            try {
+                attachmentsForQueue = await queueableAttachments(requestAttachments, ownerEmail, submissionRequestAttachmentIndexes);
+            }
+            catch (error) {
+                if (!(error instanceof DurableAttachmentReferenceRequiredError)) {
+                    throw error;
+                }
+                setResponseStatus(event, 503);
+                return {
+                    error: error.message,
+                    code: error.code,
+                    retryable: false,
+                };
+            }
             if (!attachmentsForQueue) {
                 if (requestAttachments.some((attachment) => attachment.displayOnly !== true &&
                     (attachment.type === "image" ||

package/dist/agent/run-store.js

@@ -5138,13 +5138,16 @@ async function retryPendingStaleRunThreadProjections(client) {
         const projection = row;
         if (projection.thread_projection_error_code != null) {
             failed += 1;
+            console.error(`[run-store] stale projection stuck for run ${String(projection.id)}:`, projection.thread_projection_error_code);
             continue;
         }
         const runId = projection.id;
         if (typeof runId !== "string")
             continue;
-        if (!(await finalizeStaleRun(runId, "stale-projection-retry")))
+        if (!(await finalizeStaleRun(runId, "stale-projection-retry"))) {
             failed += 1;
+            console.error(`[run-store] stale projection retry failed for run ${runId}`);
+        }
     }
     return { failed, truncated };
 }

package/dist/client/integrations/workspace-provider-oauth.d.ts

@@ -15,4 +15,28 @@ export interface WorkspaceProviderOAuthOptions {
     targetAccountEmail?: string;
 }
 export declare function workspaceProviderOAuthUrl(provider: string, options: WorkspaceProviderOAuthOptions): string;
+/** True when this app runs inside another page's iframe (for example Dispatch). */
+export declare function isFramedContext(): boolean;
+/**
+ * The completion route the OAuth popup returns to. Written in the
+ * mount-relative, internal `/_agent-native` form: the app's server joins it to
+ * its own mount (see `getAppUrl`), so a path-mounted deployment does not double
+ * the prefix. The completion page posts the workspace-connection message back
+ * to the opener.
+ */
+export declare const WORKSPACE_CONNECTION_COMPLETION_RETURN = "/_agent-native/oauth/popup?complete=workspace-connection";
+/**
+ * The start URL for a popup that returns to the framework completion page, so
+ * an embedded app can learn the flow finished instead of navigating its frame
+ * to the provider (which providers refuse to be framed). The caller's own
+ * `returnPath` is preserved in the options and applied on completion.
+ */
+export declare function workspaceProviderOAuthPopupStartUrl(provider: string, options: WorkspaceProviderOAuthOptions): string;
+/**
+ * Resolve when the popup posts the framework completion message, or when it is
+ * closed without one. Accepts the completion page's origin, which can be a
+ * configured API origin distinct from the embedded UI origin, while still
+ * binding to the exact popup window. Returns a stop function.
+ */
+export declare function watchWorkspaceConnectionCompletion(popup: Window, onComplete: () => void, expectedOrigin?: string): () => void;
 export declare function startWorkspaceProviderOAuth(provider: string, options: WorkspaceProviderOAuthOptions): void;

package/dist/client/integrations/workspace-provider-oauth.js

@@ -1,4 +1,6 @@
+import { FRAMEWORK_INTERNAL_ROUTE_PREFIX } from "../../shared/framework-route-prefix.js";
 import { agentNativePath } from "../api-path.js";
+import { openOAuthPopup } from "../oauth-popup.js";
 import { serverMountReturnPath } from "../sign-in-return.js";
 export function workspaceProviderOAuthUrl(provider, options) {
     const params = new URLSearchParams({
@@ -22,6 +24,114 @@ export function workspaceProviderOAuthUrl(provider, options) {
     }
     return agentNativePath(`/_agent-native/connections/oauth/${provider}/start?${params.toString()}`);
 }
+/** True when this app runs inside another page's iframe (for example Dispatch). */
+export function isFramedContext() {
+    if (typeof window === "undefined")
+        return false;
+    try {
+        return window.top !== window.self;
+    }
+    catch {
+        // A cross-origin ancestor makes `window.top` throw; that means framed.
+        return true;
+    }
+}
+/**
+ * The completion route the OAuth popup returns to. Written in the
+ * mount-relative, internal `/_agent-native` form: the app's server joins it to
+ * its own mount (see `getAppUrl`), so a path-mounted deployment does not double
+ * the prefix. The completion page posts the workspace-connection message back
+ * to the opener.
+ */
+export const WORKSPACE_CONNECTION_COMPLETION_RETURN = `${FRAMEWORK_INTERNAL_ROUTE_PREFIX}/oauth/popup?complete=workspace-connection`;
+/** The origin that will serve the completion page and post the message. */
+function completionOrigin(startUrl) {
+    if (!URL.canParse(startUrl, window.location.href))
+        return undefined;
+    return new URL(startUrl, window.location.href).origin;
+}
+/**
+ * The start URL for a popup that returns to the framework completion page, so
+ * an embedded app can learn the flow finished instead of navigating its frame
+ * to the provider (which providers refuse to be framed). The caller's own
+ * `returnPath` is preserved in the options and applied on completion.
+ */
+export function workspaceProviderOAuthPopupStartUrl(provider, options) {
+    return workspaceProviderOAuthUrl(provider, {
+        ...options,
+        serverReturnPath: WORKSPACE_CONNECTION_COMPLETION_RETURN,
+    });
+}
+/**
+ * Resolve when the popup posts the framework completion message, or when it is
+ * closed without one. Accepts the completion page's origin, which can be a
+ * configured API origin distinct from the embedded UI origin, while still
+ * binding to the exact popup window. Returns a stop function.
+ */
+export function watchWorkspaceConnectionCompletion(popup, onComplete, expectedOrigin) {
+    let closedTicks = 0;
+    const stop = () => {
+        window.removeEventListener("message", onMessage);
+        window.clearInterval(closedTimer);
+    };
+    const onMessage = (event) => {
+        const originAccepted = event.origin === window.location.origin ||
+            (expectedOrigin !== undefined && event.origin === expectedOrigin);
+        if (!originAccepted || event.source !== popup)
+            return;
+        const data = event.data;
+        if (typeof data !== "object" ||
+            data === null ||
+            data.type !==
+                "agent-native:workspace-connection-complete")
+            return;
+        stop();
+        onComplete();
+    };
+    // The completion message is posted just before the popup closes; wait one
+    // extra tick so a close never wins the race against it.
+    const closedTimer = window.setInterval(() => {
+        if (!popup.closed) {
+            closedTicks = 0;
+            return;
+        }
+        closedTicks += 1;
+        if (closedTicks > 1)
+            stop();
+    }, 500);
+    window.addEventListener("message", onMessage);
+    return stop;
+}
+/**
+ * Apply the caller's return target on completion, so resume state carried in
+ * `returnPath` survives an embedded flow. Falls back to a reload.
+ */
+function applyReturnPath(options) {
+    if (options.returnPath) {
+        window.location.assign(options.returnPath);
+        return;
+    }
+    window.location.reload();
+}
 export function startWorkspaceProviderOAuth(provider, options) {
+    if (isFramedContext()) {
+        // Providers refuse to be framed (X-Frame-Options / frame-ancestors), so a
+        // same-window navigation inside Dispatch's iframe is refused. Leave the
+        // frame: run the flow in a popup whose completion page posts back.
+        const startUrl = workspaceProviderOAuthPopupStartUrl(provider, options);
+        const popup = openOAuthPopup({
+            initialUrl: startUrl,
+            features: "width=640,height=760",
+        });
+        if (popup) {
+            watchWorkspaceConnectionCompletion(popup, () => applyReturnPath(options), completionOrigin(startUrl));
+            return;
+        }
+        // Popup blocked while embedded. Never navigate this frame into the
+        // provider — the frame refuses it and the user cannot connect at all.
+        // Surface the recovery; the caller retries once popups are allowed.
+        console.warn("[agent-native] OAuth popup was blocked while embedded in another page; allow popups for this site to connect the provider.");
+        return;
+    }
     window.location.assign(workspaceProviderOAuthUrl(provider, options));
 }

package/dist/framework-package-versions.json

@@ -1,17 +1,17 @@
 {
-  "@agent-native/agentkit": "0.225.1-nightly-20261106122820",
+  "@agent-native/agentkit": "0.225.1",
   "@agent-native/code-agents-ui": "0.1.75",
-  "@agent-native/core": "0.225.1-nightly-20261106122820",
-  "@agent-native/core-corpus": "0.225.1-nightly-20261106122820",
-  "@agent-native/creative-context": "0.8.66",
-  "@agent-native/dispatch": "0.42.2-nightly-20261106122820",
+  "@agent-native/core": "0.225.1",
+  "@agent-native/core-corpus": "0.225.1",
+  "@agent-native/creative-context": "0.8.67",
+  "@agent-native/dispatch": "0.42.2",
   "@agent-native/embedding": "0.2.0",
   "@agent-native/migrate": "0.0.7",
-  "@agent-native/otel": "0.1.33",
-  "@agent-native/pinpoint": "0.1.109",
-  "@agent-native/recap-cli": "0.5.97",
-  "@agent-native/scheduling": "0.2.53",
+  "@agent-native/otel": "0.1.34",
+  "@agent-native/pinpoint": "0.1.110",
+  "@agent-native/recap-cli": "0.5.98",
+  "@agent-native/scheduling": "0.2.54",
   "@agent-native/shared-app-config": "0.1.2",
-  "@agent-native/skills": "0.4.2-nightly-20261106122820",
-  "@agent-native/toolkit": "0.225.1-nightly-20261106122820"
+  "@agent-native/skills": "0.4.2",
+  "@agent-native/toolkit": "0.225.1"
 }

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

@@ -8167,28 +8167,38 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                             jobsSkippedReason: "unclaimed-background-sweep-failed",
                         };
                     }
+                    const incompleteSteps = [
+                        staleRunReapIncomplete && "staleRunsReaped",
+                        agentHarnessFollowUpRecoveryIncomplete &&
+                            "expiredAgentHarnessFollowUps",
+                        agentHarnessApprovalRecoveryIncomplete &&
+                            "expiredAgentHarnessApprovals",
+                        appSweepHandlers.failed.length > 0 && "appSweepHandlers",
+                        automationFailureAlerts === null && "automationFailureAlerts",
+                        (queuedSubmissionDrain === null ||
+                            queuedSubmissionDrain.failed > 0) &&
+                            "queuedSubmissionDrain",
+                        (staleAgentTeamRuns === null || staleAgentTeamRuns.failed > 0) &&
+                            "staleAgentTeamRuns",
+                    ].filter((step) => typeof step === "string");
+                    if (incompleteSteps.length > 0) {
+                        console.error("[recurring-jobs] Sweep incomplete:", {
+                            incompleteSteps,
+                            staleRunsReaped,
+                            expiredAgentHarnessFollowUps,
+                            expiredAgentHarnessApprovals,
+                            staleAgentTeamRuns,
+                            queuedSubmissionDrain,
+                            automationFailureAlerts,
+                            appSweepHandlers,
+                        });
+                    }
                     if (!triggerAvailability.available) {
-                        if (staleRunReapIncomplete ||
-                            agentHarnessFollowUpRecoveryIncomplete ||
-                            agentHarnessApprovalRecoveryIncomplete ||
-                            appSweepHandlers.failed.length > 0 ||
-                            automationFailureAlerts === null ||
-                            queuedSubmissionDrain === null ||
-                            queuedSubmissionDrain.failed > 0 ||
-                            staleAgentTeamRuns === null ||
-                            staleAgentTeamRuns.failed > 0) {
+                        if (incompleteSteps.length > 0) {
                             setResponseStatus(event, 500);
                         }
                         return {
-                            ok: !staleRunReapIncomplete &&
-                                !agentHarnessFollowUpRecoveryIncomplete &&
-                                !agentHarnessApprovalRecoveryIncomplete &&
-                                appSweepHandlers.failed.length === 0 &&
-                                automationFailureAlerts !== null &&
-                                queuedSubmissionDrain !== null &&
-                                queuedSubmissionDrain.failed === 0 &&
-                                staleAgentTeamRuns !== null &&
-                                staleAgentTeamRuns.failed === 0,
+                            ok: incompleteSteps.length === 0,
                             staleRunsReaped,
                             expiredAgentHarnessFollowUps,
                             expiredAgentHarnessApprovals,
@@ -8204,15 +8214,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     }
                     try {
                         await processRecurringJobs(schedulerDeps);
-                        if (staleRunReapIncomplete ||
-                            agentHarnessFollowUpRecoveryIncomplete ||
-                            agentHarnessApprovalRecoveryIncomplete ||
-                            appSweepHandlers.failed.length > 0 ||
-                            automationFailureAlerts === null ||
-                            queuedSubmissionDrain === null ||
-                            queuedSubmissionDrain.failed > 0 ||
-                            staleAgentTeamRuns === null ||
-                            staleAgentTeamRuns.failed > 0) {
+                        if (incompleteSteps.length > 0) {
                             setResponseStatus(event, 500);
                             return {
                                 ok: false,

package/dist/server/auth.js

@@ -3211,11 +3211,38 @@ function createAuthGuardFn(app) {
         if (session) {
             const method = getMethod(event);
             if (p.startsWith("/api/") || p.startsWith("/_agent-native/")) {
+                // A fresh loopback dev workspace has no session org yet, and the
+                // read-only session resolver never creates one, so the app-access check
+                // below can deny before the ordinary org initializer runs. Resolve (or
+                // create) the existing default org through the normal policy first and
+                // hand its id to the unchanged check. The check still owns the verdict;
+                // a missing or failed org initialization also denies protected requests,
+                // while null keeps the wrapper's org-recovery exemption.
+                let workspaceOrgId = session.orgId;
+                let workspaceOrgInitializationFailed = false;
+                if (!workspaceOrgId &&
+                    !hasExplicitPersonalOrgScope(event) &&
+                    isSyntheticAutoDevIdentity(session.email) &&
+                    isLoopbackDevRequest(event) &&
+                    getAppConfig().access.orgCreation === "open" &&
+                    getAppConfig().access.autoCreateDefaultOrg) {
+                    const { getOrgContext } = await import("../org/context.js");
+                    try {
+                        const org = await getOrgContext(event);
+                        if (org.orgId)
+                            workspaceOrgId = org.orgId;
+                        else
+                            workspaceOrgInitializationFailed = true;
+                    }
+                    catch {
+                        workspaceOrgInitializationFailed = true;
+                    }
+                }
                 let workspaceAppAccess = await checkWorkspaceAppAccessForRequest({
                     path: p,
                     method,
                     email: session.email,
-                    ...(session.orgId === undefined ? {} : { orgId: session.orgId }),
+                    ...(workspaceOrgId === undefined ? {} : { orgId: workspaceOrgId }),
                 });
                 if (workspaceAppAccess === false &&
                     !session.orgId &&
@@ -3246,7 +3273,8 @@ function createAuthGuardFn(app) {
                     setResponseStatus(event, 503);
                     return workspaceAppAccessUnavailableBody(workspaceAppAccess);
                 }
-                if (workspaceAppAccess === false) {
+                if ((workspaceOrgInitializationFailed && workspaceAppAccess !== null) ||
+                    workspaceAppAccess === false) {
                     setResponseStatus(event, 403);
                     return { error: "You do not have access to this workspace app." };
                 }
@@ -3408,6 +3436,22 @@ export function isLocalDevAuthAllowed(event) {
         ((!isHostedPreviewRequest(event) && isLoopbackRequest(event)) ||
             isBuilderPreviewLocalDevRequest(event)));
 }
+/**
+ * A real loopback dev/test request. `isLocalDevAuthAllowed` also admits the
+ * Builder-preview branch, which does not require loopback, so org
+ * auto-initialization additionally requires the actual socket peer and
+ * excludes hosted-preview hosts. Builder preview keeps the ordinary
+ * app-access path.
+ */
+function isLoopbackDevRequest(event) {
+    return (isLocalDevAuthAllowed(event) &&
+        isLoopbackRequest(event) &&
+        !isHostedPreviewRequest(event));
+}
+/** The framework's own throwaway local account, never a real signup. */
+function isSyntheticAutoDevIdentity(email) {
+    return (email === AUTO_DEV_ACCOUNT_EMAIL || email === LEGACY_AUTO_DEV_ACCOUNT_EMAIL);
+}
 async function createOrReuseAutoDevSession(auth, config) {
     let session = await createBetterAuthSessionForEmail(AUTO_DEV_ACCOUNT_EMAIL, config);
     if (!session) {

package/dist/shared/attachments.d.ts

@@ -1,3 +1,4 @@
+import { isPersistableAttachmentUrl } from "@agent-native/agentkit/protocol";
+export { isPersistableAttachmentUrl };
 export declare function isInlineDataUrl(value: unknown): value is string;
-export declare function isPersistableAttachmentUrl(value: unknown): value is string;
 export declare function stripInlineAttachmentPayloads(value: unknown, attachmentContext?: boolean): unknown;

package/dist/shared/attachments.js

@@ -1,3 +1,5 @@
+import { isPersistableAttachmentUrl } from "@agent-native/agentkit/protocol";
+export { isPersistableAttachmentUrl };
 const ATTACHMENT_BODY_FIELDS = new Set([
     "base64",
     "bytes",
@@ -30,19 +32,6 @@ const ATTACHMENT_CONTEXT_FIELDS = new Set([
 export function isInlineDataUrl(value) {
     return typeof value === "string" && /^\s*data:/i.test(value);
 }
-export function isPersistableAttachmentUrl(value) {
-    if (typeof value !== "string" || !value.trim())
-        return false;
-    if (!URL.canParse(value))
-        return false;
-    const url = new URL(value);
-    return (url.protocol === "https:" &&
-        Boolean(url.hostname) &&
-        !url.username &&
-        !url.password &&
-        !url.search &&
-        !url.hash);
-}
 function isBase64Payload(value) {
     return (typeof value === "string" &&
         value.trim().length >= 64 &&

package/dist/shared/inline-bytes.js

@@ -1,19 +1,6 @@
+import { isPersistableAttachmentReferenceUrl } from "@agent-native/agentkit/protocol";
 import { isInlineDataUrl } from "./attachments.js";
 import { parseDataUrl } from "./data-url.js";
-function isPersistableAttachmentReferenceUrl(value) {
-    if (typeof value !== "string" || !value.trim() || value.length > 8192) {
-        return false;
-    }
-    if (!URL.canParse(value))
-        return false;
-    const url = new URL(value);
-    return ((url.protocol === "http:" || url.protocol === "https:") &&
-        Boolean(url.hostname) &&
-        !url.username &&
-        !url.password &&
-        !url.search &&
-        !url.hash);
-}
 /**
  * Inline file bytes reached a SQL write with no durable URL to stand in for
  * them. Raised only by the `reject` policy; a durable dispatch payload must
@@ -177,10 +164,10 @@ function sanitize(value, policy, inAttachmentList, inheritedUrl, inAttachmentMet
     const ownUrl = hasAttachmentContext ? durableUrl(item) : undefined;
     const fallbackUrl = ownUrl ?? (hasAttachmentContext ? inheritedUrl : undefined);
     const inline = hasAttachmentContext ? inlineKeys(item) : [];
-    const unreferenced = isAttachment &&
-        inline.length > 0 &&
-        !fallbackUrl &&
-        !(typeof item.fileId === "string" && item.fileId);
+    // A `fileId` names the attachment; nothing resolves it back to bytes, so it
+    // never stands in for bytes that need a URL. The dispatch serializer agrees
+    // for parts that carry bytes.
+    const unreferenced = isAttachment && inline.length > 0 && !fallbackUrl;
     if (unreferenced && policy === "reject") {
         throw new DurableAttachmentReferenceRequiredError();
     }

package/package.json

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