@agent-native/core 0.198.3 → 0.198.5

package/dist/a2a/types.d.ts

@@ -49,6 +49,11 @@ export interface A2AConnectionRequestMetadata {
     reason: "connect" | "grant" | "reauthorize" | "admin_required";
     appId?: string;
     detail?: string;
+    source?: {
+        id: string;
+        kind: "workspace_connection";
+        label?: string;
+    };
 }
 export interface AgentSkill {
     id: string;

package/dist/agent/production-agent.js

@@ -1656,7 +1656,11 @@ export async function callConnectedAgentReference(input) {
                 ...(connectionRequest.appId
                     ? { appId: connectionRequest.appId }
                     : {}),
-                source: { id: input.agent, kind: "agent", label: input.agent },
+                source: connectionRequest.source ?? {
+                    id: input.agent,
+                    kind: "agent",
+                    label: input.agent,
+                },
             });
         }
         relay.finish("error");
@@ -1684,12 +1688,28 @@ function parseA2AConnectionRequest(error) {
     }
     const appId = typeof request.appId === "string" ? request.appId.trim() : "";
     const detail = typeof request.detail === "string" ? request.detail.trim() : "";
+    const sourceValue = request.source && typeof request.source === "object"
+        ? request.source
+        : null;
+    const sourceId = typeof sourceValue?.id === "string" ? sourceValue.id.trim() : "";
+    const sourceLabel = typeof sourceValue?.label === "string" ? sourceValue.label.trim() : "";
     return {
         version: 1,
         provider,
         reason,
         ...(appId && appId.length <= 120 ? { appId } : {}),
         ...(detail && detail.length <= 1_000 ? { detail } : {}),
+        ...(sourceValue?.kind === "workspace_connection" &&
+            sourceId === provider &&
+            sourceId.length <= 120
+            ? {
+                source: {
+                    id: sourceId,
+                    kind: "workspace_connection",
+                    ...(sourceLabel ? { label: sourceLabel.slice(0, 120) } : {}),
+                },
+            }
+            : {}),
     };
 }
 const MAX_CONNECTED_AGENT_PROGRESS_DETAIL_CHARS = 200;
