@agent-native/core 0.225.1 → 0.226.0-nightly-20261106182619

package/dist/client/chat/native-uploads.js

@@ -0,0 +1,97 @@
+import { isPersistableAttachmentReferenceUrl } from "@agent-native/agentkit/protocol";
+import { agentNativePath } from "../api-path.js";
+export function fileUploadUrlForChatApi(apiUrl) {
+    return apiUrl.endsWith("/agent-chat")
+        ? `${apiUrl.slice(0, -"/agent-chat".length)}/file-upload`
+        : agentNativePath("/_agent-native/file-upload");
+}
+export function createAgentNativeUploadRuntime(options = {}) {
+    const pending = new Map();
+    const fetcher = options.fetch ?? fetch;
+    const url = options.url ?? agentNativePath("/_agent-native/file-upload");
+    const failure = (code, status) => Object.assign(new Error(code), {
+        code,
+        retryable: code === "upload_network_error" ||
+            status === 408 ||
+            status === 429 ||
+            (status !== undefined && status >= 500),
+        ...(status === undefined ? {} : { status }),
+    });
+    const operations = {
+        async createUpload({ threadId, descriptor }) {
+            if (descriptor.size > 25 * 1024 * 1024)
+                throw failure("upload_too_large", 413);
+            if (pending.size >= 100)
+                throw failure("upload_unavailable", 429);
+            const uploadId = `agent-upload-${crypto.randomUUID()}`;
+            pending.set(uploadId, { threadId });
+            return { uploadId, method: "POST", url, fields: {} };
+        },
+        async completeUpload({ threadId, uploadId }) {
+            const entry = pending.get(uploadId);
+            if (!entry || entry.threadId !== threadId || !entry.file)
+                throw failure("upload_invalid_response");
+            pending.delete(uploadId);
+            return entry.file;
+        },
+        async cancelUpload({ threadId, uploadId }) {
+            if (pending.get(uploadId)?.threadId === threadId)
+                pending.delete(uploadId);
+        },
+    };
+    const upload = async (target, file, context) => {
+        const entry = pending.get(target.uploadId);
+        if (!entry || target.url !== url)
+            throw failure("upload_invalid_response");
+        if (file.size > 25 * 1024 * 1024)
+            throw failure("upload_too_large", 413);
+        const requestHeaders = new Headers(await options.headers?.(entry.threadId));
+        requestHeaders.delete("Content-Type");
+        const form = new FormData();
+        form.set("file", file.body, file.name);
+        let response;
+        try {
+            response = await fetcher(url, {
+                method: "POST",
+                headers: requestHeaders,
+                body: form,
+                ...(context?.signal ? { signal: context.signal } : {}),
+            });
+        }
+        catch (cause) {
+            if (context?.signal?.aborted)
+                throw cause;
+            throw Object.assign(failure("upload_network_error"), { cause });
+        }
+        if (!response.ok)
+            throw failure(response.status === 413
+                ? "upload_too_large"
+                : response.status === 401 || response.status === 403
+                    ? "upload_session_expired"
+                    : response.status === 415
+                        ? "upload_unsupported_type"
+                        : response.status === 408 ||
+                            response.status === 429 ||
+                            response.status >= 500
+                            ? "upload_unavailable"
+                            : `upload_http_${response.status}`, response.status);
+        const result = await response.json();
+        if (!result ||
+            typeof result !== "object" ||
+            !("url" in result) ||
+            !isPersistableAttachmentReferenceUrl(result.url))
+            throw failure("upload_invalid_response");
+        if (pending.get(target.uploadId) !== entry)
+            throw failure("upload_invalid_response");
+        entry.file = {
+            type: "file",
+            name: file.name,
+            mediaType: file.mediaType,
+            url: result.url,
+            ...("id" in result && typeof result.id === "string"
+                ? { fileId: result.id }
+                : {}),
+        };
+    };
+    return { operations, upload, dispose: () => pending.clear() };
+}

package/dist/client/experience-profiles.d.ts

