@agent-native/core 0.182.1-nightly-20260917183518 → 0.182.1

package/corpus/templates/slides/app/hooks/use-agent-generating.ts

@@ -4,6 +4,7 @@ import {
   type AgentChatMessage,
 } from "@agent-native/core/client/agent-chat";
 import { useCallback, useEffect, useRef, useState } from "react";
+import { toast } from "sonner";
 
 // This is only a lost-signal recovery guard. A long deck legitimately takes
 // several minutes because each slide is written and fit-checked separately.
@@ -12,6 +13,7 @@ const MAX_GENERATING_MS = 30 * 60 * 1000;
 // Gateway continuations can briefly report a stopped chat between model/tool
 // chunks. Keep generation UI and presence steady across that transport gap.
 export const CHAT_STOP_DEBOUNCE_MS = 4_000;
+const CHAT_SUBMIT_TARGET_EVENT = "agentNative.chatSubmitTarget";
 
 type AgentGeneratingSubmitOptions = Pick<
   AgentChatMessage,
@@ -37,8 +39,13 @@ export function useAgentGenerating() {
   const engineConfigured = useAgentEngineConfigured();
   const [recentlyGenerating, setRecentlyGenerating] = useState(false);
   const [timedOut, setTimedOut] = useState(false);
+  const [runError, setRunError] = useState(false);
   const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const stopDebounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const activeSubmitRef = useRef<string | null>(null);
+  const activeTabRef = useRef<string | null>(null);
+  const generationActiveRef = useRef(false);
+  generationActiveRef.current = generating || recentlyGenerating;
 
   const clearWatchdog = useCallback(() => {
     if (timeoutRef.current !== null) {
@@ -62,9 +69,76 @@ export function useAgentGenerating() {
     clearWatchdog();
     setRecentlyGenerating(false);
     setTimedOut(false);
+    setRunError(false);
   }, [clearStopDebounce, clearWatchdog, providerMissing]);
 
   useEffect(() => {
+    const targetHandler = (event: Event) => {
+      const detail = (event as CustomEvent).detail;
+      if (
+        detail?.submitMessageId !== activeSubmitRef.current ||
+        typeof detail?.tabId !== "string"
+      ) {
+        return;
+      }
+      activeTabRef.current = detail.tabId;
+    };
+    const errorHandler = (event: Event) => {
+      const detail = (event as CustomEvent).detail;
+      const eventTabId =
+        typeof detail?.tabId === "string" ? detail.tabId : null;
+      if (
+        !generationActiveRef.current ||
+        !eventTabId ||
+        !activeTabRef.current ||
+        eventTabId !== activeTabRef.current ||
+        typeof detail?.message !== "string"
+      ) {
+        return;
+      }
+      activeSubmitRef.current = null;
+      activeTabRef.current = null;
+      clearStopDebounce();
+      clearWatchdog();
+      setRecentlyGenerating(false);
+      setTimedOut(false);
+      setRunError(true);
+      toast.error(detail.message, {
+        id:
+          typeof detail.runId === "string"
+            ? detail.runId
+            : `agent-run-error-${eventTabId}`,
+      });
+    };
+    const runningHandler = (event: Event) => {
+      const detail = (event as CustomEvent).detail;
+      if (
+        detail?.isRunning !== false ||
+        !activeTabRef.current ||
+        detail?.tabId !== activeTabRef.current
+      ) {
+        return;
+      }
+      activeSubmitRef.current = null;
+      activeTabRef.current = null;
+    };
+
+    window.addEventListener(CHAT_SUBMIT_TARGET_EVENT, targetHandler);
+    window.addEventListener("agent-chat:run-error", errorHandler);
+    window.addEventListener("agentNative.chatRunning", runningHandler);
+    return () => {
+      window.removeEventListener(CHAT_SUBMIT_TARGET_EVENT, targetHandler);
+      window.removeEventListener("agent-chat:run-error", errorHandler);
+      window.removeEventListener("agentNative.chatRunning", runningHandler);
+    };
+  }, [clearStopDebounce, clearWatchdog]);
+
+  useEffect(() => {
+    if (runError) {
+      clearStopDebounce();
+      clearWatchdog();
+      return clearStopDebounce;
+    }
     if (stopReason === "stopped") {
       clearStopDebounce();
       clearWatchdog();
@@ -93,6 +167,7 @@ export function useAgentGenerating() {
     generating,
     recentlyGenerating,
     stopReason,
+    runError,
     clearStopDebounce,
     clearWatchdog,
   ]);
@@ -111,16 +186,20 @@ export function useAgentGenerating() {
       context: string,
       options?: AgentGeneratingSubmitOptions,
     ) => {
+      const submitMessageId = `slides-submit-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
       setTimedOut(false);
+      setRunError(false);
       clearWatchdog();
       timeoutRef.current = setTimeout(
         () => setTimedOut(true),
         MAX_GENERATING_MS,
       );
-      send({
+      activeSubmitRef.current = submitMessageId;
+      activeTabRef.current = send({
         message,
         context,
         submit: true,
+        submitMessageId,
         ...options,
       } as AgentChatMessage & { attachments?: ReadonlyArray<unknown> });
     },
@@ -132,7 +211,8 @@ export function useAgentGenerating() {
       !providerMissing &&
       stopReason !== "stopped" &&
       (generating || recentlyGenerating) &&
-      !timedOut,
+      !timedOut &&
+      !runError,
     submit,
   };
 }

package/corpus/templates/slides/app/lib/image-drop-to-agent.ts

@@ -121,6 +121,10 @@ export function buildImageDropAgentPayload(args: {
 
 export function canInlineImageFile(file: File): boolean {
   const mediaType = file.type || "application/octet-stream";
+  if (mediaType.split(";", 1)[0]?.trim().toLowerCase() === "image/svg+xml") {
+    return false;
+  }
+  if (/\.svg$/i.test(file.name)) return false;
   const encodedLength = Math.ceil(file.size / 3) * 4;
   return (
     encodedLength + `data:${mediaType};base64,`.length <=
@@ -129,10 +133,13 @@ export function canInlineImageFile(file: File): boolean {
 }
 
 export function canInlineImageDataUrl(dataUrl: string): boolean {
-  const match = /^data:(image\/[^;]+);base64,(.*)$/s.exec(dataUrl);
+  const match = /^data:(image\/[^;]+);base64,(.*)$/is.exec(dataUrl);
+  const mediaType = match?.[1]?.trim().toLowerCase();
   return Boolean(
     match &&
-    match[2].length + `data:${match[1]};base64,`.length <=
+    mediaType &&
+    mediaType !== "image/svg+xml" &&
+    match[2].length + `data:${mediaType};base64,`.length <=
       MAX_INLINE_IMAGE_BASE64_CHARS,
   );
 }

package/corpus/templates/slides/app/lib/slide-image-replacement.ts

@@ -45,7 +45,7 @@ interface PlaceholderTarget {
 export function imageFileLooksSupported(file: File): boolean {
   return (
     file.type.startsWith("image/") ||
-    /\.(?:png|jpe?g|gif|webp|avif|ico)$/i.test(file.name)
+    /\.(?:png|jpe?g|gif|webp|avif|ico|svg)$/i.test(file.name)
   );
 }
 

package/corpus/templates/slides/app/pages/DeckEditor.tsx

@@ -3054,7 +3054,7 @@ export default function DeckEditor() {
       <input
         ref={uploadInputRef}
         type="file"
-        accept="image/*"
+        accept="image/*,.svg"
         onChange={handleDirectUpload}
         className="hidden"
       />

package/corpus/templates/slides/server/handlers/assets.ts

@@ -52,7 +52,7 @@ async function requireSession(
   return { session: auth.context as AuthedSlidesSession, error: null };
 }
 
-function isRasterAssetExtension(ext: string): boolean {
+function isImageAssetExtension(ext: string): boolean {
   return new Set([
     ".jpg",
     ".jpeg",
@@ -61,6 +61,7 @@ function isRasterAssetExtension(ext: string): boolean {
     ".webp",
     ".avif",
     ".ico",
+    ".svg",
   ]).has(ext);
 }
 
@@ -68,6 +69,16 @@ function ascii(data: Uint8Array, start: number, end: number): string {
   return Buffer.from(data.subarray(start, end)).toString("ascii");
 }
 
+export function hasExpectedSvgSignature(data: Uint8Array): boolean {
+  const head = Buffer.from(
+    data.subarray(0, Math.min(data.length, 8192)),
+  ).toString("utf8");
+  const normalized = head.replace(/^\uFEFF/, "").trimStart();
+  return /^(?:(?:\s|<!--[\s\S]*?-->|<\?xml\b[\s\S]*?\?>))*<svg(?:\s|\/?>)/i.test(
+    normalized,
+  );
+}
+
 function hasExpectedImageSignature(ext: string, data: Uint8Array): boolean {
   if (ext === ".png") {
     return (
@@ -98,16 +109,127 @@ function hasExpectedImageSignature(ext: string, data: Uint8Array): boolean {
   if (ext === ".avif") {
     return ascii(data, 4, 12).includes("ftyp");
   }
+  if (ext === ".svg") {
+    return hasExpectedSvgSignature(data);
+  }
   return false;
 }
 
+function decodeXmlReferences(source: string): string {
+  const namedReferences: Record<string, string> = {
+    amp: "&",
+    apos: "'",
+    gt: ">",
+    lt: "<",
+    quot: '"',
+  };
+  return source.replace(
+    /&#x([0-9a-f]+);|&#([0-9]+);|&([a-z]+);/gi,
+    (
+      match,
+      hex: string | undefined,
+      decimal: string | undefined,
+      named: string | undefined,
+    ) => {
+      const codePoint = hex
+        ? Number.parseInt(hex, 16)
+        : decimal
+          ? Number.parseInt(decimal, 10)
+          : undefined;
+      if (
+        codePoint !== undefined &&
+        codePoint <= 0x10ffff &&
+        !(codePoint >= 0xd800 && codePoint <= 0xdfff)
+      ) {
+        return String.fromCodePoint(codePoint);
+      }
+      return named ? (namedReferences[named.toLowerCase()] ?? match) : match;
+    },
+  );
+}
+
+function decodeCssEscapes(source: string): string {
+  return source
+    .replace(/\\(?:\r\n|[\r\n\f])/g, "")
+    .replace(
+      /\\([0-9a-f]{1,6})(?:[ \t\r\n\f])?|\\([^\r\n])/gi,
+      (match, hex: string | undefined, character: string | undefined) => {
+        if (!hex) return character ?? match;
+        const codePoint = Number.parseInt(hex, 16);
+        if (
+          codePoint > 0x10ffff ||
+          (codePoint >= 0xd800 && codePoint <= 0xdfff)
+        ) {
+          return match;
+        }
+        return String.fromCodePoint(codePoint);
+      },
+    );
+}
+
+export function isSafeSvg(data: Uint8Array): boolean {
+  let source: string;
+  try {
+    source = new TextDecoder("utf-8", { fatal: true }).decode(data);
+  } catch {
+    // coercion-ok: malformed UTF-8 must reject SVG validation.
+    return false;
+  }
+  source = source.replace(/^\uFEFF/, "").trim();
+  const normalizedSource = decodeCssEscapes(
+    decodeXmlReferences(source),
+  ).replace(/\/\*[\s\S]*?\*\//g, "");
+  const forbidden = [
+    /<\s*(?:script|foreignObject|iframe|object|embed|link|audio|video|animate(?:Transform|Motion|Color)?|set|discard)\b/i,
+    /<\s*\/?[a-z_][\w.-]*:[a-z_][\w.-]*\b/i,
+    /<!\s*(?:DOCTYPE|ENTITY)\b/i,
+    /<\?xml-stylesheet\b/i,
+    /\bxml:base\s*=/i,
+    /\son[a-z][a-z0-9:_-]*\s*=/i,
+    /\b(?:javascript|vbscript)\s*:/i,
+    /\b(?:expression|behavior|-moz-binding)\s*\(/i,
+    /@import\b/i,
+    /\b(?:image|(?:-webkit-)?image-set)\s*\(/i,
+  ];
+  if (forbidden.some((pattern) => pattern.test(normalizedSource))) return false;
+
+  for (const match of normalizedSource.matchAll(
+    /(?:href|xlink:href)\s*=\s*(?:(['"])(.*?)\1|([^\s>]+))/gi,
+  )) {
+    const target = (match[2] ?? match[3] ?? match[4] ?? "").trim();
+    if (
+      target &&
+      !target.startsWith("#") &&
+      !/^data:image\/(?:png|jpeg|gif|webp);base64,/i.test(target)
+    ) {
+      return false;
+    }
+  }
+  for (const match of normalizedSource.matchAll(
+    /url\(\s*(["']?)(.*?)\1\s*\)/gi,
+  )) {
+    const target = match[2]?.trim() ?? "";
+    if (
+      target &&
+      !target.startsWith("#") &&
+      !/^data:image\/(?:png|jpeg|gif|webp);base64,/i.test(target)
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
 export function canSaveAsUploadedAsset(args: {
   originalName: string;
   data: Uint8Array;
 }): boolean {
+  const ext = path.extname(args.originalName).toLowerCase();
   return (
     args.data.length <= MAX_ASSET_FILE_SIZE &&
-    isRasterAssetExtension(path.extname(args.originalName).toLowerCase())
+    isImageAssetExtension(ext) &&
+    (ext !== ".svg" ||
+      (hasExpectedImageSignature(ext, args.data) && isSafeSvg(args.data)))
   );
 }
 
@@ -133,22 +255,26 @@ export async function uploadImageAsset(args: {
   }
 
   const ext = path.extname(args.originalName).toLowerCase();
-  // SVG is excluded — it can embed <script> tags and execute when served
-  // as image/svg+xml from the same origin.
-  if (!isRasterAssetExtension(ext)) {
+  if (!isImageAssetExtension(ext)) {
     throw new Error(
-      "Only raster image files are allowed (jpg, png, gif, webp, avif, ico)",
+      "Only image files are allowed (jpg, png, gif, webp, avif, ico, svg)",
     );
   }
   if (!hasExpectedImageSignature(ext, args.data)) {
     throw new Error("Uploaded image bytes do not match file extension");
   }
 
+  if (ext === ".svg" && !isSafeSvg(args.data)) {
+    throw new Error("SVG contains active content or external references");
+  }
+
+  const mimeType = ext === ".svg" ? "image/svg+xml" : args.type;
+
   const result = await runWithRequestContext({ userEmail: args.email }, () =>
     uploadFile({
       data: args.data,
       filename: args.originalName,
-      mimeType: args.type,
+      mimeType,
       ownerEmail: args.email,
     }),
   );
@@ -164,7 +290,7 @@ export async function uploadImageAsset(args: {
   const asset: UploadedAsset = {
     url: result.url,
     filename: args.originalName,
-    type: args.type || "application/octet-stream",
+    type: mimeType || "application/octet-stream",
     size: args.data.length,
     provider: result.provider,
   };

package/corpus/templates/slides/server/handlers/uploads.ts

@@ -13,6 +13,7 @@ import {
   MAX_FIG_REFERENCE_FILE_BYTES,
   MAX_REFERENCE_FILE_BYTES,
   MAX_REFERENCE_FILES,
+  MAX_SVG_REFERENCE_FILE_BYTES,
   SLIDES_REFERENCE_FILE_ERROR_LABEL,
   isSlidesReferenceFileExtension,
 } from "../../shared/upload-types.js";
@@ -22,7 +23,12 @@ import {
   deleteUploadedReferenceBlob,
   storeUploadedReferenceBlob,
 } from "../lib/uploaded-reference-storage.js";
-import { canSaveAsUploadedAsset, uploadImageAsset } from "./assets.js";
+import {
+  canSaveAsUploadedAsset,
+  hasExpectedSvgSignature,
+  isSafeSvg,
+  uploadImageAsset,
+} from "./assets.js";
 import {
   resolveSlidesRequestAuth,
   withSlidesRequestContext,
@@ -31,6 +37,7 @@ import {
 export {
   MAX_FIG_REFERENCE_FILE_BYTES,
   MAX_REFERENCE_FILE_BYTES,
+  MAX_SVG_REFERENCE_FILE_BYTES,
 } from "../../shared/upload-types.js";
 const FIG_LOCAL_COPY_SIGNATURE = new Uint8Array([
   0x66, 0x69, 0x67, 0x2d, 0x6b, 0x69, 0x77, 0x69,
@@ -66,6 +73,9 @@ function ascii(data: Uint8Array, start: number, end: number): string {
 export function maxReferenceFileBytes(
   originalName: string | undefined,
 ): number {
+  if (path.extname(originalName ?? "").toLowerCase() === ".svg") {
+    return MAX_SVG_REFERENCE_FILE_BYTES;
+  }
   return path.extname(originalName ?? "").toLowerCase() === ".fig"
     ? MAX_FIG_REFERENCE_FILE_BYTES
     : MAX_REFERENCE_FILE_BYTES;
@@ -108,14 +118,7 @@ function hasExpectedSignature(ext: string, data: Uint8Array): boolean {
     return ascii(data, 0, 4) === "RIFF" && ascii(data, 8, 12) === "WEBP";
   }
   if (ext === ".svg") {
-    const head = Buffer.from(
-      data.subarray(0, Math.min(data.length, 8192)),
-    ).toString("utf8");
-    const normalized = head.replace(/^\uFEFF/, "").trimStart();
-    return (
-      /^<svg(?:\s|>)/i.test(normalized) ||
-      /^<\?xml\b[\s\S]{0,4096}<svg(?:\s|>)/i.test(normalized)
-    );
+    return hasExpectedSvgSignature(data);
   }
   return !data.subarray(0, 4096).includes(0);
 }
@@ -160,6 +163,10 @@ export async function saveUploadedReferenceFile(args: {
       `Unsupported file type. Allowed: ${SLIDES_REFERENCE_FILE_ERROR_LABEL}.`,
     );
   }
+  const maxBytes = maxReferenceFileBytes(args.originalName);
+  if (args.data.length > maxBytes) {
+    throw new Error(`File too large (max ${formatMaxFileSize(maxBytes)})`);
+  }
   const isDeclaredImage = [".png", ".jpg", ".jpeg", ".gif", ".webp"].includes(
     declaredExt,
   );
@@ -179,12 +186,18 @@ export async function saveUploadedReferenceFile(args: {
   if (!hasExpectedSignature(ext, args.data)) {
     throw new Error(`File contents do not match ${ext} upload type`);
   }
+  if (ext === ".svg" && !isSafeSvg(args.data)) {
+    throw new Error("SVG contains active content or external references");
+  }
   const assetOriginalName =
     ext === declaredExt
       ? args.originalName
       : `${path.basename(args.originalName, path.extname(args.originalName))}${ext}`;
   const resolvedType =
-    detectedImage?.mimeType ?? (args.type || "application/octet-stream");
+    detectedImage?.mimeType ??
+    (declaredExt === ".svg"
+      ? "image/svg+xml"
+      : args.type || "application/octet-stream");
   let uploadedPath: string;
   if (isHostedSlidesRuntime()) {
     let reference: string | null;

package/corpus/templates/slides/shared/upload-types.ts

@@ -27,6 +27,7 @@ export const SLIDES_REFERENCE_FILE_ERROR_LABEL =
 
 export const MAX_REFERENCE_FILES = 20;
 export const MAX_REFERENCE_FILE_BYTES = 50 * 1024 * 1024;
+export const MAX_SVG_REFERENCE_FILE_BYTES = 10 * 1024 * 1024;
 export const MAX_INLINE_IMAGE_BASE64_CHARS = 1_000_000;
 export const MAX_INLINE_IMAGE_BYTES = 10 * 1024 * 1024;
 export const MAX_FIG_REFERENCE_FILE_BYTES = 200 * 1024 * 1024;

package/dist/application-state/store.d.ts

@@ -31,4 +31,13 @@ export declare function appStateList(sessionId: string, keyPrefix: string): Prom
     key: string;
     value: Record<string, unknown>;
 }>>;
+/**
+ * List a bounded batch of keys across sessions for framework-owned cleanup.
+ * Callers must use the returned session id when conditionally deleting a row.
+ */
+export declare function appStateListByKeyPrefix(keyPrefix: string, limit?: number): Promise<Array<{
+    sessionId: string;
+    key: string;
+    value: Record<string, unknown>;
+}>>;
 export declare function appStateDeleteByPrefix(sessionId: string, keyPrefix: string, options?: StoreWriteOptions): Promise<number>;

package/dist/application-state/store.js

@@ -217,6 +217,24 @@ export async function appStateList(sessionId, keyPrefix) {
         value: JSON.parse(row.value),
     }));
 }
+/**
+ * List a bounded batch of keys across sessions for framework-owned cleanup.
+ * Callers must use the returned session id when conditionally deleting a row.
+ */
+export async function appStateListByKeyPrefix(keyPrefix, limit = 100) {
+    await ensureTable();
+    const client = getDbExec();
+    const boundedLimit = Math.max(1, Math.min(Math.floor(limit), 2_048));
+    const { rows } = await client.execute({
+        sql: `SELECT session_id, key, value FROM application_state WHERE key LIKE ? ESCAPE '!' ORDER BY updated_at ASC LIMIT ?`,
+        args: [escapeLike(keyPrefix) + "%", boundedLimit],
+    });
+    return rows.map((row) => ({
+        sessionId: row.session_id,
+        key: row.key,
+        value: JSON.parse(row.value),
+    }));
+}
 export async function appStateDeleteByPrefix(sessionId, keyPrefix, options) {
     await ensureTable();
     const client = getDbExec();

package/dist/automation/index.d.ts

@@ -186,8 +186,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
+    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
-    error?: undefined;
 }>;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/deploy/build.js

@@ -768,6 +768,12 @@ export const CLOUDFLARE_WORKER_NODE_BUILTIN_STUB_MODULES = {
         "moveCursor",
     ]),
     repl: cloudflareNodeBuiltinStubSource("repl", ["start"]),
+    sqlite: cloudflareNodeBuiltinStubSource("sqlite", [
+        "DatabaseSync",
+        "StatementSync",
+        "backup",
+        "constants",
+    ]),
     sys: cloudflareNodeBuiltinStubSource("sys", [
         "debug",
         "deprecate",
@@ -2443,6 +2449,7 @@ const NODE_BUILTINS = [
     "stream",
     "stream/web",
     "string_decoder",
+    "sqlite",
     "sys",
     "timers",
     "tls",

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

@@ -1,27 +1,58 @@
+export declare const UPLOAD_RECEIPT_PREFIX = "file-upload-receipt:";
+/** Commit every image receipt for a completed browser import batch. */
+export declare function commitUploadReceiptsForImport(importId: string): Promise<void>;
+export declare function runUploadReceiptCleanupOnce(options?: {
+    force?: boolean;
+    now?: number;
+    limit?: number;
+}): Promise<{
+    scanned: number;
+    deleted: number;
+    released: number;
+    failed: number;
+    skipped: boolean;
+}>;
 declare const _default: import("../../action.js").ActionDefinition<{
     data?: string;
     url?: string;
     filename?: string;
+    idempotencyKey?: string;
+    cleanup?: "delete" | "release";
 }, {
-    error: string;
-    configured?: undefined;
-    connectPath?: undefined;
-    url?: undefined;
-    id?: undefined;
-    provider?: undefined;
+    idempotencyKey: string;
+    alreadyMissing: boolean;
+    released?: undefined;
+    deleted?: undefined;
+} | {
+    alreadyMissing?: undefined;
+    idempotencyKey: string;
+    released: boolean;
+    deleted?: undefined;
+} | {
+    alreadyMissing?: undefined;
+    released?: undefined;
+    idempotencyKey: string;
+    deleted: boolean;
 } | {
     error: string;
-    configured: boolean;
-    connectPath: string;
     url?: undefined;
     id?: undefined;
     provider?: undefined;
-} | {
-    error?: undefined;
     configured?: undefined;
     connectPath?: undefined;
+} | {
     url: string;
     id: string;
     provider: string;
+    configured?: undefined;
+    connectPath?: undefined;
+    error?: undefined;
+} | {
+    url?: undefined;
+    id?: undefined;
+    provider?: undefined;
+    error: string;
+    configured: boolean;
+    connectPath: string;
 }>;
 export default _default;