@ai-sdk/react 4.0.123 → 4.0.126

package/dist/index.js

@@ -1,1401 +1,1226 @@
-// src/use-object.ts
-import {
-  isAbortError,
-  resolve,
-  normalizeHeaders,
-  safeValidateTypes
-} from "@ai-sdk/provider-utils";
-import {
-  asSchema,
-  isDeepEqualData,
-  parsePartialJson
-} from "ai";
-import { useCallback, useId, useRef, useState } from "react";
+import { isAbortError, normalizeHeaders, resolve, safeValidateTypes, secureJsonParse } from "@ai-sdk/provider-utils";
+import { AbstractChat, DefaultChatTransport, Experimental_AbstractRealtimeSession, asSchema, callCompletionApi, isDeepEqualData, parsePartialJson } from "ai";
+import { useCallback, useEffect, useId, useInsertionEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import useSWR from "swr";
-var getOriginalFetch = () => fetch;
-function useObject({
-  api,
-  id,
-  schema,
-  // required, in the future we will use it for validation
-  initialValue,
-  fetch: fetch2,
-  onError,
-  onFinish,
-  headers,
-  credentials
-}) {
-  const hookId = useId();
-  const completionId = id ?? hookId;
-  const { data, mutate } = useSWR(
-    [completionId, "object"],
-    null,
-    { fallbackData: { object: initialValue } }
-  );
-  const [error, setError] = useState(void 0);
-  const [isLoading, setIsLoading] = useState(false);
-  const abortControllerRef = useRef(null);
-  const stop = useCallback(() => {
-    try {
-      abortControllerRef.current?.abort();
-    } catch {
-    } finally {
-      setIsLoading(false);
-      abortControllerRef.current = null;
-    }
-  }, []);
-  const submit = async (input) => {
-    const abortController = new AbortController();
-    try {
-      clearObject();
-      setIsLoading(true);
-      abortControllerRef.current = abortController;
-      const resolvedHeaders = await resolve(headers);
-      const actualFetch = fetch2 ?? getOriginalFetch();
-      const response = await actualFetch(api, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...normalizeHeaders(resolvedHeaders)
-        },
-        credentials,
-        signal: abortController.signal,
-        body: JSON.stringify(input)
-      });
-      if (!response.ok) {
-        throw new Error(
-          await response.text() || "Failed to fetch the response."
-        );
-      }
-      if (response.body == null) {
-        throw new Error("The response body is empty.");
-      }
-      let accumulatedText = "";
-      let latestObject = void 0;
-      await response.body.pipeThrough(new TextDecoderStream()).pipeTo(
-        new WritableStream({
-          async write(chunk) {
-            accumulatedText += chunk;
-            const { value } = await parsePartialJson(accumulatedText);
-            const currentObject = value;
-            if (!isDeepEqualData(latestObject, currentObject)) {
-              latestObject = currentObject;
-              mutate({ object: currentObject });
-            }
-          },
-          async close() {
-            if (abortControllerRef.current === abortController) {
-              setIsLoading(false);
-            }
-            if (onFinish != null) {
-              const validationResult = await safeValidateTypes({
-                value: latestObject,
-                schema: asSchema(schema)
-              });
-              await onFinish(
-                validationResult.success ? { object: validationResult.value, error: void 0 } : { object: void 0, error: validationResult.error }
-              );
-            }
-            if (abortControllerRef.current === abortController) {
-              abortControllerRef.current = null;
-            }
-          }
-        })
-      );
-    } catch (error2) {
-      if (isAbortError(error2)) {
-        return;
-      }
-      if (onError && error2 instanceof Error) {
-        onError(error2);
-      }
-      if (abortControllerRef.current === abortController) {
-        setIsLoading(false);
-        abortControllerRef.current = null;
-        setError(error2 instanceof Error ? error2 : new Error(String(error2)));
-      }
-    }
-  };
-  const clear = () => {
-    stop();
-    clearObject();
-  };
-  const clearObject = () => {
-    setError(void 0);
-    setIsLoading(false);
-    mutate({ object: void 0 });
-  };
-  return {
-    submit,
-    object: data?.object,
-    error,
-    isLoading,
-    stop,
-    clear
-  };
-}
-
-// src/use-chat.ts
-import {
-  DefaultChatTransport
-} from "ai";
-import {
-  useCallback as useCallback2,
-  useEffect,
-  useMemo,
-  useRef as useRef2,
-  useSyncExternalStore
-} from "react";
-
-// src/chat.react.ts
-import {
-  AbstractChat
-} from "ai";
-
-// src/throttle.ts
 import throttleFunction from "throttleit";
+import { isJSONObject } from "@ai-sdk/provider";
+import { jsx } from "react/jsx-runtime";
+//#region src/use-object.ts
+const getOriginalFetch = () => fetch;
+function useObject({ api, id, schema, initialValue, fetch, onError, onFinish, headers, credentials }) {
+	const hookId = useId();
+	const { data, mutate } = useSWR([id ?? hookId, "object"], null, { fallbackData: { object: initialValue } });
+	const [error, setError] = useState(void 0);
+	const [isLoading, setIsLoading] = useState(false);
+	const abortControllerRef = useRef(null);
+	const stop = useCallback(() => {
+		try {
+			abortControllerRef.current?.abort();
+		} catch {} finally {
+			setIsLoading(false);
+			abortControllerRef.current = null;
+		}
+	}, []);
+	const submit = async (input) => {
+		const abortController = new AbortController();
+		try {
+			clearObject();
+			setIsLoading(true);
+			abortControllerRef.current = abortController;
+			const resolvedHeaders = await resolve(headers);
+			const response = await (fetch ?? getOriginalFetch())(api, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...normalizeHeaders(resolvedHeaders)
+				},
+				credentials,
+				signal: abortController.signal,
+				body: JSON.stringify(input)
+			});
+			if (!response.ok) throw new Error(await response.text() || "Failed to fetch the response.");
+			if (response.body == null) throw new Error("The response body is empty.");
+			let accumulatedText = "";
+			let latestObject = void 0;
+			await response.body.pipeThrough(new TextDecoderStream()).pipeTo(new WritableStream({
+				async write(chunk) {
+					accumulatedText += chunk;
+					const { value } = await parsePartialJson(accumulatedText);
+					const currentObject = value;
+					if (!isDeepEqualData(latestObject, currentObject)) {
+						latestObject = currentObject;
+						mutate({ object: currentObject });
+					}
+				},
+				async close() {
+					if (abortControllerRef.current === abortController) setIsLoading(false);
+					if (onFinish != null) {
+						const validationResult = await safeValidateTypes({
+							value: latestObject,
+							schema: asSchema(schema)
+						});
+						await onFinish(validationResult.success ? {
+							object: validationResult.value,
+							error: void 0
+						} : {
+							object: void 0,
+							error: validationResult.error
+						});
+					}
+					if (abortControllerRef.current === abortController) abortControllerRef.current = null;
+				}
+			}));
+		} catch (error) {
+			if (isAbortError(error)) return;
+			if (onError && error instanceof Error) onError(error);
+			if (abortControllerRef.current === abortController) {
+				setIsLoading(false);
+				abortControllerRef.current = null;
+				setError(error instanceof Error ? error : new Error(String(error)));
+			}
+		}
+	};
+	const clear = () => {
+		stop();
+		clearObject();
+	};
+	const clearObject = () => {
+		setError(void 0);
+		setIsLoading(false);
+		mutate({ object: void 0 });
+	};
+	return {
+		submit,
+		object: data?.object,
+		error,
+		isLoading,
+		stop,
+		clear
+	};
+}
+//#endregion
+//#region src/throttle.ts
 function throttle(fn, waitMs) {
-  return waitMs != null ? throttleFunction(fn, waitMs) : fn;
+	return waitMs != null ? throttleFunction(fn, waitMs) : fn;
 }