@@ -2648,6 +2668,11 @@ export function permanentPreconditionReason(toolName, message) {
         .trim()
         // The headline appends its own sentence punctuation.
         .replace(/[.。]+$/, "");
+    const nestedPrecondition = reason
+        .match(/\bI stopped because [\w-]+ can't run yet:\s*(.+?)\. That needs to be fixed outside this chat\b/i)?.[1]
+        ?.trim();
+    if (nestedPrecondition)
+        return nestedPrecondition;
     if (!reason)
         return null;
     if (/\bI stopped because\b/i.test(reason) ||

package/dist/catalog.json

@@ -51,6 +51,7 @@
   "playwright": "1.63.0",
   "react": "^19.2.7",
   "react-dom": "^19.2.7",
+  "react-router": "8.1.0",
   "recharts": "^3.9.2",
   "sonner": "^2.0.7",
   "tailwind-merge": "^3.5.0",

package/dist/client/chat/agentkit-agent-native.js

@@ -1,12 +1,13 @@
+import { AgentKitRunSlotBusyError } from "@agent-native/agentkit/client";
 import { isAgentKitProtocolVersion, parseAgentThreadSnapshot, } from "@agent-native/agentkit/protocol";
 import { agentNativePath } from "../api-path.js";
 import { dispatchAgentChatRunning } from "../use-agent-chat-running-threads.js";
 import { appendChatThreadScopeParams, } from "../use-chat-threads.js";
 import { AGENT_NATIVE_PROTOCOL_METADATA_KEY, createAgentKitProtocolAdapter, } from "./agentkit-protocol.js";
 import { createAgentNativeChatRuntime, } from "./runtime.js";
-const RUN_SLOT_TIMEOUT_MS = 5_000;
 const RUN_SLOT_POLL_INTERVAL_MS = 150;
 const RUN_SLOT_STABLE_POLLS = 2;
+const RUN_SLOT_MAX_POLLS = RUN_SLOT_STABLE_POLLS * 2;
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -954,9 +955,8 @@ export function createAgentNativeAgentKitTransport(options = {}) {
         };
     }
     async function waitForRunSlot(threadId) {
-        const deadline = Date.now() + RUN_SLOT_TIMEOUT_MS;
         let consecutiveClearPolls = 0;
-        while (Date.now() < deadline) {
+        for (let poll = 0; poll < RUN_SLOT_MAX_POLLS; poll += 1) {
             const response = await fetcher(`${apiUrl}/runs/active?threadId=${encodeURIComponent(threadId)}`, { headers: await headers({ sessionId: threadId }) });
             if (!response.ok)
                 throw await responseError(response);
@@ -964,22 +964,22 @@ export function createAgentNativeAgentKitTransport(options = {}) {
             if (!status) {
                 throw new TypeError("Agent chat active-run response must be an object.");
             }
-            if (status.awaitingRedispatch === true) {
-                throw new Error("The agent runtime owns a continuation for this thread; the queued message remains pending.");
-            }
-            const clear = status.active !== true ||
-                status.status === "completed" ||
-                status.status === "complete" ||
-                status.status === "failed" ||
-                status.status === "cancelled" ||
-                status.status === "errored" ||
-                status.status === "aborted";
+            const clear = status.awaitingRedispatch !== true &&
+                (status.active !== true ||
+                    status.status === "completed" ||
+                    status.status === "complete" ||
+                    status.status === "failed" ||
+                    status.status === "cancelled" ||
+                    status.status === "errored" ||
+                    status.status === "aborted");
             consecutiveClearPolls = clear ? consecutiveClearPolls + 1 : 0;
             if (consecutiveClearPolls >= RUN_SLOT_STABLE_POLLS)
                 return;
-            await new Promise((resolve) => setTimeout(resolve, RUN_SLOT_POLL_INTERVAL_MS));
+            if (poll + 1 < RUN_SLOT_MAX_POLLS) {
+                await new Promise((resolve) => setTimeout(resolve, RUN_SLOT_POLL_INTERVAL_MS));
+            }
         }
-        throw new Error("The current agent run did not release the thread; the queued message remains pending.");
+        throw new AgentKitRunSlotBusyError();
     }
     async function readQueue(threadId) {
         const thread = await snapshot(threadId);

package/dist/client/chat/runtime.js

@@ -967,9 +967,11 @@ function mapAgentNativeEvent(raw, input) {
                 reason: ev.connectionReason ?? "connect",
                 appId: ev.appId,
                 detail: ev.detail,
-                source: ev.agent
-                    ? { id: ev.agent, kind: "agent", label: ev.agent }
-                    : undefined,
+                source: ev.source
+                    ? { ...ev.source, kind: ev.source.kind ?? "connection" }
+                    : ev.agent
+                        ? { id: ev.agent, kind: "agent", label: ev.agent }
+                        : undefined,
             },
         ];
     }

package/dist/client/feature-flags/types.d.ts

@@ -4,6 +4,8 @@ export interface FeatureFlagActor {
 }
 export interface FeatureFlagMetadata {
     key: string;
+    canManage?: boolean;
+    movedToLab?: string;
     displayName?: string | null;
     description?: string | null;
     defaultValue: boolean;

package/dist/client/i18n.d.ts

@@ -67,7 +67,9 @@ export declare function useIconPickerLabels(): {
     allCategories: string;
     loadError: string;
     saveError: string;
+    uploadFailed: string;
     uploadTooLarge: string;
+    uploadUnsupportedType: string;
     retry: string;
     uploadHint: string;
     colorNames: {

package/dist/client/i18n.js

@@ -488,7 +488,9 @@ export function useIconPickerLabels() {
         allCategories: t("iconPicker.allCategories"),
         loadError: t("iconPicker.loadError"),
         saveError: t("iconPicker.saveError"),
+        uploadFailed: t("iconPicker.uploadFailed"),
         uploadTooLarge: t("iconPicker.uploadTooLarge"),
+        uploadUnsupportedType: t("iconPicker.uploadUnsupportedType"),
         retry: t("iconPicker.retry"),
         uploadHint: t("iconPicker.uploadHint"),
         colorNames: Object.fromEntries(Object.keys(defaultEnglishMessages.iconPicker.colorNames).map((color) => [

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

@@ -1,4 +1,5 @@
 export { startWorkspaceProviderOAuth, workspaceProviderOAuthUrl, type WorkspaceProviderOAuthOptions, type WorkspaceProviderOAuthScope, } from "./workspace-provider-oauth.js";
+export { getWorkspaceConnectionProvider } from "../../connections/catalog.js";
 export { channelConnectionState, hasMissingRequiredCredentials, listChannelsForSettings, type ChannelConnectionState, type ChannelCredential, } from "./channel-setup.js";
 export { useIntegrationStatus } from "./useIntegrationStatus.js";
 export type { IntegrationStatus } from "./useIntegrationStatus.js";

package/dist/client/integrations/index.js

@@ -1,4 +1,5 @@
 export { startWorkspaceProviderOAuth, workspaceProviderOAuthUrl, } from "./workspace-provider-oauth.js";
+export { getWorkspaceConnectionProvider } from "../../connections/catalog.js";
 export { channelConnectionState, hasMissingRequiredCredentials, listChannelsForSettings, } from "./channel-setup.js";
 export { useIntegrationStatus } from "./useIntegrationStatus.js";
 export { listIntegrationEnvStatuses, listIntegrationStatuses, saveIntegrationEnvVars, setIntegrationEnabled, setupIntegration, disconnectManagedIntegrationInstallation, listManagedIntegrationInstallations, managedIntegrationOAuthUrl, managedSlackAgentManifestUrl, listManagedIntegrationScopes, saveManagedIntegrationScope, listManagedIntegrationBudgets, listManagedIntegrationMemory, forgetManagedIntegrationMemory, saveManagedIntegrationBudget, testManagedIntegrationInstallation, IntegrationClientError, } from "./api.js";

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

@@ -1 +1 @@
-export { useLab, useLabState, useLabs, type LabReference, type LabValues, } from "./use-lab.js";
+export { useLab, useLabState, useLabs, type LabReference, type LabValues, type LabStates, } from "./use-lab.js";

package/dist/client/labs/use-lab.d.ts

@@ -1,5 +1,7 @@
 import type { LabDefinition } from "../../labs/registry.js";
+import type { UserLabState } from "../../labs/store.js";
 export type LabValues = Record<string, boolean>;
+export type LabStates = Record<string, UserLabState>;
 /**
  * A lab by key, or by its definition. Pass the definition so the lab reads as
  * its `defaultEnabled` until the server answers (and when it can't); a bare
@@ -8,6 +10,9 @@ export type LabValues = Record<string, boolean>;
 export type LabReference = string | Pick<LabDefinition, "key" | "defaultEnabled">;
 export declare function useLabState(lab: LabReference): {
     enabled: boolean;
+    source: UserLabState["source"] | null;
+    mixed: boolean;
+    legacyValues?: Record<string, boolean>;
     isLoading: boolean;
     isError: boolean;
     isSuccess: boolean;

package/dist/client/labs/use-lab.js

@@ -6,13 +6,17 @@ function labKey(lab) {
 export function useLabState(lab) {
     const key = labKey(lab);
     const { status } = useSession();
-    const query = useActionQuery("get-labs", undefined, {
+    const query = useActionQuery("get-lab-states", undefined, {
         enabled: status === "authenticated",
     });
+    const state = query.data?.[key];
     return {
-        enabled: query.data
-            ? query.data[key] === true
+        enabled: state
+            ? state.enabled
             : typeof lab !== "string" && lab.defaultEnabled === true,
+        source: state?.source ?? null,
+        mixed: state?.mixed ?? false,
+        legacyValues: state?.legacyValues,
         isLoading: query.isLoading || (status === "loading" && query.data === undefined),
         isError: query.isError,
         isSuccess: query.isSuccess,

package/dist/client/resources/mcp-connection-resume.d.ts

@@ -2,14 +2,16 @@ export interface McpConnectionResumeRequest {
     message: string;
     returnUrl: string;
     createdAt: number;
+    completionId?: string;
     agentKit?: {
         threadId: string;
         runId: string;
         requestId: string;
     };
 }
-export declare function saveMcpConnectionResume(message: string, agentKit?: McpConnectionResumeRequest["agentKit"]): boolean;
-export declare function clearMcpConnectionResume(): void;
+export declare function saveMcpConnectionResume(message: string, agentKit?: McpConnectionResumeRequest["agentKit"], completionId?: string): boolean;
+export declare function getPendingMcpConnectionResume(returnUrl?: string): McpConnectionResumeRequest | null;
+export declare function clearMcpConnectionResume(expected?: McpConnectionResumeRequest | string): void;
 export declare function consumeMcpConnectionResume(returnUrl?: string): McpConnectionResumeRequest | null;
-export declare function notifyMcpConnectionComplete(): void;
+export declare function notifyMcpConnectionComplete(completionId?: string): void;
 export declare function addMcpConnectionCompleteListener(listener: () => void): () => void;

package/dist/client/resources/mcp-connection-resume.js

@@ -1,7 +1,9 @@
 const MCP_CONNECTION_RESUME_STORAGE_KEY = "agent-native:mcp-connection-resume";
 const MCP_CONNECTION_RESUME_EVENT = "agent-native:mcp-connection-complete";
+const MCP_CONNECTION_RESUME_COMPLETION_STORAGE_PREFIX = "agent-native:mcp-connection-completion:";
 const MCP_CONNECTION_RESUME_TTL_MS = 10 * 60 * 1_000;
 const MCP_CONNECTION_RESUME_MAX_MESSAGE_LENGTH = 24_000;
+const completedResumeIds = new Set();
 function currentReturnUrl() {
     if (typeof window === "undefined")
         return "/";
@@ -17,7 +19,27 @@ function getSessionStorage() {
         return null;
     }
 }
-export function saveMcpConnectionResume(message, agentKit) {
+function getLocalStorage() {
+    if (typeof window === "undefined")
+        return null;
+    try {
+        return window.localStorage;
+    }
+    catch {
+        // coercion-ok: callers fail closed when local storage is unavailable.
+        return null;
+    }
+}
+function clearCompletionMarker(completionId) {
+    completedResumeIds.delete(completionId);
+    try {
+        getLocalStorage()?.removeItem(MCP_CONNECTION_RESUME_COMPLETION_STORAGE_PREFIX + completionId);
+    }
+    catch {
+        // coercion-ok: stale markers cannot complete the newer opaque attempt.
+    }
+}
+export function saveMcpConnectionResume(message, agentKit, completionId) {
     const trimmedMessage = message.trim();
     if (!trimmedMessage ||
         trimmedMessage.length > MCP_CONNECTION_RESUME_MAX_MESSAGE_LENGTH) {
@@ -30,28 +52,57 @@ export function saveMcpConnectionResume(message, agentKit) {
         message: trimmedMessage,
         returnUrl: currentReturnUrl(),
         createdAt: Date.now(),
+        ...(completionId ? { completionId } : {}),
         ...(agentKit ? { agentKit } : {}),
     };
+    const previousCompletionId = readStoredMcpConnectionResume()?.completionId;
     try {
         storage.setItem(MCP_CONNECTION_RESUME_STORAGE_KEY, JSON.stringify(request));
-        return true;
     }
     catch {
         return false;
     }
+    if (previousCompletionId)
+        clearCompletionMarker(previousCompletionId);
+    return true;
 }
-export function clearMcpConnectionResume() {
+function removeStoredMcpConnectionResume(completionId) {
     const storage = getSessionStorage();
     if (!storage)
         return;
+    let storedCompletionId;
+    let raw;
+    try {
+        raw = storage.getItem(MCP_CONNECTION_RESUME_STORAGE_KEY);
+    }
+    catch {
+        return;
+    }
+    if (raw) {
+        try {
+            const request = JSON.parse(raw);
+            if (typeof request.completionId === "string") {
+                storedCompletionId = request.completionId;
+            }
+        }
+        catch {
+            // coercion-ok: malformed records are removed below and cannot be resumed.
+        }
+    }
+    if (completionId && storedCompletionId !== completionId)
+        return;
     try {
         storage.removeItem(MCP_CONNECTION_RESUME_STORAGE_KEY);
     }
     catch {
-        // Ignore storage-denied browsers; the pending request is best effort.
+        // Keep its completion marker so a readable request can still be retried.
+        return;
     }
+    const completedId = completionId ?? storedCompletionId;
+    if (completedId)
+        clearCompletionMarker(completedId);
 }
-export function consumeMcpConnectionResume(returnUrl = currentReturnUrl()) {
+function readStoredMcpConnectionResume() {
     const storage = getSessionStorage();
     if (!storage)
         return null;
@@ -63,14 +114,16 @@ export function consumeMcpConnectionResume(returnUrl = currentReturnUrl()) {
         request = JSON.parse(raw);
     }
     catch {
-        clearMcpConnectionResume();
+        removeStoredMcpConnectionResume();
         return null;
     }
     if (!request ||
         typeof request.message !== "string" ||
         typeof request.returnUrl !== "string" ||
-        typeof request.createdAt !== "number") {
-        clearMcpConnectionResume();
+        typeof request.createdAt !== "number" ||
+        (request.completionId !== undefined &&
+            (typeof request.completionId !== "string" || !request.completionId))) {
+        removeStoredMcpConnectionResume();
         return null;
     }
     if (request.agentKit !== undefined &&
@@ -81,26 +134,110 @@ export function consumeMcpConnectionResume(returnUrl = currentReturnUrl()) {
             !request.agentKit.runId.trim() ||
             typeof request.agentKit.requestId !== "string" ||
             !request.agentKit.requestId.trim())) {
-        clearMcpConnectionResume();
+        removeStoredMcpConnectionResume();
         return null;
     }
     if (Date.now() - request.createdAt > MCP_CONNECTION_RESUME_TTL_MS) {
-        clearMcpConnectionResume();
+        removeStoredMcpConnectionResume();
         return null;
     }
+    return request;
+}
+function isCompletionRecorded(completionId) {
+    if (completedResumeIds.has(completionId))
+        return true;
+    const storage = getLocalStorage();
+    if (!storage)
+        return false;
+    try {
+        return (storage.getItem(MCP_CONNECTION_RESUME_COMPLETION_STORAGE_PREFIX + completionId) === "1");
+    }
+    catch {
+        // coercion-ok: unreadable completion state fails closed and keeps the request pending.
+        return false;
+    }
+}
+export function getPendingMcpConnectionResume(returnUrl = currentReturnUrl()) {
+    const request = readStoredMcpConnectionResume();
+    if (!request)
+        return null;
     if (request.returnUrl !== returnUrl)
         return null;
-    clearMcpConnectionResume();
+    if (request.completionId && !isCompletionRecorded(request.completionId)) {
+        return null;
+    }
     return request;
 }
-export function notifyMcpConnectionComplete() {
+export function clearMcpConnectionResume(expected) {
+    const current = readStoredMcpConnectionResume();
+    if (typeof expected === "string" && current?.completionId !== expected) {
+        return;
+    }
+    if (expected &&
+        typeof expected !== "string" &&
+        (!current ||
+            current.createdAt !== expected.createdAt ||
+            current.returnUrl !== expected.returnUrl ||
+            current.message !== expected.message ||
+            current.completionId !== expected.completionId ||
+            current.agentKit?.threadId !== expected.agentKit?.threadId ||
+            current.agentKit?.runId !== expected.agentKit?.runId ||
+            current.agentKit?.requestId !== expected.agentKit?.requestId)) {
+        return;
+    }
+    removeStoredMcpConnectionResume(typeof expected === "string" ? expected : current?.completionId);
+}
+export function consumeMcpConnectionResume(returnUrl = currentReturnUrl()) {
+    const request = getPendingMcpConnectionResume(returnUrl);
+    if (request)
+        clearMcpConnectionResume(request);
+    return request;
+}
+export function notifyMcpConnectionComplete(completionId) {
     if (typeof window === "undefined")
         return;
+    if (completionId) {
+        const request = readStoredMcpConnectionResume();
+        if (request?.completionId !== completionId)
+            return;
+        completedResumeIds.add(completionId);
+        try {
+            getLocalStorage()?.setItem(MCP_CONNECTION_RESUME_COMPLETION_STORAGE_PREFIX + completionId, "1");
+        }
+        catch {
+            // coercion-ok: the active page can use this signal; reloads fail closed.
+        }
+    }
     window.dispatchEvent(new Event(MCP_CONNECTION_RESUME_EVENT));
 }
 export function addMcpConnectionCompleteListener(listener) {
     if (typeof window === "undefined")
         return () => { };
+    const onStorage = (event) => {
+        if (event.key?.startsWith(MCP_CONNECTION_RESUME_COMPLETION_STORAGE_PREFIX) &&
+            event.newValue !== null) {
+            listener();
+        }
+    };
+    const onMessage = (event) => {
+        if (event.origin !== window.location.origin ||
+            typeof event.data !== "object" ||
+            event.data === null ||
+            !("type" in event.data) ||
+            event.data.type !== "agent-native:workspace-connection-complete" ||
+            !("completionId" in event.data) ||
+            typeof event.data.completionId !== "string" ||
+            !event.source) {
+            return;
+        }
+        notifyMcpConnectionComplete(event.data.completionId);
+    };
     window.addEventListener(MCP_CONNECTION_RESUME_EVENT, listener);
-    return () => window.removeEventListener(MCP_CONNECTION_RESUME_EVENT, listener);
+    window.addEventListener("storage", onStorage);
+    window.addEventListener("message", onMessage);
+    return () => {
+        window.removeEventListener(MCP_CONNECTION_RESUME_EVENT, listener);
+        window.removeEventListener("storage", onStorage);
+        window.removeEventListener("message", onMessage);
+    };
 }

package/dist/client/sse-event-processor.d.ts

@@ -108,6 +108,12 @@ export interface SSEEvent {
     provider?: string;
     connectionReason?: "connect" | "grant" | "reauthorize" | "admin_required";
     appId?: string;
+    source?: {
+        id: string;
+        kind?: string;
+        label?: string;
+        uri?: string;
+    };
     error?: string;
     message?: string;
     seq?: number;

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

@@ -2,3 +2,4 @@ export { uploadEditorImage, type EditorImageUploadFn, type EditorImageUploadResu
 export { useUploadResource } from "./use-upload-resource.js";
 export { useFileUploadStatus } 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

@@ -2,3 +2,4 @@ export { uploadEditorImage, } from "./upload-editor-image.js";
 export { useUploadResource } from "./use-upload-resource.js";
 export { useFileUploadStatus } 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/private-icon.d.ts

@@ -0,0 +1,10 @@
+import type { IconValue } from "../../icons/index.js";
+export declare function workspacePrivateIconUrl(orgId: string, image: Extract<IconValue, {
+    kind: "image";
+}>): string | undefined;
+export declare function workspacePrivateIconLibraryUrl(orgId: string, image: Extract<IconValue, {
+    kind: "image";
+}>): string | undefined;
+export declare function uploadWorkspacePrivateIcon(file: File): Promise<Extract<IconValue, {
+    kind: "image";
+}>>;

package/dist/client/uploads/private-icon.js

@@ -0,0 +1,52 @@
+import { agentNativePath } from "../api-path.js";
+export function workspacePrivateIconUrl(orgId, image) {
+    if (image.authority === "url")
+        return image.assetId;
+    if (image.authority !== "private-icon" || !orgId)
+        return undefined;
+    return agentNativePath(`/_agent-native/org/private-icons/${encodeURIComponent(orgId)}/${encodeURIComponent(image.assetId)}`);
+}
+export function workspacePrivateIconLibraryUrl(orgId, image) {
+    if (image.authority === "url")
+        return image.assetId;
+    if (image.authority !== "private-icon" || !orgId)
+        return undefined;
+    return agentNativePath(`/_agent-native/org/private-icons/library/${encodeURIComponent(orgId)}/${encodeURIComponent(image.assetId)}`);
+}
+export async function uploadWorkspacePrivateIcon(file) {
+    const form = new FormData();
+    form.set("file", file);
+    const response = await fetch(agentNativePath("/_agent-native/org/private-icons"), {
+        method: "POST",
+        credentials: "include",
+        body: form,
+    });
+    if (!response.ok) {
+        const body = response.headers
+            .get("content-type")
+            ?.includes("application/json")
+            ? await response.json()
+            : null;
+        const message = body &&
+            typeof body === "object" &&
+            "message" in body &&
+            typeof body.message === "string"
+            ? body.message
+            : `Workspace icon upload failed (${response.status}).`;
+        throw new Error(message);
+    }
+    const body = await response.json();
+    if (!body ||
+        typeof body !== "object" ||
+        !("id" in body) ||
+        typeof body.id !== "string") {
+        throw new Error("Workspace icon upload returned an invalid asset ID.");
+    }
+    return {
+        version: 1,
+        kind: "image",
+        authority: "private-icon",
+        assetId: body.id,
+        alt: file.name.replace(/\.[^./\\]+$/, ""),
+    };
+}

package/dist/collab/routes.d.ts

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

package/dist/feature-flags/actions/get-feature-flags.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import { defineAction } from "../../action.js";
+import { getLabForLegacyFlag } from "../../labs/registry.js";
+import { getUserLabStates } from "../../labs/store.js";
 import { captureError } from "../../server/capture-error.js";
 import { listFeatureFlags } from "../registry.js";
 import { defaultFeatureFlagRules, evaluateFeatureFlagRules, getFeatureFlagRules, getFeatureFlagRulesForKeys, } from "../store.js";
@@ -38,6 +40,24 @@ export default defineAction({
                 return [key, false];
             }
         }));
+        const migratedKeys = definitions
+            .map(({ key }) => key)
+            .filter((key) => getLabForLegacyFlag(key));
+        if (migratedKeys.length === 0 || !scope.userEmail)
+            return values;
+        const labStates = await getUserLabStates(scope.userEmail, scope);
+        for (const key of migratedKeys) {
+            const lab = getLabForLegacyFlag(key);
+            if (!lab)
+                continue;
+            const state = labStates[lab.key];
+            if (!state)
+                throw new Error(`Missing migrated lab state: ${lab.key}`);
+            values[key] =
+                state.source === "choice"
+                    ? state.enabled
+                    : (state.legacyValues?.[key] ?? false);
+        }
         return values;
     },
 });

package/dist/feature-flags/actions/list-feature-flags.d.ts

@@ -19,6 +19,8 @@ declare const _default: import("../../action.js").ActionDefinition<Record<string
         defaultValue?: false;
         displayName?: string;
         description?: string;
+        movedToLab: string;
+        canManage: boolean;
         rules: import("../store.js").FeatureFlagRules;
         enabledForCurrentUser: boolean;
     }[];