@@ -0,0 +1,182 @@
+import type { ExperienceProfile, ExperienceProfileState } from "../experience-profiles/index.js";
+export declare function useExperienceProfile(): {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<ExperienceProfileState>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<NoInfer<ExperienceProfileState>>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'error';
+    setProfile: (profile: ExperienceProfile) => Promise<ExperienceProfileState>;
+    saving: boolean;
+    mutationError: Error | null;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<ExperienceProfileState>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<NoInfer<ExperienceProfileState>>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'pending';
+    setProfile: (profile: ExperienceProfile) => Promise<ExperienceProfileState>;
+    saving: boolean;
+    mutationError: Error | null;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<ExperienceProfileState>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<NoInfer<ExperienceProfileState>>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'pending';
+    setProfile: (profile: ExperienceProfile) => Promise<ExperienceProfileState>;
+    saving: boolean;
+    mutationError: Error | null;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<ExperienceProfileState>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<NoInfer<ExperienceProfileState>>;
+    data: NoInfer<ExperienceProfileState>;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: 'success';
+    setProfile: (profile: ExperienceProfile) => Promise<ExperienceProfileState>;
+    saving: boolean;
+    mutationError: Error | null;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<ExperienceProfileState>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<NoInfer<ExperienceProfileState>>;
+    data: NoInfer<ExperienceProfileState>;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'error';
+    setProfile: (profile: ExperienceProfile) => Promise<ExperienceProfileState>;
+    saving: boolean;
+    mutationError: Error | null;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<ExperienceProfileState>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<NoInfer<ExperienceProfileState>>;
+    data: NoInfer<ExperienceProfileState>;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: 'success';
+    setProfile: (profile: ExperienceProfile) => Promise<ExperienceProfileState>;
+    saving: boolean;
+    mutationError: Error | null;
+};

package/dist/client/experience-profiles.js

@@ -0,0 +1,19 @@
+import { useCallback, useState } from "react";
+import { useActionMutation, useActionQuery } from "./use-action.js";
+export function useExperienceProfile() {
+    const query = useActionQuery("get-experience-profile", undefined, { retry: false });
+    const mutation = useActionMutation("set-experience-profile");
+    const [saving, setSaving] = useState(false);
+    const setProfile = useCallback(async (profile) => {
+        setSaving(true);
+        try {
+            const result = await mutation.mutateAsync({ profile });
+            await query.refetch({ throwOnError: true });
+            return result;
+        }
+        finally {
+            setSaving(false);
+        }
+    }, [mutation.mutateAsync, query.refetch]);
+    return { ...query, setProfile, saving, mutationError: mutation.error };
+}

package/dist/client/uploads/index.d.ts

@@ -1,5 +1,5 @@
 export { uploadEditorImage, type EditorImageUploadFn, type EditorImageUploadResult, } from "./upload-editor-image.js";
 export { useUploadResource } from "./use-upload-resource.js";
-export { useFileUploadStatus } from "./use-file-upload-status.js";
+export { useFileUploadStatus, readFileUploadStatus, } from "./use-file-upload-status.js";
 export { fetchFileUploadStatus } from "../client-status-requests.js";
 export { uploadWorkspacePrivateIcon, workspacePrivateIconLibraryUrl, workspacePrivateIconUrl, } from "./private-icon.js";

package/dist/client/uploads/index.js

@@ -1,5 +1,5 @@
 export { uploadEditorImage, } from "./upload-editor-image.js";
 export { useUploadResource } from "./use-upload-resource.js";
-export { useFileUploadStatus } from "./use-file-upload-status.js";
+export { useFileUploadStatus, readFileUploadStatus, } from "./use-file-upload-status.js";
 export { fetchFileUploadStatus } from "../client-status-requests.js";
 export { uploadWorkspacePrivateIcon, workspacePrivateIconLibraryUrl, workspacePrivateIconUrl, } from "./private-icon.js";

package/dist/client/use-action.js