-
-// src/chat.react.ts
+//#endregion
+//#region src/chat.react.ts
 function cloneMetadata(metadata) {
-  if (Array.isArray(metadata)) {
-    return [...metadata];
-  }
-  if (metadata != null && typeof metadata === "object" && (Object.getPrototypeOf(metadata) === Object.prototype || Object.getPrototypeOf(metadata) === null)) {
-    return { ...metadata };
-  }
-  return metadata;
+	if (Array.isArray(metadata)) return [...metadata];
+	if (metadata != null && typeof metadata === "object" && (Object.getPrototypeOf(metadata) === Object.prototype || Object.getPrototypeOf(metadata) === null)) return { ...metadata };
+	return metadata;
 }
 var ReactChatState = class {
-  constructor(initialMessages = []) {
-    this.#status = "ready";
-    this.#error = void 0;
-    this.#messagesCallbacks = /* @__PURE__ */ new Set();
-    this.#statusCallbacks = /* @__PURE__ */ new Set();
-    this.#errorCallbacks = /* @__PURE__ */ new Set();
-    this.pushMessage = (message) => {
-      this.#messages = this.#messages.concat(message);
-      this.#callMessagesCallbacks();
-    };
-    this.popMessage = () => {
-      this.#messages = this.#messages.slice(0, -1);
-      this.#callMessagesCallbacks();
-    };
-    this.replaceMessage = (index, message) => {
-      this.#messages = [
-        ...this.#messages.slice(0, index),
-        this.snapshot(message),
-        ...this.#messages.slice(index + 1)
-      ];
-      this.#callMessagesCallbacks();
-    };
-    this.snapshot = (value) => {
-      if (value == null || typeof value !== "object" || !("parts" in value) || !Array.isArray(value.parts)) {
-        return value;
-      }
-      const message = value;
-      const snapshot = {
-        ...message,
-        parts: message.parts.map((part) => ({ ...part }))
-      };
-      if ("metadata" in message) {
-        snapshot.metadata = cloneMetadata(message.metadata);
-      }
-      return snapshot;
-    };
-    this["~registerMessagesCallback"] = (onChange, throttleWaitMs) => {
-      const callback = throttleWaitMs ? throttle(onChange, throttleWaitMs) : onChange;
-      this.#messagesCallbacks.add(callback);
-      return () => {
-        this.#messagesCallbacks.delete(callback);
-      };
-    };
-    this["~registerStatusCallback"] = (onChange) => {
-      this.#statusCallbacks.add(onChange);
-      return () => {
-        this.#statusCallbacks.delete(onChange);
-      };
-    };
-    this["~registerErrorCallback"] = (onChange) => {
-      this.#errorCallbacks.add(onChange);
-      return () => {
-        this.#errorCallbacks.delete(onChange);
-      };
-    };
-    this.#callMessagesCallbacks = () => {
-      this.#messagesCallbacks.forEach((callback) => callback());
-    };
-    this.#callStatusCallbacks = () => {
-      this.#statusCallbacks.forEach((callback) => callback());
-    };
-    this.#callErrorCallbacks = () => {
-      this.#errorCallbacks.forEach((callback) => callback());
-    };
-    this.#messages = initialMessages;
-  }
-  #messages;
-  #status;
-  #error;
-  #messagesCallbacks;
-  #statusCallbacks;
-  #errorCallbacks;
-  get status() {
-    return this.#status;
-  }
-  set status(newStatus) {
-    this.#status = newStatus;
-    this.#callStatusCallbacks();
-  }
-  get error() {
-    return this.#error;
-  }
-  set error(newError) {
-    this.#error = newError;
-    this.#callErrorCallbacks();
-  }
-  get messages() {
-    return this.#messages;
-  }
-  set messages(newMessages) {
-    this.#messages = [...newMessages];
-    this.#callMessagesCallbacks();
-  }
-  #callMessagesCallbacks;
-  #callStatusCallbacks;
-  #callErrorCallbacks;
+	#messages;
+	#status;
+	#error;
+	#messagesCallbacks;
+	#statusCallbacks;
+	#errorCallbacks;
+	constructor(initialMessages = []) {
+		this.#status = "ready";
+		this.#error = void 0;
+		this.#messagesCallbacks = /* @__PURE__ */ new Set();
+		this.#statusCallbacks = /* @__PURE__ */ new Set();
+		this.#errorCallbacks = /* @__PURE__ */ new Set();
+		this.pushMessage = (message) => {
+			this.#messages = this.#messages.concat(message);
+			this.#callMessagesCallbacks();
+		};
+		this.popMessage = () => {
+			this.#messages = this.#messages.slice(0, -1);
+			this.#callMessagesCallbacks();
+		};
+		this.replaceMessage = (index, message) => {
+			this.#messages = [
+				...this.#messages.slice(0, index),
+				this.snapshot(message),
+				...this.#messages.slice(index + 1)
+			];
+			this.#callMessagesCallbacks();
+		};
+		this.snapshot = (value) => {
+			if (value == null || typeof value !== "object" || !("parts" in value) || !Array.isArray(value.parts)) return value;
+			const message = value;
+			const snapshot = {
+				...message,
+				parts: message.parts.map((part) => ({ ...part }))
+			};
+			if ("metadata" in message) snapshot.metadata = cloneMetadata(message.metadata);
+			return snapshot;
+		};
+		this["~registerMessagesCallback"] = (onChange, throttleWaitMs) => {
+			const callback = throttleWaitMs ? throttle(onChange, throttleWaitMs) : onChange;
+			this.#messagesCallbacks.add(callback);
+			return () => {
+				this.#messagesCallbacks.delete(callback);
+			};
+		};
+		this["~registerStatusCallback"] = (onChange) => {
+			this.#statusCallbacks.add(onChange);
+			return () => {
+				this.#statusCallbacks.delete(onChange);
+			};
+		};
+		this["~registerErrorCallback"] = (onChange) => {
+			this.#errorCallbacks.add(onChange);
+			return () => {
+				this.#errorCallbacks.delete(onChange);
+			};
+		};
+		this.#callMessagesCallbacks = () => {
+			this.#messagesCallbacks.forEach((callback) => callback());
+		};
+		this.#callStatusCallbacks = () => {
+			this.#statusCallbacks.forEach((callback) => callback());
+		};
+		this.#callErrorCallbacks = () => {
+			this.#errorCallbacks.forEach((callback) => callback());
+		};
+		this.#messages = initialMessages;
+	}
+	get status() {
+		return this.#status;
+	}
+	set status(newStatus) {
+		this.#status = newStatus;
+		this.#callStatusCallbacks();
+	}
+	get error() {
+		return this.#error;
+	}
+	set error(newError) {
+		this.#error = newError;
+		this.#callErrorCallbacks();
+	}
+	get messages() {
+		return this.#messages;
+	}
+	set messages(newMessages) {
+		this.#messages = [...newMessages];
+		this.#callMessagesCallbacks();
+	}
+	#callMessagesCallbacks;
+	#callStatusCallbacks;
+	#callErrorCallbacks;
 };
 var Chat = class extends AbstractChat {
-  constructor({ messages, ...init }) {
-    const state = new ReactChatState(messages);
-    super({ ...init, state });
-    this["~registerMessagesCallback"] = (onChange, throttleWaitMs) => this.#state["~registerMessagesCallback"](onChange, throttleWaitMs);
-    this["~registerStatusCallback"] = (onChange) => this.#state["~registerStatusCallback"](onChange);
-    this["~registerErrorCallback"] = (onChange) => this.#state["~registerErrorCallback"](onChange);
-    this.#state = state;
-  }
-  #state;
+	#state;
+	constructor({ messages, ...init }) {
+		const state = new ReactChatState(messages);
+		super({
+			...init,
+			state
+		});
+		this["~registerMessagesCallback"] = (onChange, throttleWaitMs) => this.#state["~registerMessagesCallback"](onChange, throttleWaitMs);
+		this["~registerStatusCallback"] = (onChange) => this.#state["~registerStatusCallback"](onChange);
+		this["~registerErrorCallback"] = (onChange) => this.#state["~registerErrorCallback"](onChange);
+		this.#state = state;
+	}
 };
