@agent-native/core 0.198.3-nightly-20260930154911 → 0.198.4

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

@@ -16,8 +16,8 @@ export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import
 }>>;
 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/collab/struct-routes.d.ts

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/db/client.d.ts

@@ -53,6 +53,8 @@ export declare function retryOnDdlRace<T>(fn: () => Promise<T>): Promise<T>;
 export declare function isUniqueViolation(e: any): boolean;
 export declare function isLocalDatabase(): boolean;
 export declare function toPostgresParams(sql: string): string;
+export declare function hasExplicitDbTimeout(statement: DbExecStatement): boolean;
+export declare function postgresStatementTimeoutMs(clientTimeoutMs: number): number;
 export declare function dbExecQueryBudget(statement: DbExecStatement): {
     timeoutMs: number;
     maxAttempts: number;
@@ -150,5 +152,6 @@ export declare function pgliteDrizzleClient(url: string, client: any): any;
 export declare function createDbExec(config?: DbExecConfig): Promise<DbExec>;
 export declare function annotateMissingTable(err: unknown, sql: unknown): unknown;
 export declare function withDbExec<T>(exec: DbExec, run: () => T): T;
+export declare function getScopedDbExec(): DbExec | undefined;
 export declare function getDbExec(): DbExec;
 export declare function closeDbExec(): Promise<void>;

package/dist/db/client.js

@@ -556,13 +556,13 @@ function sqlAndArgs(sql) {
 const POSTGRES_STATEMENT_TIMEOUT_HEADROOM_MS = 250;
 const POSTGRES_STATEMENT_TIMEOUT_RESET_MS = 5_000;
 const POSTGRES_MAX_INT = 2_147_483_647;
-function hasExplicitDbTimeout(statement) {
+export function hasExplicitDbTimeout(statement) {
     if (typeof statement === "string")
         return false;
     const timeoutMs = Number(statement.timeoutMs);
     return Number.isFinite(timeoutMs) && timeoutMs > 0;
 }
-function postgresStatementTimeoutMs(clientTimeoutMs) {
+export function postgresStatementTimeoutMs(clientTimeoutMs) {
     const safeTimeoutMs = Math.max(1, Math.min(POSTGRES_MAX_INT, Math.floor(clientTimeoutMs)));
     const headroomMs = Math.min(POSTGRES_STATEMENT_TIMEOUT_HEADROOM_MS, Math.max(1, Math.floor(safeTimeoutMs * 0.1)));
     return Math.max(1, safeTimeoutMs - headroomMs);
@@ -1063,7 +1063,7 @@ async function executePglite(client, sql) {
         rowsAffected: result.affectedRows ?? result.rowCount ?? 0,
     };
 }
-function runPgliteTransaction(url, client, fn) {
+async function runPgliteTransaction(url, client, fn) {
     if (getActivePgliteTransactionExec(url)) {
         throw new Error("Nested PGlite transactions are not supported; reuse the active transaction handle.");
     }
@@ -1461,7 +1461,10 @@ export function annotateMissingTable(err, sql) {
 }
 const scopedDbExec = new AsyncLocalStorage();
 export function withDbExec(exec, run) {
-    return scopedDbExec.run(exec, run);
+    return scopedDbExec.run(guardSchemaMutations(exec), run);
+}
+export function getScopedDbExec() {
+    return scopedDbExec.getStore();
 }
 export function getDbExec() {
     const scoped = scopedDbExec.getStore();