@@ -236,6 +236,9 @@ function ensureUiActionCapability(signal) {
             cache: "no-store",
             signal: controller?.signal,
         }).then((res) => {
+            // The capability is the Set-Cookie header; an unread body keeps the
+            // request open and the page never reaches network idle.
+            res.body?.cancel().catch(() => { });
             if (!res.ok) {
                 throw new Error("Could not establish the browser UI capability.");
             }

package/dist/collab/routes.d.ts

@@ -25,9 +25,9 @@ export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import
     ok: boolean;
 }>>;
 export declare const postCollabText: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    text?: undefined;
     ok?: undefined;
     error: string;
+    text?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/experience-profiles/index.d.ts

@@ -0,0 +1,13 @@
+import type { FeatureFlagDefinition } from "../feature-flags/registry.js";
+export type ExperienceProfile = "reference" | "agent-native";
+export interface ExperienceDeviation {
+    flag: FeatureFlagDefinition;
+    enabledInAgentNative: boolean;
+}
+export interface ExperienceProfileState {
+    profile: ExperienceProfile;
+    savedProfile: ExperienceProfile | null;
+    referenceAvailable: boolean;
+    values: Record<string, boolean>;
+}
+export declare function resolveExperienceFlags(deviations: readonly ExperienceDeviation[], profile: ExperienceProfile): Record<string, boolean>;

package/dist/experience-profiles/index.js

@@ -0,0 +1,10 @@
+export function resolveExperienceFlags(deviations, profile) {
+    const values = {};
+    for (const { flag, enabledInAgentNative } of deviations) {
+        if (Object.hasOwn(values, flag.key)) {
+            throw new Error(`Duplicate experience deviation: ${flag.key}`);
+        }
+        values[flag.key] = profile === "agent-native" && enabledInAgentNative;
+    }
+    return values;
+}

package/dist/experience-profiles/server.d.ts

@@ -0,0 +1,38 @@
+import { type ActionRunContext } from "../action.js";
+import { type ExperienceDeviation } from "./index.js";
+export interface ExperienceProfileOptions {
+    appId: string;
+    deviations: readonly ExperienceDeviation[];
+    canUseReference: (ctx: ActionRunContext) => boolean | Promise<boolean>;
+}
+export declare function createExperienceProfileActions(options: ExperienceProfileOptions): {
+    get: import("../action.js").ActionDefinition<Record<string, never>, {
+        profile: "agent-native" | "reference";
+        savedProfile: "agent-native" | "reference" | null;
+        referenceAvailable: boolean;
+        values: Record<string, boolean>;
+    }>;
+    set: import("../action.js").ActionDefinition<{
+        profile: "agent-native" | "reference";
+    }, {
+        profile: "agent-native" | "reference";
+        savedProfile: "agent-native" | "reference" | null;
+        referenceAvailable: boolean;
+        values: Record<string, boolean>;
+    }>;
+};
+export declare function canUseReferenceExperience(ctx: ActionRunContext): boolean;
+export declare function createGetExperienceProfileAction(options: ExperienceProfileOptions): import("../action.js").ActionDefinition<Record<string, never>, {
+    profile: "agent-native" | "reference";
+    savedProfile: "agent-native" | "reference" | null;
+    referenceAvailable: boolean;
+    values: Record<string, boolean>;
+}>;
+export declare function createSetExperienceProfileAction(options: ExperienceProfileOptions): import("../action.js").ActionDefinition<{
+    profile: "agent-native" | "reference";
+}, {
+    profile: "agent-native" | "reference";
+    savedProfile: "agent-native" | "reference" | null;
+    referenceAvailable: boolean;
+    values: Record<string, boolean>;
+}>;

package/dist/experience-profiles/server.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { defineAction, fail } from "../action.js";
+import { getAppConfig } from "../app-config/index.js";
+import { getUserSetting, putUserSetting } from "../settings/user-settings.js";
+import { resolveExperienceFlags } from "./index.js";
+const profileSchema = z.enum(["reference", "agent-native"]);
+const preferenceSchema = z.object({ profile: profileSchema });
+const stateSchema = z.object({
+    profile: profileSchema,
+    savedProfile: profileSchema.nullable(),
+    referenceAvailable: z.boolean(),
+    values: z.record(z.string(), z.boolean()),
+});
+export function createExperienceProfileActions(options) {
+    if (!/^[a-zA-Z][a-zA-Z0-9._-]{0,63}$/.test(options.appId)) {
+        throw new Error("Experience profiles require a stable app id.");
+    }
+    resolveExperienceFlags(options.deviations, "reference");
+    const key = `experience-profile:${options.appId}`;
+    async function read(ctx) {
+        if (!ctx?.userEmail)
+            fail("Sign in to select an experience.", { statusCode: 401 });
+        const email = ctx.userEmail;
+        const referenceAvailable = await options.canUseReference(ctx);
+        const stored = await getUserSetting(email, key, { bypassCache: true });
+        const preference = stored === null ? null : preferenceSchema.parse(stored);
+        const savedProfile = preference?.profile ?? null;
+        // A saved choice is not a permission grant. Revocation takes effect on every read.
+        const profile = savedProfile === "reference" && referenceAvailable
+            ? "reference"
+            : "agent-native";
+        return {
+            profile,
+            savedProfile,
+            referenceAvailable,
+            values: resolveExperienceFlags(options.deviations, profile),
+        };
+    }
+    return {
+        get: defineAction({
+            description: "Read the current user's experience profile and effective deviation flags. Reference access is checked on the server; no saved choice defaults to Agent-Native.",
+            schema: z.object({}),
+            outputSchema: stateSchema,
+            http: { method: "GET" },
+            run: async (_args, ctx) => read(ctx),
+        }),
+        set: defineAction({
+            description: "Save the current user's experience profile without changing navigation, selection, or app records. Reference requires current server authorization.",
+            schema: preferenceSchema,
+            outputSchema: stateSchema,
+            run: async ({ profile }, ctx) => {
+                if (!ctx?.userEmail)
+                    fail("Sign in to select an experience.", { statusCode: 401 });
+                if (profile === "reference" && !(await options.canUseReference(ctx))) {
+                    fail("Reference experience is restricted to authorized reviewers.", {
+                        statusCode: 403,
+                        errorCode: "reference_forbidden",
+                    });
+                }
+                await putUserSetting(ctx.userEmail, key, { profile });
+                return read(ctx);
+            },
+        }),
+    };
+}
+export function canUseReferenceExperience(ctx) {
+    const email = ctx.userEmail?.trim().toLowerCase();
+    return (email !== undefined &&
+        getAppConfig().experienceProfiles.referenceEmails.some((reviewer) => reviewer.trim().toLowerCase() === email));
+}
+export function createGetExperienceProfileAction(options) {
+    return createExperienceProfileActions(options).get;
+}
+export function createSetExperienceProfileAction(options) {
+    return createExperienceProfileActions(options).set;
+}

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

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

package/dist/framework-package-versions.json

@@ -1,17 +1,17 @@
 {
-  "@agent-native/agentkit": "0.225.1",
+  "@agent-native/agentkit": "0.226.0-nightly-20261106182619",
   "@agent-native/code-agents-ui": "0.1.75",
-  "@agent-native/core": "0.225.1",
-  "@agent-native/core-corpus": "0.225.1",
+  "@agent-native/core": "0.226.0-nightly-20261106182619",
+  "@agent-native/core-corpus": "0.226.0-nightly-20261106182619",
   "@agent-native/creative-context": "0.8.67",
-  "@agent-native/dispatch": "0.42.2",
+  "@agent-native/dispatch": "0.42.3-nightly-20261106182619",
   "@agent-native/embedding": "0.2.0",
   "@agent-native/migrate": "0.0.7",
   "@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/scheduling": "0.2.55-nightly-20261106182619",
   "@agent-native/shared-app-config": "0.1.2",
-  "@agent-native/skills": "0.4.2",
-  "@agent-native/toolkit": "0.225.1"
+  "@agent-native/skills": "0.4.3-nightly-20261106182619",
+  "@agent-native/toolkit": "0.226.0-nightly-20261106182619"
 }

package/dist/localization/workspace-integration-messages.d.ts

@@ -0,0 +1,11 @@
+export declare function workspaceIntegrationMessagesForUser(userEmail: string): Promise<{
+    limit: string;
+    invalid: string;
+    unavailable: string;
+    referenceUnknown: string;
+    referenceSignIn: string;
+    referenceUnavailable: string;
+    composerReferenceAuthentication: string;
+    composerReferenceInvalid: string;
+    composerReferenceUnavailable: string;
+}>;