-
-// src/use-chat.ts
-function useChat({
-  throttle: throttle2,
-  experimental_throttle,
-  resume = false,
-  ...options
-} = {}) {
-  const throttleWaitMs = throttle2 ?? experimental_throttle;
-  const latestRef = useRef2({});
-  if (!("chat" in options)) {
-    latestRef.current = {
-      onToolCall: options.onToolCall,
-      onData: options.onData,
-      onFinish: options.onFinish,
-      onError: options.onError,
-      sendAutomaticallyWhen: options.sendAutomaticallyWhen,
-      transport: options.transport
-    };
-  }
-  let defaultTransport;
-  const getTransport = () => latestRef.current.transport ?? (defaultTransport ??= new DefaultChatTransport());
-  const chatOptions = {
-    ...options,
-    transport: {
-      sendMessages: (sendOptions) => getTransport().sendMessages(sendOptions),
-      reconnectToStream: (reconnectOptions) => getTransport().reconnectToStream(reconnectOptions)
-    },
-    onToolCall: (arg) => latestRef.current.onToolCall?.(arg),
-    onData: (arg) => latestRef.current.onData?.(arg),
-    onFinish: (arg) => latestRef.current.onFinish?.(arg),
-    onError: (arg) => latestRef.current.onError?.(arg),
-    sendAutomaticallyWhen: (arg) => latestRef.current.sendAutomaticallyWhen?.(arg) ?? false
-  };
-  const chatKey = "chat" in options ? options.chat : options.id;
-  const { chat, isExternallyManaged } = useMemo(
-    () => ({
-      chat: "chat" in options ? options.chat : new Chat(chatOptions),
-      isExternallyManaged: "chat" in options
-    }),
-    [chatKey]
-  );
-  useEffect(() => {
-    if (isExternallyManaged) {
-      return;
-    }
-    return () => {
-      void chat.stop();
-    };
-  }, [chat, isExternallyManaged]);
-  const messagesSnapshot = useMemo(() => ({ messages: chat.messages }), [chat]);
-  const subscribeToMessages = useCallback2(
-    (update) => {
-      let isSubscribed = true;
-      const updateMessages = () => {
-        if (!isSubscribed) {
-          return;
-        }
-        messagesSnapshot.messages = chat.messages;
-        update();
-      };
-      const unsubscribe = chat["~registerMessagesCallback"](
-        updateMessages,
-        throttleWaitMs
-      );
-      messagesSnapshot.messages = chat.messages;
-      return () => {
-        isSubscribed = false;
-        unsubscribe();
-      };
-    },
-    [chat, messagesSnapshot, throttleWaitMs]
-  );
-  const getMessagesSnapshot = useCallback2(
-    () => messagesSnapshot.messages,
-    [messagesSnapshot]
-  );
-  const messages = useSyncExternalStore(
-    subscribeToMessages,
-    getMessagesSnapshot,
-    getMessagesSnapshot
-  );
-  const subscribeToStatus = useCallback2(
-    (update) => chat["~registerStatusCallback"](() => {
-      if (chat.status === "ready" || chat.status === "error") {
-        messagesSnapshot.messages = chat.messages;
-      }
-      update();
-    }),
-    [chat, messagesSnapshot]
-  );
-  const getStatusSnapshot = useCallback2(() => chat.status, [chat]);
-  const status = useSyncExternalStore(
-    subscribeToStatus,
-    getStatusSnapshot,
-    getStatusSnapshot
-  );
-  const error = useSyncExternalStore(
-    chat["~registerErrorCallback"],
-    () => chat.error,
-    () => chat.error
-  );
-  const setMessages = useCallback2(
-    (messagesParam) => {
-      if (typeof messagesParam === "function") {
-        messagesParam = messagesParam(chat.messages);
-      }
-      chat.messages = messagesParam;
-    },
-    [chat]
-  );
-  useEffect(() => {
-    if (resume) {
-      chat.resumeStream();
-    }
-  }, [resume, chat]);
-  return {
-    id: chat.id,
-    messages,
-    setMessages,
-    sendMessage: chat.sendMessage,
-    regenerate: chat.regenerate,
-    clearError: chat.clearError,
-    stop: chat.stop,
-    error,
-    resumeStream: chat.resumeStream,
-    status,
-    /**
-     * @deprecated Use `addToolOutput` instead.
-     */
-    addToolResult: chat.addToolOutput,
-    addToolOutput: chat.addToolOutput,
-    addToolApprovalResponse: chat.addToolApprovalResponse
-  };
+//#endregion
+//#region src/use-chat.ts
+const automaticResumeRegistrations = /* @__PURE__ */ new WeakMap();
+function registerAutomaticResume({ chat, registration }) {
+	let registrations = automaticResumeRegistrations.get(chat);
+	if (registrations == null) {
+		registrations = /* @__PURE__ */ new Set();
+		automaticResumeRegistrations.set(chat, registrations);
+	}
+	const shouldResume = registrations.size === 0;
+	registrations.add(registration);
+	if (shouldResume) chat.resumeStream();
+	return () => {
+		registrations.delete(registration);
+		if (registrations.size === 0) automaticResumeRegistrations.delete(chat);
+	};
 }
-
-// src/use-completion.ts
-import {
-  callCompletionApi
-} from "ai";
-import { normalizeHeaders as normalizeHeaders2 } from "@ai-sdk/provider-utils";
-import { useCallback as useCallback3, useEffect as useEffect2, useId as useId2, useRef as useRef3, useState as useState2 } from "react";
-import useSWR2 from "swr";
-function useCompletion({
-  api = "/api/completion",
-  id,
-  initialCompletion = "",
-  initialInput = "",
-  credentials,
-  headers,
-  body,
-  streamProtocol = "data",
-  fetch: fetch2,
-  onFinish,
-  onError,
-  throttle: throttleWait,
-  experimental_throttle
-} = {}) {
-  const throttleWaitMs = throttleWait ?? experimental_throttle;
-  const hookId = useId2();
-  const completionId = id || hookId;
-  const { data, mutate } = useSWR2([api, completionId], null, {
-    fallbackData: initialCompletion
-  });
-  const { data: isLoading = false, mutate: mutateLoading } = useSWR2(
-    [completionId, "loading"],
-    null
-  );
-  const [error, setError] = useState2(void 0);
-  const completion = data;
-  const abortControllerRef = useRef3(null);
-  const requestIdRef = useRef3(0);
-  const extraMetadataRef = useRef3({
-    credentials,
-    headers,
-    body
-  });
-  useEffect2(() => {
-    extraMetadataRef.current = {
-      credentials,
-      headers,
-      body
-    };
-  }, [credentials, headers, body]);
-  const triggerRequest = useCallback3(
-    async (prompt, options) => {
-      const requestId = ++requestIdRef.current;
-      return callCompletionApi({
-        api,
-        prompt,
-        credentials: extraMetadataRef.current.credentials,
-        headers: {
-          ...normalizeHeaders2(extraMetadataRef.current.headers),
-          ...normalizeHeaders2(options?.headers)
-        },
-        body: {
-          ...extraMetadataRef.current.body,
-          ...options?.body
-        },
-        streamProtocol,
-        fetch: fetch2,
-        // throttle streamed ui updates:
-        setCompletion: throttle((completion2) => {
-          if (requestIdRef.current === requestId) {
-            mutate(completion2, false);
-          }
-        }, throttleWaitMs),
-        setLoading: mutateLoading,
-        setError,
-        setAbortController: (controller) => {
-          abortControllerRef.current = controller;
-        },
-        getAbortController: () => abortControllerRef.current,
-        onFinish,
-        onError
-      });
-    },
-    [
-      mutate,
-      mutateLoading,
-      api,
-      extraMetadataRef,
-      onFinish,
-      onError,
-      setError,
-      streamProtocol,
-      fetch2,
-      throttleWaitMs
-    ]
-  );
-  const stop = useCallback3(() => {
-    abortControllerRef.current?.abort();
-  }, []);
-  const setCompletion = useCallback3(
-    (completion2) => {
-      mutate(completion2, false);
-    },
-    [mutate]
-  );
-  const complete = useCallback3(
-    async (prompt, options) => {
-      return triggerRequest(prompt, options);
-    },
-    [triggerRequest]
-  );
-  const [input, setInput] = useState2(initialInput);
-  const handleSubmit = useCallback3(
-    (event) => {
-      event?.preventDefault?.();
-      if (!input) {
-        return;
-      }
-      const result = complete(input);
-      setInput("");
-      return result;
-    },
-    [input, complete, setInput]
-  );
-  const handleInputChange = useCallback3(
-    (e) => {
-      setInput(e.target.value);
-    },
-    [setInput]
-  );
-  return {
-    completion,
-    complete,
-    error,
-    setCompletion,
-    stop,
-    input,
-    setInput,
-    handleInputChange,
-    handleSubmit,
-    isLoading
-  };
+function useChat({ throttle, experimental_throttle, resume = false, ...options } = {}) {
+	const throttleWaitMs = throttle ?? experimental_throttle;
+	const automaticResumeRegistration = useRef({});
+	const latestRef = useRef({});
+	if (!("chat" in options)) latestRef.current = {
+		onToolCall: options.onToolCall,
+		onData: options.onData,
+		onFinish: options.onFinish,
+		onError: options.onError,
+		sendAutomaticallyWhen: options.sendAutomaticallyWhen,
+		transport: options.transport
+	};
+	let defaultTransport;
+	const getTransport = () => latestRef.current.transport ?? (defaultTransport ??= new DefaultChatTransport());
+	const chatOptions = {
+		...options,
+		transport: {
+			sendMessages: (sendOptions) => getTransport().sendMessages(sendOptions),
+			reconnectToStream: (reconnectOptions) => getTransport().reconnectToStream(reconnectOptions)
+		},
+		onToolCall: (arg) => latestRef.current.onToolCall?.(arg),
+		onData: (arg) => latestRef.current.onData?.(arg),
+		onFinish: (arg) => latestRef.current.onFinish?.(arg),
+		onError: (arg) => latestRef.current.onError?.(arg),
+		sendAutomaticallyWhen: (arg) => latestRef.current.sendAutomaticallyWhen?.(arg) ?? false
+	};
+	const chatKey = "chat" in options ? options.chat : options.id;
+	const { chat, isExternallyManaged } = useMemo(() => ({
+		chat: "chat" in options ? options.chat : new Chat(chatOptions),
+		isExternallyManaged: "chat" in options
+	}), [chatKey]);
+	useEffect(() => {
+		if (isExternallyManaged) return;
+		return () => {
+			chat.stop();
+		};
+	}, [chat, isExternallyManaged]);
+	const messagesSnapshot = useMemo(() => ({ messages: chat.messages }), [chat]);
+	const subscribeToMessages = useCallback((update) => {
+		let isSubscribed = true;
+		const updateMessages = () => {
+			if (!isSubscribed) return;
+			messagesSnapshot.messages = chat.messages;
+			update();
+		};
+		const unsubscribe = chat["~registerMessagesCallback"](updateMessages, throttleWaitMs);
+		messagesSnapshot.messages = chat.messages;
+		return () => {
+			isSubscribed = false;
+			unsubscribe();
+		};
+	}, [
+		chat,
+		messagesSnapshot,
+		throttleWaitMs
+	]);
+	const getMessagesSnapshot = useCallback(() => messagesSnapshot.messages, [messagesSnapshot]);
+	const messages = useSyncExternalStore(subscribeToMessages, getMessagesSnapshot, getMessagesSnapshot);
+	const subscribeToStatus = useCallback((update) => chat["~registerStatusCallback"](() => {
+		if (chat.status === "ready" || chat.status === "error") messagesSnapshot.messages = chat.messages;
+		update();
+	}), [chat, messagesSnapshot]);
+	const getStatusSnapshot = useCallback(() => chat.status, [chat]);
+	const status = useSyncExternalStore(subscribeToStatus, getStatusSnapshot, getStatusSnapshot);
+	const error = useSyncExternalStore(chat["~registerErrorCallback"], () => chat.error, () => chat.error);
+	const setMessages = useCallback((messagesParam) => {
+		if (typeof messagesParam === "function") messagesParam = messagesParam(chat.messages);
+		chat.messages = messagesParam;
+	}, [chat]);
+	useEffect(() => {
+		if (resume) return registerAutomaticResume({
+			chat,
+			registration: automaticResumeRegistration.current
+		});
+	}, [resume, chat]);
+	return {
+		id: chat.id,
+		messages,
+		setMessages,
+		sendMessage: chat.sendMessage,
+		regenerate: chat.regenerate,
+		clearError: chat.clearError,
+		stop: chat.stop,
+		error,
+		resumeStream: chat.resumeStream,
+		status,
+		/**
+		* @deprecated Use `addToolOutput` instead.
+		*/
+		addToolResult: chat.addToolOutput,
+		addToolOutput: chat.addToolOutput,
+		addToolApprovalResponse: chat.addToolApprovalResponse
+	};
 }
-
-// src/use-realtime.ts
-import { secureJsonParse } from "@ai-sdk/provider-utils";
-import {
-  Experimental_AbstractRealtimeSession as AbstractRealtimeSession
-} from "ai";
-import {
-  useCallback as useCallback4,
-  useEffect as useEffect3,
-  useInsertionEffect,
-  useLayoutEffect,
-  useMemo as useMemo2,
-  useRef as useRef4,
-  useSyncExternalStore as useSyncExternalStore2
-} from "react";
-var useIsomorphicLayoutEffect = typeof window === "undefined" ? useEffect3 : useLayoutEffect;
-var RealtimeStore = /* @__PURE__ */ (() => class RealtimeStore extends AbstractRealtimeSession {
-  constructor() {
-    super(...arguments);
-    this.state = {
-      status: "disconnected",
-      messages: [],
-      events: [],
-      isCapturing: false,
-      isPlaying: false
-    };
-    this.callbacks = {
-      status: /* @__PURE__ */ new Set(),
-      messages: /* @__PURE__ */ new Set(),
-      events: /* @__PURE__ */ new Set(),
-      isCapturing: /* @__PURE__ */ new Set(),
-      isPlaying: /* @__PURE__ */ new Set(),
-      session: /* @__PURE__ */ new Set()
-    };
-  }
-  get status() {
-    return this.state.status;
-  }
-  get messages() {
-    return this.state.messages;
-  }
-  get events() {
-    return this.state.events;
-  }
-  get isCapturing() {
-    return this.state.isCapturing;
-  }
-  get isPlaying() {
-    return this.state.isPlaying;
-  }
-  get session() {
-    return this.state.session;
-  }
-  subscribe(key, onChange) {
-    this.callbacks[key].add(onChange);
-    return () => {
-      this.callbacks[key].delete(onChange);
-    };
-  }
-  setState(key, value) {
-    this.state = { ...this.state, [key]: value };
-    this.callbacks[key].forEach((callback) => callback());
-  }
+//#endregion
+//#region src/use-completion.ts
+function useCompletion({ api = "/api/completion", id, initialCompletion = "", initialInput = "", credentials, headers, body, streamProtocol = "data", fetch, onFinish, onError, throttle: throttleWait, experimental_throttle } = {}) {
+	const throttleWaitMs = throttleWait ?? experimental_throttle;
+	const hookId = useId();
+	const completionId = id || hookId;
+	const { data, mutate } = useSWR([api, completionId], null, { fallbackData: initialCompletion });
+	const { data: isLoading = false, mutate: mutateLoading } = useSWR([completionId, "loading"], null);
+	const [error, setError] = useState(void 0);
+	const completion = data;
+	const abortControllerRef = useRef(null);
+	const requestIdRef = useRef(0);
+	const extraMetadataRef = useRef({
+		credentials,
+		headers,
+		body
+	});
+	useEffect(() => {
+		extraMetadataRef.current = {
+			credentials,
+			headers,
+			body
+		};
+	}, [
+		credentials,
+		headers,
+		body
+	]);
+	const triggerRequest = useCallback(async (prompt, options) => {
+		const requestId = ++requestIdRef.current;
+		return callCompletionApi({
+			api,
+			prompt,
+			credentials: extraMetadataRef.current.credentials,
+			headers: {
+				...normalizeHeaders(extraMetadataRef.current.headers),
+				...normalizeHeaders(options?.headers)
+			},
+			body: {
+				...extraMetadataRef.current.body,
+				...options?.body
+			},
+			streamProtocol,
+			fetch,
+			setCompletion: throttle((completion) => {
+				if (requestIdRef.current === requestId) mutate(completion, false);
+			}, throttleWaitMs),
+			setLoading: mutateLoading,
+			setError,
+			setAbortController: (controller) => {
+				abortControllerRef.current = controller;
+			},
+			getAbortController: () => abortControllerRef.current,
+			onFinish,
+			onError
+		});
+	}, [
+		mutate,
+		mutateLoading,
+		api,
+		extraMetadataRef,
+		onFinish,
+		onError,
+		setError,
+		streamProtocol,
+		fetch,
+		throttleWaitMs
+	]);
+	const stop = useCallback(() => {
+		abortControllerRef.current?.abort();
+	}, []);
+	const setCompletion = useCallback((completion) => {
+		mutate(completion, false);
+	}, [mutate]);
+	const complete = useCallback(async (prompt, options) => {
+		return triggerRequest(prompt, options);
+	}, [triggerRequest]);
+	const [input, setInput] = useState(initialInput);
+	const handleSubmit = useCallback((event) => {
+		event?.preventDefault?.();
+		if (!input) return;
+		const result = complete(input);
+		setInput("");
+		return result;
+	}, [
+		input,
+		complete,
+		setInput
+	]);
+	return {
+		completion,
+		complete,
+		error,
+		setCompletion,
+		stop,
+		input,
+		setInput,
+		handleInputChange: useCallback((e) => {
+			setInput(e.target.value);
+		}, [setInput]),
+		handleSubmit,
+		isLoading
+	};
+}
+//#endregion
+//#region src/use-realtime.ts
+const useIsomorphicLayoutEffect = typeof window === "undefined" ? useEffect : useLayoutEffect;
+const RealtimeStore = /* @__PURE__ */ (() => class RealtimeStore extends Experimental_AbstractRealtimeSession {
+	constructor(..._args) {
+		super(..._args);
+		this.state = {
+			status: "disconnected",
+			messages: [],
+			events: [],
+			isCapturing: false,
+			isPlaying: false
+		};
+		this.callbacks = {
+			status: /* @__PURE__ */ new Set(),
+			messages: /* @__PURE__ */ new Set(),
+			events: /* @__PURE__ */ new Set(),
+			isCapturing: /* @__PURE__ */ new Set(),
+			isPlaying: /* @__PURE__ */ new Set(),
+			session: /* @__PURE__ */ new Set()
+		};
+	}
+	get status() {
+		return this.state.status;
+	}
+	get messages() {
+		return this.state.messages;
+	}
+	get events() {
+		return this.state.events;
+	}
+	get isCapturing() {
+		return this.state.isCapturing;
+	}
+	get isPlaying() {
+		return this.state.isPlaying;
+	}
+	get session() {
+		return this.state.session;
+	}
+	subscribe(key, onChange) {
+		this.callbacks[key].add(onChange);
+		return () => {
+			this.callbacks[key].delete(onChange);
+		};
+	}
+	setState(key, value) {
+		this.state = {
+			...this.state,
+			[key]: value
+		};
+		this.callbacks[key].forEach((callback) => callback());
+	}
 })();
 function useRealtime(options) {
-  const ownerRef = useRef4(null);
-  const {
-    model,
-    api,
-    startupTimeoutMs,
-    closeTimeoutMs,
-    rtcDisconnectTimeoutMs,
-    sessionConfig,
-    sampleRate,
-    maxEvents,
-    maxPlaybackBufferSeconds,
-    onToolCall,
-    onEvent,
-    onError
-  } = options;
-  const { token, websocket, session: sessionEndpoint } = api;
-  const protocols = JSON.stringify(api.protocols ?? []);
-  const rt = useMemo2(() => {
-    const store = new RealtimeStore({
-      model,
-      api: token != null ? { token } : sessionEndpoint != null ? { session: sessionEndpoint } : {
-        websocket,
-        protocols: secureJsonParse(protocols)
-      },
-      startupTimeoutMs,
-      closeTimeoutMs,
-      rtcDisconnectTimeoutMs,
-      sessionConfig,
-      sampleRate,
-      maxEvents,
-      maxPlaybackBufferSeconds,
-      onEvent: (...args) => ownerRef.current?.store === store ? ownerRef.current.onEvent?.(...args) : void 0,
-      onError: (...args) => ownerRef.current?.store === store ? ownerRef.current.onError?.(...args) : void 0
-    });
-    return store;
-  }, [
-    model,
-    token,
-    sessionEndpoint,
-    websocket,
-    protocols,
-    startupTimeoutMs,
-    closeTimeoutMs,
-    rtcDisconnectTimeoutMs,
-    sessionConfig,
-    sampleRate,
-    maxEvents,
-    maxPlaybackBufferSeconds
-  ]);
-  useInsertionEffect(() => {
-    ownerRef.current = { store: rt, onToolCall, onEvent, onError };
-    rt.onToolCall = onToolCall == null ? void 0 : (...args) => ownerRef.current?.store === rt ? ownerRef.current.onToolCall?.(...args) : void 0;
-    return () => {
-      ownerRef.current = null;
-    };
-  });
-  useIsomorphicLayoutEffect(() => {
-    return () => rt.dispose();
-  }, [rt]);
-  const actions = useMemo2(() => {
-    const current = () => {
-      if (ownerRef.current == null)
-        throw new Error("Realtime controls require a mounted hook");
-      return ownerRef.current.store;
-    };
-    return {
-      connect: async (options2) => {
-        const store = current();
-        return options2 == null ? store.connect() : store.connect(options2);
-      },
-      close: async (options2) => current().close(options2),
-      resumePlayback: async () => current().resumePlayback(),
-      resumeAudioCapture: async () => current().resumeAudioCapture(),
-      disconnect: () => current().disconnect(),
-      addToolOutput: (callId, result) => current().addToolOutput(callId, result),
-      sendEvent: (event) => current().sendEvent(event),
-      sendTextMessage: (text) => current().sendTextMessage(text),
-      sendAudio: (audio) => current().sendAudio(audio),
-      commitAudio: () => current().commitAudio(),
-      clearAudioBuffer: () => current().clearAudioBuffer(),
-      requestResponse: (options2) => current().requestResponse(options2),
-      cancelResponse: () => current().cancelResponse(),
-      startAudioCapture: (stream) => current().startAudioCapture(stream),
-      stopAudioCapture: () => current().stopAudioCapture(),
-      stopPlayback: () => current().stopPlayback()
-    };
-  }, []);
-  const status = useSyncExternalStore2(
-    useCallback4((cb) => rt.subscribe("status", cb), [rt]),
-    () => rt.status,
-    () => rt.status
-  );
-  const messages = useSyncExternalStore2(
-    useCallback4((cb) => rt.subscribe("messages", cb), [rt]),
-    () => rt.messages,
-    () => rt.messages
-  );
-  const events = useSyncExternalStore2(
-    useCallback4((cb) => rt.subscribe("events", cb), [rt]),
-    () => rt.events,
-    () => rt.events
-  );
-  const isCapturing = useSyncExternalStore2(
-    useCallback4((cb) => rt.subscribe("isCapturing", cb), [rt]),
-    () => rt.isCapturing,
-    () => rt.isCapturing
-  );
-  const isPlaying = useSyncExternalStore2(
-    useCallback4((cb) => rt.subscribe("isPlaying", cb), [rt]),
-    () => rt.isPlaying,
-    () => rt.isPlaying
-  );
-  const session = useSyncExternalStore2(
-    useCallback4((cb) => rt.subscribe("session", cb), [rt]),
-    () => rt.session,
-    () => rt.session
-  );
-  return {
-    status,
-    messages,
-    events,
-    isCapturing,
-    isPlaying,
-    session,
-    ...actions
-  };
+	const ownerRef = useRef(null);
+	const { model, api, startupTimeoutMs, closeTimeoutMs, rtcDisconnectTimeoutMs, sessionConfig, sampleRate, maxEvents, maxPlaybackBufferSeconds, onToolCall, onEvent, onError } = options;
+	const { token, websocket, session: sessionEndpoint } = api;
+	const protocols = JSON.stringify(api.protocols ?? []);
+	const rt = useMemo(() => {
+		const store = new RealtimeStore({
+			model,
+			api: token != null ? { token } : sessionEndpoint != null ? { session: sessionEndpoint } : {
+				websocket,
+				protocols: secureJsonParse(protocols)
+			},
+			startupTimeoutMs,
+			closeTimeoutMs,
+			rtcDisconnectTimeoutMs,
+			sessionConfig,
+			sampleRate,
+			maxEvents,
+			maxPlaybackBufferSeconds,
+			onEvent: (...args) => ownerRef.current?.store === store ? ownerRef.current.onEvent?.(...args) : void 0,
+			onError: (...args) => ownerRef.current?.store === store ? ownerRef.current.onError?.(...args) : void 0
+		});
+		return store;
+	}, [
+		model,
+		token,
+		sessionEndpoint,
+		websocket,
+		protocols,
+		startupTimeoutMs,
+		closeTimeoutMs,
+		rtcDisconnectTimeoutMs,
+		sessionConfig,
+		sampleRate,
+		maxEvents,
+		maxPlaybackBufferSeconds
+	]);
+	useInsertionEffect(() => {
+		ownerRef.current = {
+			store: rt,
+			onToolCall,
+			onEvent,
+			onError
+		};
+		rt.onToolCall = onToolCall == null ? void 0 : (...args) => ownerRef.current?.store === rt ? ownerRef.current.onToolCall?.(...args) : void 0;
+		return () => {
+			ownerRef.current = null;
+		};
+	});
+	useIsomorphicLayoutEffect(() => {
+		return () => rt.dispose();
+	}, [rt]);
+	const actions = useMemo(() => {
+		const current = () => {
+			if (ownerRef.current == null) throw new Error("Realtime controls require a mounted hook");
+			return ownerRef.current.store;
+		};
+		return {
+			connect: async (options) => {
+				const store = current();
+				return options == null ? store.connect() : store.connect(options);
+			},
+			close: async (options) => current().close(options),
+			resumePlayback: async () => current().resumePlayback(),
+			resumeAudioCapture: async () => current().resumeAudioCapture(),
+			disconnect: () => current().disconnect(),
+			addToolOutput: (callId, result) => current().addToolOutput(callId, result),
+			sendEvent: (event) => current().sendEvent(event),
+			sendTextMessage: (text) => current().sendTextMessage(text),
+			sendAudio: (audio) => current().sendAudio(audio),
+			commitAudio: () => current().commitAudio(),
+			clearAudioBuffer: () => current().clearAudioBuffer(),
+			requestResponse: (options) => current().requestResponse(options),
+			cancelResponse: () => current().cancelResponse(),
+			startAudioCapture: (stream) => current().startAudioCapture(stream),
+			stopAudioCapture: () => current().stopAudioCapture(),
+			stopPlayback: () => current().stopPlayback()
+		};
+	}, []);
+	return {
+		status: useSyncExternalStore(useCallback((cb) => rt.subscribe("status", cb), [rt]), () => rt.status, () => rt.status),
+		messages: useSyncExternalStore(useCallback((cb) => rt.subscribe("messages", cb), [rt]), () => rt.messages, () => rt.messages),
+		events: useSyncExternalStore(useCallback((cb) => rt.subscribe("events", cb), [rt]), () => rt.events, () => rt.events),
+		isCapturing: useSyncExternalStore(useCallback((cb) => rt.subscribe("isCapturing", cb), [rt]), () => rt.isCapturing, () => rt.isCapturing),
+		isPlaying: useSyncExternalStore(useCallback((cb) => rt.subscribe("isPlaying", cb), [rt]), () => rt.isPlaying, () => rt.isPlaying),
+		session: useSyncExternalStore(useCallback((cb) => rt.subscribe("session", cb), [rt]), () => rt.session, () => rt.session),
+		...actions
+	};
 }
-var experimental_useRealtime = useRealtime;
-
-// src/mcp-apps/app-renderer.tsx
-import { useEffect as useEffect5, useState as useState3 } from "react";
-
-// src/mcp-apps/app-frame.tsx
-import { useEffect as useEffect4, useMemo as useMemo3, useRef as useRef5 } from "react";
-
-// src/mcp-apps/bridge.ts
-import { isJSONObject } from "@ai-sdk/provider";
-var MCP_APP_PROTOCOL_VERSION = "2026-01-26";
+const experimental_useRealtime = useRealtime;
+//#endregion
+//#region src/mcp-apps/bridge.ts
+const MCP_APP_PROTOCOL_VERSION = "2026-01-26";
+/**
+* Checks whether an iframe message looks like a JSON-RPC 2.0 message.
+*/
 function isJsonRpcMessage(value) {
-  return value != null && typeof value === "object" && !Array.isArray(value) && "jsonrpc" in value && value.jsonrpc === "2.0";
+	return value != null && typeof value === "object" && !Array.isArray(value) && "jsonrpc" in value && value.jsonrpc === "2.0";
 }
+/**
+* Checks whether a JSON-RPC message expects a response.
+*/
 function isRequest(message) {
-  return "method" in message && "id" in message;
+	return "method" in message && "id" in message;
 }
+/**
+* Checks whether a JSON-RPC message is a fire-and-forget notification.
+*/
 function isNotification(message) {
-  return "method" in message && !("id" in message);
+	return "method" in message && !("id" in message);
 }
+/**
+* Normalizes unknown thrown values into an `Error`.
+*/
 function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
+	return error instanceof Error ? error : new Error(String(error));
 }
+/**
+* Validates the params for app-initiated `tools/call` requests.
+*/
 function assertToolCallParams(params) {
-  if (!isJSONObject(params) || typeof params.name !== "string") {
-    throw new Error("Invalid tools/call params");
-  }
-  return {
-    name: params.name,
-    arguments: isJSONObject(params.arguments) ? params.arguments : void 0
-  };
+	if (!isJSONObject(params) || typeof params.name !== "string") throw new Error("Invalid tools/call params");
+	return {
+		name: params.name,
+		arguments: isJSONObject(params.arguments) ? params.arguments : void 0
+	};
 }
+/**
+* Validates `resources/read` params and limits reads to `ui://` app resources.
+*/
 function assertResourceReadParams(params) {
-  if (!isJSONObject(params) || typeof params.uri !== "string") {
-    throw new Error("Invalid resources/read params");
-  }
-  if (!params.uri.startsWith("ui://")) {
-    throw new Error(
-      `resources/read is limited to ui:// resources: ${params.uri}`
-    );
-  }
-  return { uri: params.uri };
+	if (!isJSONObject(params) || typeof params.uri !== "string") throw new Error("Invalid resources/read params");
+	if (!params.uri.startsWith("ui://")) throw new Error(`resources/read is limited to ui:// resources: ${params.uri}`);
+	return { uri: params.uri };
 }
+/**
+* Validates `ui/open-link` params and allows only `https:`/`http:`/`mailto:`
+* URLs.
+*/
 function assertOpenLinkParams(params) {
-  if (!isJSONObject(params) || typeof params.url !== "string") {
-    throw new Error("Invalid ui/open-link params");
-  }
-  let scheme;
-  try {
-    scheme = new URL(params.url).protocol;
-  } catch {
-    throw new Error(`Invalid ui/open-link url: ${params.url}`);
-  }
-  if (scheme !== "https:" && scheme !== "http:" && scheme !== "mailto:") {
-    throw new Error(`Disallowed ui/open-link scheme: ${scheme}`);
-  }
-  return { url: params.url };
+	if (!isJSONObject(params) || typeof params.url !== "string") throw new Error("Invalid ui/open-link params");
+	let scheme;
+	try {
+		scheme = new URL(params.url).protocol;
+	} catch {
+		throw new Error(`Invalid ui/open-link url: ${params.url}`);
+	}
+	if (scheme !== "https:" && scheme !== "http:" && scheme !== "mailto:") throw new Error(`Disallowed ui/open-link scheme: ${scheme}`);
+	return { url: params.url };
 }
+/**
+* Validates params for `ui/request-display-mode`.
+*/
 function assertDisplayModeParams(params) {
-  if (!isJSONObject(params) || params.mode !== "inline" && params.mode !== "fullscreen" && params.mode !== "pip") {
-    throw new Error("Invalid ui/request-display-mode params");
-  }
-  return { mode: params.mode };
+	if (!isJSONObject(params) || params.mode !== "inline" && params.mode !== "fullscreen" && params.mode !== "pip") throw new Error("Invalid ui/request-display-mode params");
+	return { mode: params.mode };
 }
+/**
+* Host-side JSON-RPC bridge for one MCP App iframe.
+*
+* It handles the MCP Apps initialization handshake, sends tool input/result
+* notifications to the iframe, and proxies allowed iframe requests through
+* host-provided callbacks.
+*
+* @example
+* ```ts
+* const bridge = new MCPAppBridge({
+*   targetWindow: iframe.contentWindow!,
+*   handlers: {
+*     allowedTools: ['refreshDashboardData'],
+*     callTool: params => client.callTool(params),
+*   },
+* });
+*
+* window.addEventListener('message', event => bridge.handleMessage(event));
+* bridge.sendToolInput({ topic: 'usage' });
+* ```
+*/
 var MCPAppBridge = class {
-  constructor({
-    targetWindow,
-    targetOrigin = "*",
-    handlers = {},
-    hostInfo = { name: "ai-sdk-react", version: "1.0.0" },
-    hostContext = { displayMode: "inline" }
-  }) {
-    this.initialized = false;
-    this.pendingNotifications = [];
-    this.nextRequestId = 0;
-    this.pendingResponses = /* @__PURE__ */ new Map();
-    this.targetWindow = targetWindow;
-    this.targetOrigin = targetOrigin;
-    this.handlers = handlers;
-    this.hostInfo = hostInfo;
-    this.hostContext = hostContext;
-  }
-  /**
-   * Replaces the callbacks used to serve iframe requests.
-   */
-  setHandlers(handlers) {
-    this.handlers = handlers;
-  }
-  /**
-   * Updates host context and notifies the iframe after initialization.
-   *
-   * @example
-   * ```ts
-   * bridge.setHostContext({ theme: 'dark', displayMode: 'inline' });
-   * ```
-   */
-  setHostContext(hostContext) {
-    this.hostContext = hostContext;
-    this.sendNotification({
-      method: "ui/notifications/host-context-changed",
-      params: hostContext
-    });
-  }
-  /**
-   * Whether a `message` event came from the expected proxy window and origin.
-   * The origin check is skipped only when `targetOrigin` is the `'*'` default.
-   * Callers that intercept events before {@link handleMessage} share this check.
-   */
-  acceptsEvent(event) {
-    return event.source === this.targetWindow && (this.targetOrigin === "*" || event.origin === this.targetOrigin);
-  }
-  /**
-   * Processes one `message` event from the sandbox proxy iframe.
-   */
-  handleMessage(event) {
-    if (!this.acceptsEvent(event) || !isJsonRpcMessage(event.data)) {
-      return;
-    }
-    const message = event.data;
-    if ("result" in message || "error" in message) {
-      this.handleResponse(message);
-      return;
-    }
-    if (isRequest(message)) {
-      void this.handleRequest(message);
-      return;
-    }
-    if (isNotification(message)) {
-      this.handleNotification(message);
-    }
-  }
-  /**
-   * Sends app HTML and sandbox settings to the sandbox proxy.
-   */
-  sendSandboxResourceReady(params) {
-    this.post({
-      jsonrpc: "2.0",
-      method: "ui/notifications/sandbox-resource-ready",
-      params
-    });
-  }
-  /**
-   * Sends final tool arguments to the MCP App.
-   */
-  sendToolInput(input) {
-    this.sendNotification({
-      method: "ui/notifications/tool-input",
-      params: { arguments: input }
-    });
-  }
-  /**
-   * Sends a completed MCP tool result to the MCP App.
-   */
-  sendToolResult(result) {
-    this.sendNotification({
-      method: "ui/notifications/tool-result",
-      params: result
-    });
-  }
-  /**
-   * Notifies the MCP App that the related tool call was cancelled.
-   */
-  sendToolCancelled(reason) {
-    this.sendNotification({
-      method: "ui/notifications/tool-cancelled",
-      params: reason != null ? { reason } : {}
-    });
-  }
-  /**
-   * Requests graceful teardown before the host removes the iframe.
-   */
-  teardownResource() {
-    return this.request("ui/resource-teardown", {});
-  }
-  /**
-   * Rejects pending bridge requests and clears queued notifications.
-   */
-  close() {
-    for (const pending of this.pendingResponses.values()) {
-      pending.reject(new Error("MCP App bridge closed"));
-    }
-    this.pendingResponses.clear();
-    this.pendingNotifications = [];
-  }
-  /**
-   * Resolves or rejects a host-initiated request when the iframe responds.
-   */
-  handleResponse(response) {
-    const pending = this.pendingResponses.get(response.id);
-    if (pending == null) {
-      return;
-    }
-    this.pendingResponses.delete(response.id);
-    if (response.error != null) {
-      pending.reject(new Error(response.error.message));
-    } else {
-      pending.resolve(response.result);
-    }
-  }
-  /**
-   * Runs a handler for an iframe request and posts the JSON-RPC response.
-   */
-  async handleRequest(request) {
-    try {
-      const result = await this.getRequestResult(request);
-      this.post({ jsonrpc: "2.0", id: request.id, result });
-    } catch (error) {
-      const normalizedError = toError(error);
-      this.handlers.onError?.(normalizedError);
-      this.post({
-        jsonrpc: "2.0",
-        id: request.id,
-        error: { code: -32603, message: normalizedError.message }
-      });
-    }
-  }
-  /**
-   * Maps supported iframe request methods to host callbacks.
-   */
-  async getRequestResult(request) {
-    switch (request.method) {
-      case "ui/initialize":
-        return {
-          protocolVersion: MCP_APP_PROTOCOL_VERSION,
-          hostCapabilities: {
-            ...this.handlers.callTool != null ? { serverTools: {} } : {},
-            ...this.handlers.readResource != null ? { serverResources: {} } : {},
-            ...this.handlers.onLog != null ? { logging: {} } : {}
-          },
-          hostInfo: this.hostInfo,
-          hostContext: this.hostContext
-        };
-      case "tools/call": {
-        if (this.handlers.callTool == null) {
-          throw new Error("No tools/call handler configured");
-        }
-        const params = assertToolCallParams(request.params);
-        if (this.handlers.allowedTools == null || !this.handlers.allowedTools.includes(params.name)) {
-          throw new Error(`Tool is not app-visible: ${params.name}`);
-        }
-        return this.handlers.callTool(params);
-      }
-      case "resources/read":
-        if (this.handlers.readResource == null) {
-          throw new Error("No resources/read handler configured");
-        }
-        return this.handlers.readResource(
-          assertResourceReadParams(request.params)
-        );
-      case "resources/list":
-        if (this.handlers.listResources == null) {
-          throw new Error("No resources/list handler configured");
-        }
-        return this.handlers.listResources(request.params);
-      case "ui/open-link":
-        if (this.handlers.openLink == null) {
-          throw new Error("No ui/open-link handler configured");
-        }
-        return this.handlers.openLink(assertOpenLinkParams(request.params));
-      case "ui/message":
-        return this.handlers.sendMessage?.(request.params) ?? {};
-      case "ui/update-model-context":
-        return this.handlers.updateModelContext?.(request.params) ?? {};
-      case "ui/request-display-mode":
-        return this.handlers.requestDisplayMode?.(
-          assertDisplayModeParams(request.params)
-        ) ?? { mode: this.hostContext.displayMode ?? "inline" };
-      default:
-        throw new Error(`Unsupported MCP App method: ${request.method}`);
-    }
-  }
-  /**
-   * Handles iframe lifecycle and telemetry notifications.
-   */
-  handleNotification(notification) {
-    switch (notification.method) {
-      case "ui/notifications/initialized":
-        this.initialized = true;
-        this.flushNotifications();
-        this.handlers.onInitialized?.();
-        break;
-      case "ui/notifications/size-changed":
-        this.handlers.onSizeChange?.(
-          notification.params
-        );
-        break;
-      case "ui/notifications/request-teardown":
-        this.handlers.onRequestTeardown?.(notification.params);
-        break;
-      case "notifications/message":
-        this.handlers.onLog?.(notification.params);
-        break;
-    }
-  }
-  /**
-   * Sends a host-to-iframe notification, queueing it until app initialization.
-   */
-  sendNotification(notification) {
-    const message = { jsonrpc: "2.0", ...notification };
-    if (!this.initialized && !notification.method.includes("sandbox")) {
-      this.pendingNotifications.push(message);
-      return;
-    }
-    this.post(message);
-  }
-  /**
-   * Sends notifications that were queued before `ui/notifications/initialized`.
-   */
-  flushNotifications() {
-    const notifications = this.pendingNotifications;
-    this.pendingNotifications = [];
-    for (const notification of notifications) {
-      this.post(notification);
-    }
-  }
-  /**
-   * Sends a host-initiated JSON-RPC request to the iframe.
-   */
-  request(method, params) {
-    const id = this.nextRequestId++;
-    this.post({ jsonrpc: "2.0", id, method, params });
-    return new Promise((resolve2, reject) => {
-      this.pendingResponses.set(id, { resolve: resolve2, reject });
-    });
-  }
-  /**
-   * Posts a JSON-RPC message to the sandbox proxy iframe.
-   */
-  post(message) {
-    this.targetWindow.postMessage(message, this.targetOrigin);
-  }
+	constructor({ targetWindow, targetOrigin = "*", handlers = {}, hostInfo = {
+		name: "ai-sdk-react",
+		version: "1.0.0"
+	}, hostContext = { displayMode: "inline" } }) {
+		this.initialized = false;
+		this.pendingNotifications = [];
+		this.nextRequestId = 0;
+		this.pendingResponses = /* @__PURE__ */ new Map();
+		this.targetWindow = targetWindow;
+		this.targetOrigin = targetOrigin;
+		this.handlers = handlers;
+		this.hostInfo = hostInfo;
+		this.hostContext = hostContext;
+	}
+	/**
+	* Replaces the callbacks used to serve iframe requests.
+	*/
+	setHandlers(handlers) {
+		this.handlers = handlers;
+	}
+	/**
+	* Updates host context and notifies the iframe after initialization.
+	*
+	* @example
+	* ```ts
+	* bridge.setHostContext({ theme: 'dark', displayMode: 'inline' });
+	* ```
+	*/
+	setHostContext(hostContext) {
+		this.hostContext = hostContext;
+		this.sendNotification({
+			method: "ui/notifications/host-context-changed",
+			params: hostContext
+		});
+	}
+	/**
+	* Whether a `message` event came from the expected proxy window and origin.
+	* The origin check is skipped only when `targetOrigin` is the `'*'` default.
+	* Callers that intercept events before {@link handleMessage} share this check.
+	*/
+	acceptsEvent(event) {
+		return event.source === this.targetWindow && (this.targetOrigin === "*" || event.origin === this.targetOrigin);
+	}
+	/**
+	* Processes one `message` event from the sandbox proxy iframe.
+	*/
+	handleMessage(event) {
+		if (!this.acceptsEvent(event) || !isJsonRpcMessage(event.data)) return;
+		const message = event.data;
+		if ("result" in message || "error" in message) {
+			this.handleResponse(message);
+			return;
+		}
+		if (isRequest(message)) {
+			this.handleRequest(message);
+			return;
+		}
+		if (isNotification(message)) this.handleNotification(message);
+	}
+	/**
+	* Sends app HTML and sandbox settings to the sandbox proxy.
+	*/
+	sendSandboxResourceReady(params) {
+		this.post({
+			jsonrpc: "2.0",
+			method: "ui/notifications/sandbox-resource-ready",
+			params
+		});
+	}
+	/**
+	* Sends final tool arguments to the MCP App.
+	*/
+	sendToolInput(input) {
+		this.sendNotification({
+			method: "ui/notifications/tool-input",
+			params: { arguments: input }
+		});
+	}
+	/**
+	* Sends a completed MCP tool result to the MCP App.
+	*/
+	sendToolResult(result) {
+		this.sendNotification({
+			method: "ui/notifications/tool-result",
+			params: result
+		});
+	}
+	/**
+	* Notifies the MCP App that the related tool call was cancelled.
+	*/
+	sendToolCancelled(reason) {
+		this.sendNotification({
+			method: "ui/notifications/tool-cancelled",
+			params: reason != null ? { reason } : {}
+		});
+	}
+	/**
+	* Requests graceful teardown before the host removes the iframe.
+	*/
+	teardownResource() {
+		return this.request("ui/resource-teardown", {});
+	}
+	/**
+	* Rejects pending bridge requests and clears queued notifications.
+	*/
+	close() {
+		for (const pending of this.pendingResponses.values()) pending.reject(/* @__PURE__ */ new Error("MCP App bridge closed"));
+		this.pendingResponses.clear();
+		this.pendingNotifications = [];
+	}
+	/**
+	* Resolves or rejects a host-initiated request when the iframe responds.
+	*/
+	handleResponse(response) {
+		const pending = this.pendingResponses.get(response.id);
+		if (pending == null) return;
+		this.pendingResponses.delete(response.id);
+		if (response.error != null) pending.reject(new Error(response.error.message));
+		else pending.resolve(response.result);
+	}
+	/**
+	* Runs a handler for an iframe request and posts the JSON-RPC response.
+	*/
+	async handleRequest(request) {
+		try {
+			const result = await this.getRequestResult(request);
+			this.post({
+				jsonrpc: "2.0",
+				id: request.id,
+				result
+			});
+		} catch (error) {
+			const normalizedError = toError(error);
+			this.handlers.onError?.(normalizedError);
+			this.post({
+				jsonrpc: "2.0",
+				id: request.id,
+				error: {
+					code: -32603,
+					message: normalizedError.message
+				}
+			});
+		}
+	}
+	/**
+	* Maps supported iframe request methods to host callbacks.
+	*/
+	async getRequestResult(request) {
+		switch (request.method) {
+			case "ui/initialize": return {
+				protocolVersion: MCP_APP_PROTOCOL_VERSION,
+				hostCapabilities: {
+					...this.handlers.callTool != null ? { serverTools: {} } : {},
+					...this.handlers.readResource != null ? { serverResources: {} } : {},
+					...this.handlers.onLog != null ? { logging: {} } : {}
+				},
+				hostInfo: this.hostInfo,
+				hostContext: this.hostContext
+			};
+			case "tools/call": {
+				if (this.handlers.callTool == null) throw new Error("No tools/call handler configured");
+				const params = assertToolCallParams(request.params);
+				if (this.handlers.allowedTools == null || !this.handlers.allowedTools.includes(params.name)) throw new Error(`Tool is not app-visible: ${params.name}`);
+				return this.handlers.callTool(params);
+			}
+			case "resources/read":
+				if (this.handlers.readResource == null) throw new Error("No resources/read handler configured");
+				return this.handlers.readResource(assertResourceReadParams(request.params));
+			case "resources/list":
+				if (this.handlers.listResources == null) throw new Error("No resources/list handler configured");
+				return this.handlers.listResources(request.params);
+			case "ui/open-link":
+				if (this.handlers.openLink == null) throw new Error("No ui/open-link handler configured");
+				return this.handlers.openLink(assertOpenLinkParams(request.params));
+			case "ui/message": return this.handlers.sendMessage?.(request.params) ?? {};
+			case "ui/update-model-context": return this.handlers.updateModelContext?.(request.params) ?? {};
+			case "ui/request-display-mode": return this.handlers.requestDisplayMode?.(assertDisplayModeParams(request.params)) ?? { mode: this.hostContext.displayMode ?? "inline" };
+			default: throw new Error(`Unsupported MCP App method: ${request.method}`);
+		}
+	}
+	/**
+	* Handles iframe lifecycle and telemetry notifications.
+	*/
+	handleNotification(notification) {
+		switch (notification.method) {
+			case "ui/notifications/initialized":
+				this.initialized = true;
+				this.flushNotifications();
+				this.handlers.onInitialized?.();
+				break;
+			case "ui/notifications/size-changed":
+				this.handlers.onSizeChange?.(notification.params);
+				break;
+			case "ui/notifications/request-teardown":
+				this.handlers.onRequestTeardown?.(notification.params);
+				break;
+			case "notifications/message": this.handlers.onLog?.(notification.params);
+		}
+	}
+	/**
+	* Sends a host-to-iframe notification, queueing it until app initialization.
+	*/
+	sendNotification(notification) {
+		const message = {
+			jsonrpc: "2.0",
+			...notification
+		};
+		if (!this.initialized && !notification.method.includes("sandbox")) {
+			this.pendingNotifications.push(message);
+			return;
+		}
+		this.post(message);
+	}
+	/**
+	* Sends notifications that were queued before `ui/notifications/initialized`.
+	*/
+	flushNotifications() {
+		const notifications = this.pendingNotifications;
+		this.pendingNotifications = [];
+		for (const notification of notifications) this.post(notification);
+	}
+	/**
+	* Sends a host-initiated JSON-RPC request to the iframe.
+	*/
+	request(method, params) {
+		const id = this.nextRequestId++;
+		this.post({
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		});
+		return new Promise((resolve, reject) => {
+			this.pendingResponses.set(id, {
+				resolve,
+				reject
+			});
+		});
+	}
+	/**
+	* Posts a JSON-RPC message to the sandbox proxy iframe.
+	*/
+	post(message) {
+		this.targetWindow.postMessage(message, this.targetOrigin);
+	}
 };
-
-// src/mcp-apps/sandbox.ts
-var ALLOWED_CSP_SCHEMES = /* @__PURE__ */ new Set(["https:", "wss:"]);
+//#endregion
+//#region src/mcp-apps/sandbox.ts
+const ALLOWED_CSP_SCHEMES = /* @__PURE__ */ new Set(["https:", "wss:"]);
 function sanitizeCSPSources(sources) {
-  const result = [];
-  for (const source of sources ?? []) {
-    if (typeof source !== "string") {
-      continue;
-    }
-    let origin;
-    try {
-      const url = new URL(source);
-      if (!ALLOWED_CSP_SCHEMES.has(url.protocol) || url.host.length === 0 || url.host === "*") {
-        continue;
-      }
-      origin = url.origin;
-    } catch {
-      continue;
-    }
-    if (/["'`\s;,]/.test(origin)) {
-      continue;
-    }
-    result.push(origin);
-  }
-  return result;
+	const result = [];
+	for (const source of sources ?? []) {
+		if (typeof source !== "string") continue;
+		let origin;
+		try {
+			const url = new URL(source);
+			if (!ALLOWED_CSP_SCHEMES.has(url.protocol) || url.host.length === 0 || url.host === "*") continue;
+			origin = url.origin;
+		} catch {
+			continue;
+		}
+		if (/["'`\s;,]/.test(origin)) continue;
+		result.push(origin);
+	}
+	return result;
 }
-var MCP_APP_DEFAULT_OUTER_SANDBOX = "allow-scripts allow-same-origin allow-forms";
-var MCP_APP_DEFAULT_INNER_SANDBOX = "allow-scripts allow-forms";
+/**
+* Converts MCP App CSP metadata into a Content-Security-Policy string.
+*
+* The returned value is meant to be passed to a sandbox proxy, which can apply
+* it to the inner iframe document.
+*
+* @example
+* ```ts
+* const csp = getMCPAppCSP({
+*   connectDomains: ['https://api.example.com'],
+*   resourceDomains: ['https://cdn.example.com'],
+* });
+* ```
+*/
 function getMCPAppCSP(csp) {
-  if (csp == null) {
-    return void 0;
-  }
-  const connectSrc = ["'self'", ...sanitizeCSPSources(csp.connectDomains)];
-  const imgSrc = [
-    "'self'",
-    "data:",
-    ...sanitizeCSPSources(csp.resourceDomains)
-  ];
-  const frameSrc = ["'self'", ...sanitizeCSPSources(csp.frameDomains)];
-  return [
-    "default-src 'none'",
-    "base-uri 'none'",
-    "form-action 'none'",
-    "script-src 'unsafe-inline'",
-    "style-src 'unsafe-inline'",
-    `connect-src ${connectSrc.join(" ")}`,
-    `img-src ${imgSrc.join(" ")}`,
-    `font-src ${imgSrc.join(" ")}`,
-    `frame-src ${frameSrc.join(" ")}`
-  ].join("; ");
+	if (csp == null) return;
+	const connectSrc = ["'self'", ...sanitizeCSPSources(csp.connectDomains)];
+	const imgSrc = [
+		"'self'",
+		"data:",
+		...sanitizeCSPSources(csp.resourceDomains)
+	];
+	const frameSrc = ["'self'", ...sanitizeCSPSources(csp.frameDomains)];
+	return [
+		"default-src 'none'",
+		"base-uri 'none'",
+		"form-action 'none'",
+		"script-src 'unsafe-inline'",
+		"style-src 'unsafe-inline'",
+		`connect-src ${connectSrc.join(" ")}`,
+		`img-src ${imgSrc.join(" ")}`,
+		`font-src ${imgSrc.join(" ")}`,
+		`frame-src ${frameSrc.join(" ")}`
+	].join("; ");
 }
-var MCP_APP_PERMISSION_FEATURES = {
-  camera: "camera",
-  microphone: "microphone",
-  geolocation: "geolocation",
-  clipboardWrite: "clipboard-write"
+const MCP_APP_PERMISSION_FEATURES = {
+	camera: "camera",
+	microphone: "microphone",
+	geolocation: "geolocation",
+	clipboardWrite: "clipboard-write"
 };
+/**
+* Converts MCP App permission metadata into an iframe `allow` attribute.
+*
+* Deny-by-default: a capability is granted only when it is both requested in
+* `permissions` and present in the host `allowedPermissions` allowlist.
+* Omitting the allowlist grants nothing, mirroring `allowedTools` in the bridge.
+*
+* @example
+* ```ts
+* const allow = getMCPAppAllowAttribute(
+*   { microphone: {}, camera: {} },
+*   ['microphone'],
+* );
+* // "microphone" — camera requested by server but not host-allowed
+* ```
+*/
 function getMCPAppAllowAttribute(permissions, allowedPermissions) {
-  if (permissions == null || allowedPermissions == null) {
-    return void 0;
-  }
-  const allow = allowedPermissions.filter((permission) => Boolean(permissions[permission])).map((permission) => MCP_APP_PERMISSION_FEATURES[permission]);
-  return allow.length > 0 ? allow.join("; ") : void 0;
+	if (permissions == null || allowedPermissions == null) return;
+	const allow = allowedPermissions.filter((permission) => Boolean(permissions[permission])).map((permission) => MCP_APP_PERMISSION_FEATURES[permission]);
+	return allow.length > 0 ? allow.join("; ") : void 0;
 }
-
-// src/mcp-apps/utils.ts
-import { isJSONObject as isJSONObject2 } from "@ai-sdk/provider";
+//#endregion
+//#region src/mcp-apps/utils.ts
+/**
+* Extracts MCP App metadata from an AI SDK tool UI part.
+*
+* @example
+* ```ts
+* const app = getMCPAppFromToolPart({
+*   type: 'dynamic-tool',
+*   toolName: 'showDashboard',
+*   toolCallId: 'call-1',
+*   state: 'input-available',
+*   input: { topic: 'usage' },
+*   toolMetadata: {
+*     app: {
+*       resourceUri: 'ui://example/dashboard',
+*       mimeType: 'text/html;profile=mcp-app',
+*     },
+*   },
+* });
+* // { resourceUri: 'ui://example/dashboard', mimeType: 'text/html;profile=mcp-app' }
+* ```
+*/
 function getMCPAppFromToolPart(part) {
-  const rawAppMetadata = part.toolMetadata?.app;
-  const appMetadata = isJSONObject2(rawAppMetadata) ? rawAppMetadata : void 0;
-  if (appMetadata == null || appMetadata.mimeType !== "text/html;profile=mcp-app" || typeof appMetadata.resourceUri !== "string" || !appMetadata.resourceUri.startsWith("ui://") || appMetadata.visibility != null && (!Array.isArray(appMetadata.visibility) || appMetadata.visibility.some(
-    (value) => value !== "model" && value !== "app"
-  ))) {
-    return void 0;
-  }
-  return appMetadata;
+	const rawAppMetadata = part.toolMetadata?.app;
+	const appMetadata = isJSONObject(rawAppMetadata) ? rawAppMetadata : void 0;
+	if (appMetadata == null || appMetadata.mimeType !== "text/html;profile=mcp-app" || typeof appMetadata.resourceUri !== "string" || !appMetadata.resourceUri.startsWith("ui://") || appMetadata.visibility != null && (!Array.isArray(appMetadata.visibility) || appMetadata.visibility.some((value) => value !== "model" && value !== "app"))) return;
+	return appMetadata;
 }
+/**
+* Converts an AI SDK tool output into the MCP Apps tool-result shape.
+*
+* MCP Apps expect tool results to have `content` and optional
+* `structuredContent`. MCP tools already return that shape, but typed AI SDK
+* tools may return only structured data. This helper wraps structured-only
+* outputs so the iframe can receive a valid tool result notification.
+*
+* @example
+* ```ts
+* normalizeMCPAppToolResult({ cards: [] });
+* // { content: [], structuredContent: { cards: [] } }
+* ```
+*/
 function normalizeMCPAppToolResult(output) {
-  if (output != null && typeof output === "object" && "content" in output) {
-    return output;
-  }
-  return {
-    content: [],
-    structuredContent: output
-  };
+	if (output != null && typeof output === "object" && "content" in output) return output;
+	return {
+		content: [],
+		structuredContent: output
+	};
 }
-
-// src/mcp-apps/app-frame.tsx
-import { jsx } from "react/jsx-runtime";
+//#endregion
+//#region src/mcp-apps/app-frame.tsx
+/**
+* Derives the concrete origin of the sandbox proxy from its URL, so outbound
+* postMessage targets a specific origin instead of `'*'` and inbound messages
+* can be origin-checked. The proxy must be served from a stable, concrete
+* origin (the default outer sandbox keeps `allow-same-origin`). Falls back to
+* the host origin on a malformed URL, never `'*'`.
+*/
 function deriveTargetOrigin(url) {
-  const location = typeof window !== "undefined" ? window.location : void 0;
-  try {
-    return new URL(url, location?.href).origin;
-  } catch {
-    return location?.origin ?? "null";
-  }
+	const location = typeof window !== "undefined" ? window.location : void 0;
+	try {
+		return new URL(url, location?.href).origin;
+	} catch {
+		return location?.origin ?? "null";
+	}
 }
-function sendToolState({
-  bridge,
-  input,
-  output
-}) {
-  if (bridge == null) {
-    return;
-  }
-  if (input !== void 0) {
-    bridge.sendToolInput(input);
-  }
-  if (output !== void 0) {
-    bridge.sendToolResult(normalizeMCPAppToolResult(output));
-  }
+function sendToolState({ bridge, input, output }) {
+	if (bridge == null) return;
+	if (input !== void 0) bridge.sendToolInput(input);
+	if (output !== void 0) bridge.sendToolResult(normalizeMCPAppToolResult(output));
 }
-function MCPAppFrame({
-  app,
-  resource,
-  input,
-  output,
-  sandbox,
-  handlers,
-  hostInfo,
-  hostContext
-}) {
-  const iframeRef = useRef5(null);
-  const bridgeRef = useRef5(void 0);
-  const inputRef = useRef5(input);
-  const outputRef = useRef5(output);
-  const hostContextRef = useRef5(hostContext);
-  const initializedRef = useRef5(false);
-  inputRef.current = input;
-  outputRef.current = output;
-  hostContextRef.current = hostContext;
-  const sandboxUrl = String(sandbox.url);
-  const targetOrigin = sandbox.targetOrigin ?? deriveTargetOrigin(sandboxUrl);
-  const resourceCSP = getMCPAppCSP(resource.meta?.csp);
-  const resourceAllow = getMCPAppAllowAttribute(
-    resource.meta?.permissions,
-    sandbox.allowedPermissions
-  );
-  const innerSandbox = sandbox.innerSandbox ?? MCP_APP_DEFAULT_INNER_SANDBOX;
-  const bridgeHandlers = useMemo3(
-    () => ({
-      ...handlers,
-      onInitialized: () => {
-        initializedRef.current = true;
-        handlers?.onInitialized?.();
-        sendToolState({
-          bridge: bridgeRef.current,
-          input: inputRef.current,
-          output: outputRef.current
-        });
-      }
-    }),
-    [handlers]
-  );
-  const bridgeHandlersRef = useRef5(bridgeHandlers);
-  bridgeHandlersRef.current = bridgeHandlers;
-  useEffect4(() => {
-    const iframe = iframeRef.current;
-    const targetWindow = iframe?.contentWindow;
-    if (targetWindow == null) {
-      return;
-    }
-    initializedRef.current = false;
-    const bridge = new MCPAppBridge({
-      targetWindow,
-      targetOrigin,
-      handlers: bridgeHandlersRef.current,
-      hostInfo,
-      hostContext: hostContextRef.current
-    });
-    bridgeRef.current = bridge;
-    const onMessage = (event) => {
-      if (!bridge.acceptsEvent(event)) {
-        return;
-      }
-      if (event.data?.jsonrpc === "2.0" && event.data.method === "ui/notifications/sandbox-proxy-ready") {
-        bridge.sendSandboxResourceReady({
-          html: resource.html,
-          csp: resourceCSP,
-          sandbox: innerSandbox,
-          allow: resourceAllow
-        });
-        return;
-      }
-      bridge.handleMessage(event);
-    };
-    window.addEventListener("message", onMessage);
-    return () => {
-      initializedRef.current = false;
-      window.removeEventListener("message", onMessage);
-      void bridge.teardownResource().catch(() => {
-      });
-      bridge.close();
-      bridgeRef.current = void 0;
-    };
-  }, [
-    hostInfo,
-    innerSandbox,
-    resource.html,
-    resourceAllow,
-    resourceCSP,
-    sandboxUrl,
-    targetOrigin
-  ]);
-  useEffect4(() => {
-    bridgeRef.current?.setHandlers(bridgeHandlers);
-  }, [bridgeHandlers]);
-  useEffect4(() => {
-    if (hostContext != null) {
-      bridgeRef.current?.setHostContext(hostContext);
-    }
-  }, [hostContext]);
-  useEffect4(() => {
-    if (initializedRef.current && input !== void 0) {
-      bridgeRef.current?.sendToolInput(input);
-    }
-  }, [input]);
-  useEffect4(() => {
-    if (initializedRef.current && output !== void 0) {
-      bridgeRef.current?.sendToolResult(normalizeMCPAppToolResult(output));
-    }
-  }, [output]);
-  return /* @__PURE__ */ jsx(
-    "iframe",
-    {
-      ref: iframeRef,
-      title: "MCP App",
-      "aria-label": sandbox.title ?? app.resourceUri,
-      src: sandboxUrl,
-      className: sandbox.className,
-      style: sandbox.style,
-      allow: resourceAllow,
-      sandbox: sandbox.outerSandbox ?? MCP_APP_DEFAULT_OUTER_SANDBOX
-    }
-  );
+function MCPAppFrame({ app, resource, input, output, sandbox, handlers, hostInfo, hostContext }) {
+	const iframeRef = useRef(null);
+	const bridgeRef = useRef(void 0);
+	const inputRef = useRef(input);
+	const outputRef = useRef(output);
+	const hostContextRef = useRef(hostContext);
+	const initializedRef = useRef(false);
+	inputRef.current = input;
+	outputRef.current = output;
+	hostContextRef.current = hostContext;
+	const sandboxUrl = String(sandbox.url);
+	const targetOrigin = sandbox.targetOrigin ?? deriveTargetOrigin(sandboxUrl);
+	const resourceCSP = getMCPAppCSP(resource.meta?.csp);
+	const resourceAllow = getMCPAppAllowAttribute(resource.meta?.permissions, sandbox.allowedPermissions);
+	const innerSandbox = sandbox.innerSandbox ?? "allow-scripts allow-forms";
+	const bridgeHandlers = useMemo(() => ({
+		...handlers,
+		onInitialized: () => {
+			initializedRef.current = true;
+			handlers?.onInitialized?.();
+			sendToolState({
+				bridge: bridgeRef.current,
+				input: inputRef.current,
+				output: outputRef.current
+			});
+		}
+	}), [handlers]);
+	const bridgeHandlersRef = useRef(bridgeHandlers);
+	bridgeHandlersRef.current = bridgeHandlers;
+	useEffect(() => {
+		const targetWindow = iframeRef.current?.contentWindow;
+		if (targetWindow == null) return;
+		initializedRef.current = false;
+		const bridge = new MCPAppBridge({
+			targetWindow,
+			targetOrigin,
+			handlers: bridgeHandlersRef.current,
+			hostInfo,
+			hostContext: hostContextRef.current
+		});
+		bridgeRef.current = bridge;
+		const onMessage = (event) => {
+			if (!bridge.acceptsEvent(event)) return;
+			if (event.data?.jsonrpc === "2.0" && event.data.method === "ui/notifications/sandbox-proxy-ready") {
+				bridge.sendSandboxResourceReady({
+					html: resource.html,
+					csp: resourceCSP,
+					sandbox: innerSandbox,
+					allow: resourceAllow
+				});
+				return;
+			}
+			bridge.handleMessage(event);
+		};
+		window.addEventListener("message", onMessage);
+		return () => {
+			initializedRef.current = false;
+			window.removeEventListener("message", onMessage);
+			bridge.teardownResource().catch(() => {});
+			bridge.close();
+			bridgeRef.current = void 0;
+		};
+	}, [
+		hostInfo,
+		innerSandbox,
+		resource.html,
+		resourceAllow,
+		resourceCSP,
+		sandboxUrl,
+		targetOrigin
+	]);
+	useEffect(() => {
+		bridgeRef.current?.setHandlers(bridgeHandlers);
+	}, [bridgeHandlers]);
+	useEffect(() => {
+		if (hostContext != null) bridgeRef.current?.setHostContext(hostContext);
+	}, [hostContext]);
+	useEffect(() => {
+		if (initializedRef.current && input !== void 0) bridgeRef.current?.sendToolInput(input);
+	}, [input]);
+	useEffect(() => {
+		if (initializedRef.current && output !== void 0) bridgeRef.current?.sendToolResult(normalizeMCPAppToolResult(output));
+	}, [output]);
+	return /* @__PURE__ */ jsx("iframe", {
+		ref: iframeRef,
+		title: "MCP App",
+		"aria-label": sandbox.title ?? app.resourceUri,
+		src: sandboxUrl,
+		className: sandbox.className,
+		style: sandbox.style,
+		allow: resourceAllow,
+		sandbox: sandbox.outerSandbox ?? "allow-scripts allow-same-origin allow-forms"
+	});
 }
-
-// src/mcp-apps/app-renderer.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
+//#endregion
+//#region src/mcp-apps/app-renderer.tsx
 function getToolPartOutput(part) {
-  return part.state === "output-available" ? part.output : void 0;
+	return part.state === "output-available" ? part.output : void 0;
 }
 function getToolPartInput(part) {
-  return part.state === "input-available" || part.state === "output-available" ? part.input : void 0;
+	return part.state === "input-available" || part.state === "output-available" ? part.input : void 0;
 }
-function MCPAppRenderer({
-  part,
-  sandbox,
-  resource: resourceProp,
-  loadResource,
-  handlers,
-  hostInfo,
-  hostContext,
-  fallback = null
-}) {
-  const app = getMCPAppFromToolPart(part);
-  const [cachedApp, setCachedApp] = useState3();
-  const [loadedResource, setLoadedResource] = useState3();
-  useEffect5(() => {
-    if (app != null) {
-      setCachedApp(
-        (previous) => previous?.resourceUri === app.resourceUri ? previous : app
-      );
-    }
-  }, [app?.resourceUri]);
-  const appForRender = app ?? cachedApp;
-  useEffect5(() => {
-    if (appForRender == null || resourceProp != null || loadResource == null) {
-      return;
-    }
-    let cancelled = false;
-    const resourceUri = appForRender.resourceUri;
-    loadResource(appForRender).then((resource2) => {
-      if (!cancelled) {
-        setLoadedResource({ resourceUri, resource: resource2 });
-      }
-    }).catch((error2) => {
-      if (!cancelled) {
-        setLoadedResource({
-          resourceUri,
-          error: error2 instanceof Error ? error2 : new Error(String(error2))
-        });
-      }
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [appForRender?.resourceUri, loadResource, resourceProp]);
-  const loadedResourceForApp = loadedResource?.resourceUri === appForRender?.resourceUri ? loadedResource : void 0;
-  const resource = resourceProp ?? loadedResourceForApp?.resource;
-  const error = resourceProp == null ? loadedResourceForApp?.error : void 0;
-  if (appForRender == null || error != null || resource == null) {
-    return fallback;
-  }
-  return /* @__PURE__ */ jsx2(
-    MCPAppFrame,
-    {
-      app: appForRender,
-      resource,
-      input: getToolPartInput(part),
-      output: getToolPartOutput(part),
-      sandbox,
-      handlers,
-      hostInfo,
-      hostContext
-    }
-  );
+function MCPAppRenderer({ part, sandbox, resource: resourceProp, loadResource, handlers, hostInfo, hostContext, fallback = null }) {
+	const app = getMCPAppFromToolPart(part);
+	const [cachedApp, setCachedApp] = useState();
+	const [loadedResource, setLoadedResource] = useState();
+	useEffect(() => {
+		if (app != null) setCachedApp((previous) => previous?.resourceUri === app.resourceUri ? previous : app);
+	}, [app?.resourceUri]);
+	const appForRender = app ?? cachedApp;
+	useEffect(() => {
+		if (appForRender == null || resourceProp != null || loadResource == null) return;
+		let cancelled = false;
+		const resourceUri = appForRender.resourceUri;
+		loadResource(appForRender).then((resource) => {
+			if (!cancelled) setLoadedResource({
+				resourceUri,
+				resource
+			});
+		}).catch((error) => {
+			if (!cancelled) setLoadedResource({
+				resourceUri,
+				error: error instanceof Error ? error : new Error(String(error))
+			});
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		appForRender?.resourceUri,
+		loadResource,
+		resourceProp
+	]);
+	const loadedResourceForApp = loadedResource?.resourceUri === appForRender?.resourceUri ? loadedResource : void 0;
+	const resource = resourceProp ?? loadedResourceForApp?.resource;
+	const error = resourceProp == null ? loadedResourceForApp?.error : void 0;
+	if (appForRender == null || error != null || resource == null) return fallback;
+	return /* @__PURE__ */ jsx(MCPAppFrame, {
+		app: appForRender,
+		resource,
+		input: getToolPartInput(part),
+		output: getToolPartOutput(part),
+		sandbox,
+		handlers,
+		hostInfo,
+		hostContext
+	});
 }
+//#endregion
+//#region src/index.ts
+/**
+* @deprecated Use `useObject` instead.
+*/
+const experimental_useObject = useObject;
+//#endregion
+export { Chat, MCPAppRenderer as experimental_MCPAppRenderer, experimental_useObject, experimental_useRealtime, useChat, useCompletion, useObject };
 
-// src/index.ts
-var experimental_useObject = useObject;
-export {
-  Chat,
-  MCPAppRenderer as experimental_MCPAppRenderer,
-  experimental_useObject,
-  experimental_useRealtime,
-  useChat,
-  useCompletion,
-  useObject
-};
 //# sourceMappingURL=index.js.map