@agent-native/core 0.209.1 → 0.209.2-nightly-20261016005836

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

@@ -59,7 +59,7 @@ import { AGENT_CHAT_STREAM_PATH, AGENT_CHAT_STREAM_TOKEN_SUFFIX, AGENT_CHAT_STRE
 import { handleSharedThreadRequest, } from "./agent-chat/shared-thread.js";
 import { sortResourceSkills } from "./agent-chat/skill-frontmatter.js";
 import { discoverAgents } from "./agent-discovery.js";
-import { resolveAgentRunOrgId, resolveAgentRunOwnerContext, runWithAgentRunContext, seedAgentRunOwnerContext, seedBackgroundAgentRunOwnerContext, } from "./agent-run-context.js";
+import { resolveAgentRunOrgId, resolveAgentRunOrgScope, resolveAgentRunOwnerContext, runWithAgentRunContext, seedAgentRunOwnerContext, seedBackgroundAgentRunOwnerContext, } from "./agent-run-context.js";
 import { AGENT_TEAM_PROCESS_RUN_PATH, getCurrentDelegationDepth, processAgentTeamRun, reconcileStaleAgentTeamRuns, reconcileAgentTeamRunsForOwner, } from "./agent-teams.js";
 import { getSession, isLoopbackRequest, registerAuthPublicPaths, } from "./auth.js";
 import { captureError } from "./capture-error.js";
@@ -71,9 +71,11 @@ import { getOrigin } from "./google-oauth.js";
 import { readBody } from "./h3-helpers.js";
 import { loadHostedHarnessConfig } from "./hosted-harness-policy.js";
 import { startIntervalJob } from "./interval-job.js";
+import { isDirectLoopbackRequest } from "./loopback.js";
 import { getModelFamilyOverlay } from "./prompts/index.js";
 import { mountRealtimeVoiceRoutes } from "./realtime-voice.js";
 import { runWithRequestContext, getRequestContext, getRequestOrgId, getRequestUserEmail, getRequestRunContext, ensureRequestRunContext, } from "./request-context.js";
+import { getForwardedRequestOrigin } from "./request-origin.js";
 export { handleSharedThreadRequest };
 export function trackAgentChatRunLifecycle(event, threadId, attemptId, userId, properties = {}, appId, trackingSource) {
     if (!threadId?.trim() ||
@@ -3389,10 +3391,12 @@ export function createAgentChatPlugin(options) {
                 const owner = await getOwnerFromEvent(event);
                 const orgId = await getOrgIdFromEvent(event);
                 const { resolveOwnerEngineApiKey } = await import("../agent/production-agent.js");
-                const userApiKey = await resolveOwnerEngineApiKey({
-                    engineOption: options?.engine,
-                    ownerEmail: owner,
-                });
+                const userApiKey = owner
+                    ? await resolveOwnerEngineApiKey({
+                        engineOption: options?.engine,
+                        ownerEmail: owner,
+                    })
+                    : { apiKey: undefined, apiKeyEnvVar: undefined };
                 const runCtx = ensureRequestRunContext();
                 if (runCtx) {
                     runCtx.requestOrigin = getOrigin(event);
@@ -4150,14 +4154,27 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                 catch {
                     orgCtx = null;
                 }
-                const orgId = (options?.resolveOrgId
-                    ? await options.resolveOrgId(event)
-                    : (orgCtx?.orgId ?? session.orgId ?? null)) ?? null;
-                const canUpdate = await canUpdateAgentAppModelDefaultSettings(session.email, orgId);
+                const orgScope = await resolveAgentRunOrgScope({
+                    event,
+                    ownerContext: { owner: session.email, anonymous: false },
+                    resolveOrgId: options?.resolveOrgId,
+                });
+                if (!orgScope.orgId && orgScope.orgScope !== "personal") {
+                    return {
+                        ok: false,
+                        status: 503,
+                        error: "Organization scope is temporarily unavailable.",
+                    };
+                }
+                const orgId = orgScope.orgId ?? null;
+                const canUpdate = await canUpdateAgentAppModelDefaultSettings(session.email, orgId, orgScope.orgScope);
                 return {
                     ok: true,
                     userEmail: session.email,
                     orgId,
+                    ...(orgScope.orgScope === "personal"
+                        ? { orgScope: "personal" }
+                        : {}),
                     orgName: orgCtx?.orgId === orgId ? (orgCtx.orgName ?? null) : null,
                     role: orgCtx?.orgId === orgId ? (orgCtx.role ?? null) : null,
                     canUpdate,
@@ -4166,12 +4183,15 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             const listModelDefaultEngineOptions = async (ctx, event) => {
                 registerBuiltinEngines();
                 const availableEngines = listAgentEngines();
-                const chatGPTEnabled = !ctx.orgId &&
+                const directLoopbackRequest = isDirectLoopbackRequest(event);
+                const chatGPTEnabled = directLoopbackRequest &&
+                    ctx.orgScope === "personal" &&
+                    !ctx.orgId &&
                     !!ctx.userEmail &&
                     availableEngines.some((entry) => entry.name === CHATGPT_SUBSCRIPTION_ENGINE_NAME) &&
                     (await getUserLabEnabled(ctx.userEmail, CHATGPT_SUBSCRIPTION_LAB));
                 // Provider model selections follow the setting scope. ChatGPT catalogs
-                // are user-scoped, so they are only available for personal defaults.
+                // are user-scoped, so organization defaults cannot use them.
                 const selectionScope = ctx.orgId ? "org" : "user";
                 const selections = new Map();
                 const modelsFor = async (entry) => {
@@ -4192,8 +4212,12 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                 return runWithRequestContext({
                     userEmail: ctx.userEmail,
                     orgId: ctx.orgId ?? undefined,
-                    requestOrigin: getOrigin(event),
+                    ...(ctx.orgScope === "personal"
+                        ? { orgScope: "personal" }
+                        : {}),
+                    requestOrigin: getForwardedRequestOrigin(event),
                     isLoopbackRequest: isLoopbackRequest(event),
+                    isDirectLoopbackRequest: isDirectLoopbackRequest(event),
                 }, async () => {
                     const chatGPTCatalog = chatGPTEnabled && ctx.userEmail
                         ? await listChatGPTSubscriptionModels(ctx.userEmail)
@@ -4224,7 +4248,11 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                 const ctx = await resolveModelDefaultsContext(event);
                 if (!ctx.ok)
                     return ctx;
-                const scope = { userEmail: ctx.userEmail, orgId: ctx.orgId };
+                const scope = {
+                    userEmail: ctx.userEmail,
+                    orgId: ctx.orgId,
+                    orgScope: ctx.orgScope,
+                };
                 const [settings, orgDefault] = await Promise.all([
                     readAgentAppModelDefaultSettings(scope, appId),
                     readDefaultAgentEngineSetting(scope),
@@ -4283,7 +4311,11 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     };
                 }
                 if (method === "DELETE") {
-                    await resetAgentAppModelDefaultSettings({ userEmail: ctx.userEmail, orgId: ctx.orgId }, appId);
+                    await resetAgentAppModelDefaultSettings({
+                        userEmail: ctx.userEmail,
+                        orgId: ctx.orgId,
+                        orgScope: ctx.orgScope,
+                    }, appId);
                     return buildModelDefaultsPayload(event, appId);
                 }
                 const body = await readBody(event).catch(() => ({}));
@@ -4322,8 +4354,12 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     const catalog = await runWithRequestContext({
                         userEmail: ctx.userEmail,
                         orgId: ctx.orgId ?? undefined,
-                        requestOrigin: getOrigin(event),
+                        ...(ctx.orgScope === "personal"
+                            ? { orgScope: "personal" }
+                            : {}),
+                        requestOrigin: getForwardedRequestOrigin(event),
                         isLoopbackRequest: isLoopbackRequest(event),
+                        isDirectLoopbackRequest: isDirectLoopbackRequest(event),
                     }, () => listChatGPTSubscriptionModels(ctx.userEmail));
                     if (!catalog.models.includes(model)) {
                         setResponseStatus(event, 400);
@@ -4339,7 +4375,11 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         error: `Model "${model}" is not supported by Builder. Choose one of: ${entry.supportedModels.join(", ")}`,
                     };
                 }
-                await writeAgentAppModelDefaultSettings({ userEmail: ctx.userEmail, orgId: ctx.orgId }, targetAppId, { engine, model, updatedBy: ctx.userEmail });
+                await writeAgentAppModelDefaultSettings({
+                    userEmail: ctx.userEmail,
+                    orgId: ctx.orgId,
+                    orgScope: ctx.orgScope,
+                }, targetAppId, { engine, model, updatedBy: ctx.userEmail });
                 return buildModelDefaultsPayload(event, targetAppId);
             }));
             // Mount save-key BEFORE the prefix handler so it isn't shadowed.
@@ -4894,10 +4934,21 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     setResponseStatus(event, 400);
                     return { error: "message is required" };
                 }
-                const orgId = await getOrgIdFromEvent(event);
-                await runWithRequestContext({ userEmail: ownerEmail, orgId }, () => requireAgentChatAiSetup());
+                const orgScope = await resolveAgentRunOrgScope({
+                    event,
+                    ownerContext: titleOwnerContext,
+                    resolveOrgId: options?.resolveOrgId,
+                });
+                const titleRequestContext = {
+                    userEmail: ownerEmail,
+                    ...orgScope,
+                    requestOrigin: getForwardedRequestOrigin(event),
+                    isLoopbackRequest: isLoopbackRequest(event),
+                    isDirectLoopbackRequest: isDirectLoopbackRequest(event),
+                };
+                await runWithRequestContext(titleRequestContext, () => requireAgentChatAiSetup());
                 try {
-                    const title = await runWithRequestContext({ userEmail: ownerEmail, orgId }, () => generateChatTitle({ ...request, appId: options?.appId }));
+                    const title = await runWithRequestContext(titleRequestContext, () => generateChatTitle({ ...request, appId: options?.appId }));
                     return { title };
                 }
                 catch (error) {
@@ -5410,11 +5461,12 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             const threadRouteHandler = withTransientDatabaseFallback(`${routePath}/threads`, async (event) => {
                 const ownerContext = await resolveOwnerContext(event);
                 const owner = ownerContext.owner;
-                const orgId = await resolveAgentRunOrgId({
+                const orgScope = await resolveAgentRunOrgScope({
                     event,
                     ownerContext,
                     resolveOrgId: options?.resolveOrgId,
                 });
+                const orgId = orgScope.orgId;
                 const method = getMethod(event);
                 const { threadId, tail: threadTail } = parseThreadRoute(event);
                 const isThreadSubroute = (subroute) => threadTail[0] === subroute;
@@ -5672,7 +5724,13 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                             (mutation.type === "append" ||
                                 mutation.type === "moveToTop" ||
                                 mutation.type === "claim")) {
-                            await runWithRequestContext({ userEmail: owner, orgId }, () => requireAgentChatAiSetup());
+                            await runWithRequestContext({
+                                userEmail: owner,
+                                ...orgScope,
+                                requestOrigin: getForwardedRequestOrigin(event),
+                                isLoopbackRequest: isLoopbackRequest(event),
+                                isDirectLoopbackRequest: isDirectLoopbackRequest(event),
+                            }, () => requireAgentChatAiSetup());
                         }
                         let result;
                         try {
@@ -6042,10 +6100,24 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     return { error: "Authentication required" };
                 }
                 try {
+                    const orgScope = await resolveAgentRunOrgScope({
+                        event,
+                        ownerContext: { owner: session.email, anonymous: false },
+                        resolveOrgId: options?.resolveOrgId,
+                    });
+                    if (!orgScope.orgId && orgScope.orgScope !== "personal") {
+                        setResponseStatus(event, 503);
+                        return {
+                            error: "Organization scope is temporarily unavailable.",
+                        };
+                    }
+                    const scope = orgScope.orgId
+                        ? { orgId: orgScope.orgId }
+                        : { orgId: null, orgScope: "personal" };
                     return {
                         token: await createAgentChatStreamToken({
                             ownerEmail: session.email,
-                            orgId: session.orgId ?? null,
+                            ...scope,
                             authUserId: session.authUserId,
                         }),
                         ttlSeconds: AGENT_CHAT_STREAM_TOKEN_TTL_SECONDS,
@@ -6078,6 +6150,9 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         owner: principal.ownerEmail,
                         anonymous: false,
                         orgId: principal.orgId,
+                        ...(principal.orgScope === "personal"
+                            ? { orgScope: "personal" }
+                            : {}),
                         ...(principal.authUserId
                             ? { authUserId: principal.authUserId }
                             : {}),

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

@@ -1,16 +1,28 @@
 export declare const AGENT_CHAT_STREAM_PATH = "/_agent-native/agent-chat-stream";
 export declare const AGENT_CHAT_STREAM_TOKEN_SUFFIX = "/stream-token";
 export declare const AGENT_CHAT_STREAM_TOKEN_TTL_SECONDS: number;
-export interface AgentChatStreamPrincipal {
+export type AgentChatStreamPrincipal = {
     ownerEmail: string;
-    orgId: string | null;
     authUserId?: string;
-}
+} & ({
+    orgId: string;
+    orgScope?: never;
+} | {
+    orgId: null;
+    orgScope: "personal";
+});
+type AgentChatStreamTokenScope = {
+    orgId: string;
+    orgScope?: never;
+} | {
+    orgId: null;
+    orgScope: "personal";
+};
 export declare function isAgentChatStreamingRuntime(): boolean;
 export declare function readAgentChatStreamBearerToken(authorization: string | undefined): string | null;
 export declare function createAgentChatStreamToken(input: {
     ownerEmail: string;
-    orgId?: string | null;
     authUserId?: string;
-}): Promise<string>;
+} & AgentChatStreamTokenScope): Promise<string>;
 export declare function verifyAgentChatStreamToken(token: string): Promise<AgentChatStreamPrincipal | null>;
+export {};

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

@@ -41,6 +41,13 @@ export function readAgentChatStreamBearerToken(authorization) {
 }
 export async function createAgentChatStreamToken(input) {
     const ownerEmail = validateOwnerEmail(input.ownerEmail);
+    if (input.orgScope === "personal" && input.orgId !== null) {
+        throw new Error("Personal agent-chat stream scope cannot include an org.");
+    }
+    if (input.orgScope !== "personal" &&
+        (typeof input.orgId !== "string" || !input.orgId.trim())) {
+        throw new Error("Agent-chat stream tokens require a resolved organization or personal scope.");
+    }
     const authUserId = input.authUserId?.trim();
     if (input.authUserId !== undefined &&
         (!authUserId ||
@@ -53,6 +60,7 @@ export async function createAgentChatStreamToken(input) {
         token_type: AGENT_CHAT_STREAM_TOKEN_TYPE,
         sub: ownerEmail,
         org_id: input.orgId ?? null,
+        ...(input.orgScope === "personal" ? { org_scope: "personal" } : {}),
         ...(authUserId ? { auth_user_id: authUserId } : {}),
     })
         .setProtectedHeader({ alg: "HS256", typ: "JWT" })
@@ -80,6 +88,12 @@ export async function verifyAgentChatStreamToken(token) {
         const orgId = payload.org_id;
         if (orgId !== null && typeof orgId !== "string")
             return null;
+        const orgScope = payload.org_scope;
+        if ((orgScope !== undefined && orgScope !== "personal") ||
+            (orgScope === "personal" && orgId !== null) ||
+            (orgId === null && orgScope !== "personal")) {
+            return null;
+        }
         const authUserId = payload.auth_user_id;
         if (authUserId !== undefined &&
             (typeof authUserId !== "string" ||
@@ -91,6 +105,7 @@ export async function verifyAgentChatStreamToken(token) {
         return {
             ownerEmail: validateOwnerEmail(payload.sub),
             orgId,
+            ...(orgScope === "personal" ? { orgScope: "personal" } : {}),
             ...(authUserId ? { authUserId } : {}),
         };
         // coercion-ok: signature, issuer, audience, and expiry failures mean invalid authorization.

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<{
-    error: string;
     ok?: undefined;
+    error: string;
     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-default-model-route.js

@@ -1,6 +1,6 @@
 import { defineEventHandler, getMethod, setResponseStatus, } from "h3";
 import { clearDefaultAgentEngineSelection, recordDefaultAgentEngineRefusal, resolveDefaultAgentEngineAuthority, } from "../agent/default-agent-engine.js";
-import { getOrgContext } from "../org/context.js";
+import { resolveAgentRunOrgScope } from "./agent-run-context.js";
 import { getSession } from "./auth.js";
 import { runWithRequestContext } from "./request-context.js";
 export const AGENT_ENGINE_DISCONNECT_ACTION_NAME = "agent-engine-disconnect";
@@ -26,8 +26,24 @@ export function createAgentEngineDisconnectHandler() {
             // Not caught separately: an unreadable org context must not downgrade an
             // org member's clear to a personal one that answers "ok" and changes
             // nothing.
-            const orgCtx = await getOrgContext(event);
-            const ctx = { userEmail: session.email, orgId: orgCtx.orgId };
+            const orgScope = await resolveAgentRunOrgScope({
+                event,
+                ownerContext: { owner: session.email, anonymous: false },
+            });
+            if (!orgScope.orgId && orgScope.orgScope !== "personal") {
+                setResponseStatus(event, 503);
+                return {
+                    ok: false,
+                    error: "Organization scope is temporarily unavailable.",
+                };
+            }
+            const ctx = {
+                userEmail: session.email,
+                orgId: orgScope.orgId,
+                ...(orgScope.orgScope === "personal"
+                    ? { orgScope: "personal" }
+                    : {}),
+            };
             const meta = {
                 actionName: AGENT_ENGINE_DISCONNECT_ACTION_NAME,
                 caller: "http",
@@ -88,19 +104,36 @@ export async function selectDefaultModelForSavedKey(event, input) {
         if (!userEmail)
             return { status: "skipped", reason: "not-allowed" };
         let orgId;
+        let orgScope;
         if (input.keyScope === "org") {
             orgId = input.keyScopeId;
         }
         else {
-            orgId = (await getOrgContext(event)).orgId;
+            const resolved = await resolveAgentRunOrgScope({
+                event,
+                ownerContext: { owner: userEmail, anonymous: false },
+            });
+            orgId = resolved.orgId;
+            orgScope = resolved.orgScope;
+            if (!orgId && orgScope !== "personal") {
+                return { status: "skipped", reason: "not-allowed" };
+            }
             if (orgId)
                 return { status: "skipped", reason: "personal-key" };
         }
-        const ctx = { userEmail, orgId };
+        const ctx = {
+            userEmail,
+            orgId: orgId ?? null,
+            ...(orgScope ? { orgScope } : {}),
+        };
         // Loaded here so the key-save route doesn't pull the engine registry into
         // its module graph for saves that don't touch the default.
         const { selectDefaultAgentEngine } = await import("../scripts/agent-engines/set-agent-engine.js");
-        const result = await runWithRequestContext({ userEmail, ...(orgId ? { orgId } : {}) }, () => selectDefaultAgentEngine(input.request, { actionName: AGENT_ENGINE_API_KEY_ACTION_NAME, caller: "http" }, ctx));
+        const result = await runWithRequestContext({
+            userEmail,
+            ...(orgId ? { orgId } : {}),
+            ...(orgScope ? { orgScope } : {}),
+        }, () => selectDefaultAgentEngine(input.request, { actionName: AGENT_ENGINE_API_KEY_ACTION_NAME, caller: "http" }, ctx));
         if (result.status === "selected") {
             return { status: "selected", engine: result.engine, model: result.model };
         }

package/dist/server/agent-engine-status-cache.d.ts

@@ -1,10 +1,14 @@
 export declare function memoizeAgentEngineStatus<T>(identity: {
     userEmail?: string | null;
     orgId?: string | null;
+    orgScope?: "personal" | null;
+    isDirectLoopbackRequest?: boolean;
 }, load: () => Promise<T>): Promise<T>;
 export declare function getMemoizedAgentEngineStatus<T>(identity: {
     userEmail?: string | null;
     orgId?: string | null;
+    orgScope?: "personal" | null;
+    isDirectLoopbackRequest?: boolean;
 }): Promise<T> | undefined;
 export declare function invalidateAgentEngineStatusCache(): void;
 /** @internal Test assertion for bounded status-cache retention. */

package/dist/server/agent-engine-status-cache.js

@@ -20,6 +20,8 @@ function statusCacheKey(identity) {
     return JSON.stringify([
         identity.userEmail?.trim().toLowerCase() ?? null,
         identity.orgId?.trim() || null,
+        identity.orgScope === "personal",
+        identity.isDirectLoopbackRequest === true,
     ]);
 }
 export function memoizeAgentEngineStatus(identity, load) {

package/dist/server/agent-run-context.d.ts

@@ -22,11 +22,20 @@ export declare function seedBackgroundAgentRunOwnerContext(event: H3Event, runId
 export declare function resolveAgentRunOwnerContext(event: H3Event, options?: {
     anonymousOwner?: AnonymousOwnerResolver;
 }): Promise<AgentRunOwnerContext>;
+export type AgentRunOrgScope = {
+    orgId?: string;
+    orgScope?: "personal";
+};
 export declare function resolveAgentRunOrgId(options: {
     event: H3Event;
     ownerContext: AgentRunOwnerContext;
     resolveOrgId?: OrgIdResolver;
 }): Promise<string | undefined>;
+export declare function resolveAgentRunOrgScope(options: {
+    event: H3Event;
+    ownerContext: AgentRunOwnerContext;
+    resolveOrgId?: OrgIdResolver;
+}): Promise<AgentRunOrgScope>;
 export declare function resolveAgentRunRequestContext(options: {
     event: H3Event;
     ownerContext: AgentRunOwnerContext;

package/dist/server/agent-run-context.js

@@ -1,10 +1,16 @@
 import { createError, getHeader } from "h3";
-import { AGENT_CHAT_BROWSER_SESSION_ID_FIELD } from "../agent/durable-background.js";
+import { AGENT_CHAT_BROWSER_SESSION_ID_FIELD, AGENT_CHAT_REQUEST_CONTEXT_FIELD, } from "../agent/durable-background.js";
 import { ANALYTICS_CLIENT_PLATFORM_BODY_FIELD, ANALYTICS_CLIENT_PLATFORM_HEADER, normalizeAnalyticsClientPlatform, } from "../shared/analytics-platform.js";
 import { SYNTHETIC_TRAFFIC_HEADER, isSyntheticTrafficValue, } from "../shared/test-traffic.js";
 import { CREDENTIAL_MEMBERSHIP_UNAVAILABLE_MESSAGE, isCredentialMembershipUnavailable, } from "./credential-membership-unavailable.js";
-import { getRequestContext, getRequestIdentityAuthenticatedAtMs, getRequestIdentitySessionToken, runWithRequestContext, } from "./request-context.js";
-const resolveOrgIdForEmail = (...args) => import("../org/context.js").then(({ resolveOrgIdForEmail }) => resolveOrgIdForEmail(...args));
+import { isDirectLoopbackRequest, isLoopbackRequest } from "./loopback.js";
+import { getRequestContext, getRequestIdentityAuthenticatedAtMs, getRequestIdentitySessionToken, hasExplicitPersonalOrgScope, runWithRequestContext, } from "./request-context.js";
+import { getForwardedRequestOrigin } from "./request-origin.js";
+const resolveOrgScopeForEmail = (...args) => import("../org/context.js").then(({ resolveOrgScopeForEmail }) => resolveOrgScopeForEmail(...args));
+async function hasOrgScopeResolutionUnavailable(event) {
+    const { hasOrgScopeResolutionUnavailable } = await import("../org/context.js");
+    return hasOrgScopeResolutionUnavailable(event);
+}
 const getOrgContext = (...args) => import("../org/context.js").then(({ getOrgContext }) => getOrgContext(...args));
 export const AGENT_RUN_OWNER_CONTEXT_KEY = "__agentNativeOwnerContext";
 function eventContext(event) {
@@ -153,10 +159,23 @@ export async function resolveAgentRunOwnerContext(event, options = {}) {
     });
 }
 export async function resolveAgentRunOrgId(options) {
-    if (Object.prototype.hasOwnProperty.call(options.ownerContext, "orgId")) {
-        return normalizeId(options.ownerContext.orgId);
+    return (await resolveAgentRunOrgScope(options)).orgId;
+}
+export async function resolveAgentRunOrgScope(options) {
+    const { ownerContext } = options;
+    const hasOwnerOrgId = Object.prototype.hasOwnProperty.call(ownerContext, "orgId");
+    if (hasOwnerOrgId) {
+        const orgId = normalizeId(ownerContext.orgId);
+        if (orgId)
+            return { orgId };
+        return ownerContext.orgScope === "personal" ? { orgScope: "personal" } : {};
+    }
+    if (ownerContext.orgScope === "personal" ||
+        hasExplicitPersonalOrgScope(options.event)) {
+        return { orgScope: "personal" };
     }
     let resolvedOrgId;
+    let orgLookupFailed = false;
     if (options.resolveOrgId) {
         resolvedOrgId = normalizeId(await options.resolveOrgId(options.event));
     }
@@ -167,32 +186,57 @@ export async function resolveAgentRunOrgId(options) {
             resolvedOrgId = normalizeId(session?.orgId);
         }
         catch {
-            // Session not available.
+            orgLookupFailed = true;
         }
         if (!resolvedOrgId) {
             try {
                 const orgContext = await getOrgContext(options.event);
                 resolvedOrgId = normalizeId(orgContext.orgId);
+                const scopeUnavailable = await hasOrgScopeResolutionUnavailable(options.event);
+                if (!resolvedOrgId && scopeUnavailable)
+                    orgLookupFailed = true;
+                if (!resolvedOrgId &&
+                    !scopeUnavailable &&
+                    !orgLookupFailed &&
+                    ownerContext.owner &&
+                    !ownerContext.anonymous &&
+                    normalizeId(orgContext.email)?.toLowerCase() ===
+                        ownerContext.owner.trim().toLowerCase()) {
+                    return { orgScope: "personal" };
+                }
             }
             catch {
-                // Org tables may not exist yet on first boot.
+                orgLookupFailed = true;
             }
         }
     }
-    if (!resolvedOrgId &&
-        options.ownerContext.owner &&
-        !options.ownerContext.anonymous) {
+    if (!resolvedOrgId && ownerContext.owner && !ownerContext.anonymous) {
         try {
-            resolvedOrgId = normalizeId(await resolveOrgIdForEmail(options.ownerContext.owner));
+            const scope = await resolveOrgScopeForEmail(ownerContext.owner);
+            if (scope.status === "organization") {
+                resolvedOrgId = normalizeId(scope.orgId);
+            }
+            else if (scope.status === "unknown") {
+                orgLookupFailed = true;
+            }
+            else if (!orgLookupFailed) {
+                return { orgScope: "personal" };
+            }
         }
         catch {
-            // Org tables may not exist yet on first boot.
+            orgLookupFailed = true;
         }
     }
-    return resolvedOrgId;
+    if (resolvedOrgId)
+        return { orgId: resolvedOrgId };
+    // An absent org is personal only when every available membership lookup succeeded.
+    if (!orgLookupFailed && ownerContext.owner && !ownerContext.anonymous) {
+        return { orgScope: "personal" };
+    }
+    return {};
 }
 export async function resolveAgentRunRequestContext(options) {
-    const orgId = await resolveAgentRunOrgId(options);
+    const { orgId, orgScope } = await resolveAgentRunOrgScope(options);
     const timezone = readAgentRunTimezone(options.event);
     const browserSessionId = options.isBackgroundWorker
         ? readDurableBrowserSessionId(options.event)
@@ -202,6 +246,17 @@ export async function resolveAgentRunRequestContext(options) {
     const clientPlatform = readAnalyticsClientPlatformHeader(options.event);
     const isSyntheticTraffic = readSyntheticTrafficHeader(options.event);
     const waitUntil = requestWaitUntil(options.event);
+    const durableBody = options.isBackgroundWorker
+        ? eventContext(options.event)["__agentChatBackgroundBody"]
+        : undefined;
+    const durableRequestContext = durableBody?.[AGENT_CHAT_REQUEST_CONTEXT_FIELD];
+    const durableOrigin = durableRequestContext &&
+        typeof durableRequestContext === "object" &&
+        !Array.isArray(durableRequestContext) &&
+        typeof durableRequestContext.requestOrigin ===
+            "string"
+        ? durableRequestContext.requestOrigin
+        : undefined;
     const run = {
         ...(options.isBackgroundWorker ? { isBackgroundWorker: true } : {}),
         ...(waitUntil ? { waitUntil } : {}),
@@ -211,10 +266,11 @@ export async function resolveAgentRunRequestContext(options) {
         ...(options.ownerContext.authUserId
             ? { authUserId: options.ownerContext.authUserId }
             : {}),
-        ...(options.ownerContext.orgScope === "personal"
-            ? { orgScope: "personal" }
-            : {}),
+        ...(orgScope === "personal" ? { orgScope: "personal" } : {}),
         ...(options.ownerContext.anonymous ? { agentRunAnonymous: true } : {}),
+        ...(options.ownerContext.anonymous && !orgId
+            ? { defaultAgentEngineScope: "deployment" }
+            : {}),
         ...(options.ownerContext.identityAuthenticatedAtMs !== undefined
             ? {
                 identityAuthenticatedAtMs: options.ownerContext.identityAuthenticatedAtMs,
@@ -227,6 +283,15 @@ export async function resolveAgentRunRequestContext(options) {
         ...(browserSessionId ? { browserSessionId } : {}),
         ...(clientPlatform ? { clientPlatform } : {}),
         ...(isSyntheticTraffic ? { isSyntheticTraffic: true } : {}),
+        requestOrigin: options.isBackgroundWorker
+            ? durableOrigin
+            : getForwardedRequestOrigin(options.event),
+        isLoopbackRequest: options.isBackgroundWorker
+            ? false
+            : isLoopbackRequest(options.event),
+        isDirectLoopbackRequest: options.isBackgroundWorker
+            ? false
+            : isDirectLoopbackRequest(options.event),
         ...(browserTabId ? { run: { ...run, browserTabId } } : {}),
         ...(!browserTabId && Object.keys(run).length > 0 ? { run } : {}),
     };

package/dist/server/auth.js

@@ -271,10 +271,15 @@ async function enrichLegacySessionIdentity(session, canonicalUser) {
             // coercion-ok: preserve the valid legacy session when optional profile enrichment is unreadable.
             .catch(() => null);
     }
-    if (!existing)
+    if (!existing ||
+        existing.user.email.trim().toLowerCase() !==
+            session.email.trim().toLowerCase()) {
         return session;
+    }
     return {
         ...session,
+        authUserId: session.authUserId ?? existing.user.id,
+        userId: session.userId ?? existing.user.id,
         ...(!session.name?.trim() && existing.user.name?.trim()
             ? { name: existing.user.name.trim() }
             : {}),