create-skybridge 0.0.0-cloudflare

package/template/node_modules/.vite/deps/skybridge_web.js

@@ -0,0 +1,1508 @@
+import {
+  require_client
+} from "./chunk-VNABIVRN.js";
+import "./chunk-V2LKO732.js";
+import {
+  AppsSdkAdaptor,
+  AppsSdkBridge,
+  McpAppAdaptor,
+  McpAppBridge,
+  SET_GLOBALS_EVENT_TYPE,
+  SetGlobalsEvent,
+  TOOL_RESPONSE_EVENT_TYPE,
+  getAdaptor,
+  useAppsSdkContext,
+  useHostContext,
+  useMcpAppContext
+} from "./chunk-YNOAPT43.js";
+import {
+  require_jsx_runtime
+} from "./chunk-RKAOJUND.js";
+import {
+  require_react
+} from "./chunk-MEVQY4YB.js";
+import {
+  __toESM
+} from "./chunk-5WRI5ZAA.js";
+
+// ../../../node_modules/.pnpm/zustand@5.0.11_@types+react@19.2.14_immer@9.0.21_react@19.2.4_use-sync-external-store@1.6.0_react@19.2.4_/node_modules/zustand/esm/vanilla.mjs
+var createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState2 = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const api = { setState, getState, getInitialState: getInitialState2, subscribe };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+var createStore = ((createState) => createState ? createStoreImpl(createState) : createStoreImpl);
+
+// ../../../node_modules/.pnpm/zustand@5.0.11_@types+react@19.2.14_immer@9.0.21_react@19.2.4_use-sync-external-store@1.6.0_react@19.2.4_/node_modules/zustand/esm/react.mjs
+var import_react = __toESM(require_react(), 1);
+var identity = (arg) => arg;
+function useStore(api, selector = identity) {
+  const slice = import_react.default.useSyncExternalStore(
+    api.subscribe,
+    import_react.default.useCallback(() => selector(api.getState()), [api, selector]),
+    import_react.default.useCallback(() => selector(api.getInitialState()), [api, selector])
+  );
+  import_react.default.useDebugValue(slice);
+  return slice;
+}
+var createImpl = (createState) => {
+  const api = createStore(createState);
+  const useBoundStore = (selector) => useStore(api, selector);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
+};
+var create = ((createState) => createState ? createImpl(createState) : createImpl);
+
+// ../../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/double-indexed-kv.js
+var DoubleIndexedKV = class {
+  constructor() {
+    this.keyToValue = /* @__PURE__ */ new Map();
+    this.valueToKey = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this.keyToValue.set(key, value);
+    this.valueToKey.set(value, key);
+  }
+  getByKey(key) {
+    return this.keyToValue.get(key);
+  }
+  getByValue(value) {
+    return this.valueToKey.get(value);
+  }
+  clear() {
+    this.keyToValue.clear();
+    this.valueToKey.clear();
+  }
+};
+
+// ../../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/registry.js
+var Registry = class {
+  constructor(generateIdentifier) {
+    this.generateIdentifier = generateIdentifier;
+    this.kv = new DoubleIndexedKV();
+  }
+  register(value, identifier) {
+    if (this.kv.getByValue(value)) {
+      return;
+    }
+    if (!identifier) {
+      identifier = this.generateIdentifier(value);
+    }
+    this.kv.set(identifier, value);
+  }
+  clear() {
+    this.kv.clear();
+  }
+  getIdentifier(value) {
+    return this.kv.getByValue(value);
+  }
+  getValue(identifier) {
+    return this.kv.getByKey(identifier);
+  }
+};
+
+// ../../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/class-registry.js
+var ClassRegistry = class extends Registry {
+  constructor() {
+    super((c) => c.name);
+    this.classToAllowedProps = /* @__PURE__ */ new Map();
+  }
+  register(value, options) {
+    if (typeof options === "object") {
+      if (options.allowProps) {
+        this.classToAllowedProps.set(value, options.allowProps);
+      }
+      super.register(value, options.identifier);
+    } else {
+      super.register(value, options);
+    }
+  }
+  getAllowedProps(value) {
+    return this.classToAllowedProps.get(value);
+  }
+};
+
+// ../../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/util.js
+function valuesOfObj(record) {
+  if ("values" in Object) {
+    return Object.values(record);
+  }
+  const values = [];
+  for (const key in record) {
+    if (record.hasOwnProperty(key)) {
+      values.push(record[key]);
+    }
+  }
+  return values;
+}
+function find(record, predicate) {
+  const values = valuesOfObj(record);
+  if ("find" in values) {
+    return values.find(predicate);
+  }
+  const valuesNotNever = values;
+  for (let i = 0; i < valuesNotNever.length; i++) {
+    const value = valuesNotNever[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function forEach(record, run) {
+  Object.entries(record).forEach(([key, value]) => run(value, key));
+}
+function includes(arr, value) {
+  return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+  for (let i = 0; i < record.length; i++) {
+    const value = record[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// ../../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/custom-transformer-registry.js
+var CustomTransformerRegistry = class {
+  constructor() {
+    this.transfomers = {};
+  }
+  register(transformer) {
+    this.transfomers[transformer.name] = transformer;
+  }
+  findApplicable(v) {
+    return find(this.transfomers, (transformer) => transformer.isApplicable(v));
+  }
+  findByName(name) {
+    return this.transfomers[name];
+  }
+};
+
+// ../../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/is.js
+var getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+var isUndefined = (payload) => typeof payload === "undefined";
+var isNull = (payload) => payload === null;
+var isPlainObject = (payload) => {
+  if (typeof payload !== "object" || payload === null)
+    return false;
+  if (payload === Object.prototype)
+    return false;
+  if (Object.getPrototypeOf(payload) === null)
+    return true;
+  return Object.getPrototypeOf(payload) === Object.prototype;
+};
+var isEmptyObject = (payload) => isPlainObject(payload) && Object.keys(payload).length === 0;
+var isArray = (payload) => Array.isArray(payload);
+var isString = (payload) => typeof payload === "string";
+var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
+var isBoolean = (payload) => typeof payload === "boolean";
+var isRegExp = (payload) => payload instanceof RegExp;
+var isMap = (payload) => payload instanceof Map;
+var isSet = (payload) => payload instanceof Set;
+var isSymbol = (payload) => getType(payload) === "Symbol";
+var isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+var isError = (payload) => payload instanceof Error;
+var isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
+var isPrimitive = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+var isBigint = (payload) => typeof payload === "bigint";
+var isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+var isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+var isURL = (payload) => payload instanceof URL;
+
+// ../../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/pathstringifier.js
+var escapeKey = (key) => key.replace(/\\/g, "\\\\").replace(/\./g, "\\.");
+var stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
+var parsePath = (string, legacyPaths) => {
+  const result = [];
+  let segment = "";
+  for (let i = 0; i < string.length; i++) {
+    let char = string.charAt(i);
+    if (!legacyPaths && char === "\\") {
+      const escaped = string.charAt(i + 1);
+      if (escaped === "\\") {
+        segment += "\\";
+        i++;
+        continue;
+      } else if (escaped !== ".") {
+        throw Error("invalid path");
+      }
+    }
+    const isEscapedDot = char === "\\" && string.charAt(i + 1) === ".";
+    if (isEscapedDot) {
+      segment += ".";
+      i++;
+      continue;
+    }
+    const isEndOfSegment = char === ".";
+    if (isEndOfSegment) {
+      result.push(segment);
+      segment = "";
+      continue;
+    }
+    segment += char;
+  }
+  const lastSegment = segment;
+  result.push(lastSegment);
+  return result;
+};
+
+// ../../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/transformer.js
+function simpleTransformation(isApplicable, annotation, transform2, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform: transform2,
+    untransform
+  };
+}
+var simpleRules = [
+  simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
+  simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
+    if (typeof BigInt !== "undefined") {
+      return BigInt(v);
+    }
+    console.error("Please add a BigInt polyfill.");
+    return v;
+  }),
+  simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
+  simpleTransformation(isError, "Error", (v, superJson) => {
+    const baseError = {
+      name: v.name,
+      message: v.message
+    };
+    if ("cause" in v) {
+      baseError.cause = v.cause;
+    }
+    superJson.allowedErrorProps.forEach((prop) => {
+      baseError[prop] = v[prop];
+    });
+    return baseError;
+  }, (v, superJson) => {
+    const e = new Error(v.message, { cause: v.cause });
+    e.name = v.name;
+    e.stack = v.stack;
+    superJson.allowedErrorProps.forEach((prop) => {
+      e[prop] = v[prop];
+    });
+    return e;
+  }),
+  simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
+    const body = regex.slice(1, regex.lastIndexOf("/"));
+    const flags = regex.slice(regex.lastIndexOf("/") + 1);
+    return new RegExp(body, flags);
+  }),
+  simpleTransformation(
+    isSet,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    (v) => [...v.values()],
+    (v) => new Set(v)
+  ),
+  simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
+  simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
+    if (isNaNValue(v)) {
+      return "NaN";
+    }
+    if (v > 0) {
+      return "Infinity";
+    } else {
+      return "-Infinity";
+    }
+  }, Number),
+  simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
+    return "-0";
+  }, Number),
+  simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
+];
+function compositeTransformation(isApplicable, annotation, transform2, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform: transform2,
+    untransform
+  };
+}
+var symbolRule = compositeTransformation((s, superJson) => {
+  if (isSymbol(s)) {
+    const isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
+    return isRegistered;
+  }
+  return false;
+}, (s, superJson) => {
+  const identifier = superJson.symbolRegistry.getIdentifier(s);
+  return ["symbol", identifier];
+}, (v) => v.description, (_, a, superJson) => {
+  const value = superJson.symbolRegistry.getValue(a[1]);
+  if (!value) {
+    throw new Error("Trying to deserialize unknown symbol");
+  }
+  return value;
+});
+var constructorToName = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce((obj, ctor) => {
+  obj[ctor.name] = ctor;
+  return obj;
+}, {});
+var typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
+  const ctor = constructorToName[a[1]];
+  if (!ctor) {
+    throw new Error("Trying to deserialize unknown typed array");
+  }
+  return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+  if (potentialClass?.constructor) {
+    const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+    return isRegistered;
+  }
+  return false;
+}
+var classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+  const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+  return ["class", identifier];
+}, (clazz, superJson) => {
+  const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+  if (!allowedProps) {
+    return { ...clazz };
+  }
+  const result = {};
+  allowedProps.forEach((prop) => {
+    result[prop] = clazz[prop];
+  });
+  return result;
+}, (v, a, superJson) => {
+  const clazz = superJson.classRegistry.getValue(a[1]);
+  if (!clazz) {
+    throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+  }
+  return Object.assign(Object.create(clazz.prototype), v);
+});
+var customRule = compositeTransformation((value, superJson) => {
+  return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return ["custom", transformer.name];
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return transformer.serialize(value);
+}, (v, a, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findByName(a[1]);
+  if (!transformer) {
+    throw new Error("Trying to deserialize unknown custom value");
+  }
+  return transformer.deserialize(v);
+});
+var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
+var transformValue = (value, superJson) => {
+  const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableCompositeRule) {
+    return {
+      value: applicableCompositeRule.transform(value, superJson),
+      type: applicableCompositeRule.annotation(value, superJson)
+    };
+  }
+  const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableSimpleRule) {
+    return {
+      value: applicableSimpleRule.transform(value, superJson),
+      type: applicableSimpleRule.annotation
+    };
+  }
+  return void 0;
+};
+var simpleRulesByAnnotation = {};
+simpleRules.forEach((rule) => {
+  simpleRulesByAnnotation[rule.annotation] = rule;
+});
+var untransformValue = (json, type, superJson) => {
+  if (isArray(type)) {
+    switch (type[0]) {
+      case "symbol":
+        return symbolRule.untransform(json, type, superJson);
+      case "class":
+        return classRule.untransform(json, type, superJson);
+      case "custom":
+        return customRule.untransform(json, type, superJson);
+      case "typed-array":
+        return typedArrayRule.untransform(json, type, superJson);
+      default:
+        throw new Error("Unknown transformation: " + type);
+    }
+  } else {
+    const transformation = simpleRulesByAnnotation[type];
+    if (!transformation) {
+      throw new Error("Unknown transformation: " + type);
+    }
+    return transformation.untransform(json, superJson);
+  }
+};
+
+// ../../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/accessDeep.js
+var getNthKey = (value, n) => {
+  if (n > value.size)
+    throw new Error("index out of bounds");
+  const keys = value.keys();
+  while (n > 0) {
+    keys.next();
+    n--;
+  }
+  return keys.next().value;
+};
+function validatePath(path) {
+  if (includes(path, "__proto__")) {
+    throw new Error("__proto__ is not allowed as a property");
+  }
+  if (includes(path, "prototype")) {
+    throw new Error("prototype is not allowed as a property");
+  }
+  if (includes(path, "constructor")) {
+    throw new Error("constructor is not allowed as a property");
+  }
+}
+var getDeep = (object, path) => {
+  validatePath(path);
+  for (let i = 0; i < path.length; i++) {
+    const key = path[i];
+    if (isSet(object)) {
+      object = getNthKey(object, +key);
+    } else if (isMap(object)) {
+      const row = +key;
+      const type = +path[++i] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(object, row);
+      switch (type) {
+        case "key":
+          object = keyOfRow;
+          break;
+        case "value":
+          object = object.get(keyOfRow);
+          break;
+      }
+    } else {
+      object = object[key];
+    }
+  }
+  return object;
+};
+var setDeep = (object, path, mapper) => {
+  validatePath(path);
+  if (path.length === 0) {
+    return mapper(object);
+  }
+  let parent = object;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (isArray(parent)) {
+      const index = +key;
+      parent = parent[index];
+    } else if (isPlainObject(parent)) {
+      parent = parent[key];
+    } else if (isSet(parent)) {
+      const row = +key;
+      parent = getNthKey(parent, row);
+    } else if (isMap(parent)) {
+      const isEnd = i === path.length - 2;
+      if (isEnd) {
+        break;
+      }
+      const row = +key;
+      const type = +path[++i] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(parent, row);
+      switch (type) {
+        case "key":
+          parent = keyOfRow;
+          break;
+        case "value":
+          parent = parent.get(keyOfRow);
+          break;
+      }
+    }
+  }
+  const lastKey = path[path.length - 1];
+  if (isArray(parent)) {
+    parent[+lastKey] = mapper(parent[+lastKey]);
+  } else if (isPlainObject(parent)) {
+    parent[lastKey] = mapper(parent[lastKey]);
+  }
+  if (isSet(parent)) {
+    const oldValue = getNthKey(parent, +lastKey);
+    const newValue = mapper(oldValue);
+    if (oldValue !== newValue) {
+      parent.delete(oldValue);
+      parent.add(newValue);
+    }
+  }
+  if (isMap(parent)) {
+    const row = +path[path.length - 2];
+    const keyToRow = getNthKey(parent, row);
+    const type = +lastKey === 0 ? "key" : "value";
+    switch (type) {
+      case "key": {
+        const newKey = mapper(keyToRow);
+        parent.set(newKey, parent.get(keyToRow));
+        if (newKey !== keyToRow) {
+          parent.delete(keyToRow);
+        }
+        break;
+      }
+      case "value": {
+        parent.set(keyToRow, mapper(parent.get(keyToRow)));
+        break;
+      }
+    }
+  }
+  return object;
+};
+
+// ../../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/plainer.js
+var enableLegacyPaths = (version) => version < 1;
+function traverse(tree, walker2, version, origin = []) {
+  if (!tree) {
+    return;
+  }
+  const legacyPaths = enableLegacyPaths(version);
+  if (!isArray(tree)) {
+    forEach(tree, (subtree, key) => traverse(subtree, walker2, version, [
+      ...origin,
+      ...parsePath(key, legacyPaths)
+    ]));
+    return;
+  }
+  const [nodeValue, children] = tree;
+  if (children) {
+    forEach(children, (child, key) => {
+      traverse(child, walker2, version, [
+        ...origin,
+        ...parsePath(key, legacyPaths)
+      ]);
+    });
+  }
+  walker2(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, version, superJson) {
+  traverse(annotations, (type, path) => {
+    plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
+  }, version);
+  return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations, version) {
+  const legacyPaths = enableLegacyPaths(version);
+  function apply(identicalPaths, path) {
+    const object = getDeep(plain, parsePath(path, legacyPaths));
+    identicalPaths.map((path2) => parsePath(path2, legacyPaths)).forEach((identicalObjectPath) => {
+      plain = setDeep(plain, identicalObjectPath, () => object);
+    });
+  }
+  if (isArray(annotations)) {
+    const [root, other] = annotations;
+    root.forEach((identicalPath) => {
+      plain = setDeep(plain, parsePath(identicalPath, legacyPaths), () => plain);
+    });
+    if (other) {
+      forEach(other, apply);
+    }
+  } else {
+    forEach(annotations, apply);
+  }
+  return plain;
+}
+var isDeep = (object, superJson) => isPlainObject(object) || isArray(object) || isMap(object) || isSet(object) || isError(object) || isInstanceOfRegisteredClass(object, superJson);
+function addIdentity(object, path, identities) {
+  const existingSet = identities.get(object);
+  if (existingSet) {
+    existingSet.push(path);
+  } else {
+    identities.set(object, [path]);
+  }
+}
+function generateReferentialEqualityAnnotations(identitites, dedupe) {
+  const result = {};
+  let rootEqualityPaths = void 0;
+  identitites.forEach((paths) => {
+    if (paths.length <= 1) {
+      return;
+    }
+    if (!dedupe) {
+      paths = paths.map((path) => path.map(String)).sort((a, b) => a.length - b.length);
+    }
+    const [representativePath, ...identicalPaths] = paths;
+    if (representativePath.length === 0) {
+      rootEqualityPaths = identicalPaths.map(stringifyPath);
+    } else {
+      result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
+    }
+  });
+  if (rootEqualityPaths) {
+    if (isEmptyObject(result)) {
+      return [rootEqualityPaths];
+    } else {
+      return [rootEqualityPaths, result];
+    }
+  } else {
+    return isEmptyObject(result) ? void 0 : result;
+  }
+}
+var walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+  const primitive = isPrimitive(object);
+  if (!primitive) {
+    addIdentity(object, path, identities);
+    const seen = seenObjects.get(object);
+    if (seen) {
+      return dedupe ? {
+        transformedValue: null
+      } : seen;
+    }
+  }
+  if (!isDeep(object, superJson)) {
+    const transformed2 = transformValue(object, superJson);
+    const result2 = transformed2 ? {
+      transformedValue: transformed2.value,
+      annotations: [transformed2.type]
+    } : {
+      transformedValue: object
+    };
+    if (!primitive) {
+      seenObjects.set(object, result2);
+    }
+    return result2;
+  }
+  if (includes(objectsInThisPath, object)) {
+    return {
+      transformedValue: null
+    };
+  }
+  const transformationResult = transformValue(object, superJson);
+  const transformed = transformationResult?.value ?? object;
+  const transformedValue = isArray(transformed) ? [] : {};
+  const innerAnnotations = {};
+  forEach(transformed, (value, index) => {
+    if (index === "__proto__" || index === "constructor" || index === "prototype") {
+      throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
+    }
+    const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
+    transformedValue[index] = recursiveResult.transformedValue;
+    if (isArray(recursiveResult.annotations)) {
+      innerAnnotations[escapeKey(index)] = recursiveResult.annotations;
+    } else if (isPlainObject(recursiveResult.annotations)) {
+      forEach(recursiveResult.annotations, (tree, key) => {
+        innerAnnotations[escapeKey(index) + "." + key] = tree;
+      });
+    }
+  });
+  const result = isEmptyObject(innerAnnotations) ? {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type] : void 0
+  } : {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+  };
+  if (!primitive) {
+    seenObjects.set(object, result);
+  }
+  return result;
+};
+
+// ../../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/getType.js
+function getType2(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+}
+
+// ../../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isArray.js
+function isArray2(payload) {
+  return getType2(payload) === "Array";
+}
+
+// ../../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isPlainObject.js
+function isPlainObject2(payload) {
+  if (getType2(payload) !== "Object")
+    return false;
+  const prototype = Object.getPrototypeOf(payload);
+  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+
+// ../../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isNull.js
+function isNull2(payload) {
+  return getType2(payload) === "Null";
+}
+
+// ../../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isOneOf.js
+function isOneOf(a, b, c, d, e) {
+  return (value) => a(value) || b(value) || !!c && c(value) || !!d && d(value) || !!e && e(value);
+}
+
+// ../../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isUndefined.js
+function isUndefined2(payload) {
+  return getType2(payload) === "Undefined";
+}
+
+// ../../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isNullOrUndefined.js
+var isNullOrUndefined = isOneOf(isNull2, isUndefined2);
+
+// ../../../node_modules/.pnpm/copy-anything@4.0.5/node_modules/copy-anything/dist/index.js
+function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
+  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+  if (propType === "enumerable")
+    carry[key] = newVal;
+  if (includeNonenumerable && propType === "nonenumerable") {
+    Object.defineProperty(carry, key, {
+      value: newVal,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  }
+}
+function copy(target, options = {}) {
+  if (isArray2(target)) {
+    return target.map((item) => copy(item, options));
+  }
+  if (!isPlainObject2(target)) {
+    return target;
+  }
+  const props = Object.getOwnPropertyNames(target);
+  const symbols = Object.getOwnPropertySymbols(target);
+  return [...props, ...symbols].reduce((carry, key) => {
+    if (key === "__proto__")
+      return carry;
+    if (isArray2(options.props) && !options.props.includes(key)) {
+      return carry;
+    }
+    const val = target[key];
+    const newVal = copy(val, options);
+    assignProp(carry, key, newVal, target, options.nonenumerable);
+    return carry;
+  }, {});
+}
+
+// ../../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/index.js
+var SuperJSON = class {
+  /**
+   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+   */
+  constructor({ dedupe = false } = {}) {
+    this.classRegistry = new ClassRegistry();
+    this.symbolRegistry = new Registry((s) => s.description ?? "");
+    this.customTransformerRegistry = new CustomTransformerRegistry();
+    this.allowedErrorProps = [];
+    this.dedupe = dedupe;
+  }
+  serialize(object) {
+    const identities = /* @__PURE__ */ new Map();
+    const output = walker(object, identities, this, this.dedupe);
+    const res = {
+      json: output.transformedValue
+    };
+    if (output.annotations) {
+      res.meta = {
+        ...res.meta,
+        values: output.annotations
+      };
+    }
+    const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
+    if (equalityAnnotations) {
+      res.meta = {
+        ...res.meta,
+        referentialEqualities: equalityAnnotations
+      };
+    }
+    if (res.meta)
+      res.meta.v = 1;
+    return res;
+  }
+  deserialize(payload, options) {
+    const { json, meta } = payload;
+    let result = options?.inPlace ? json : copy(json);
+    if (meta?.values) {
+      result = applyValueAnnotations(result, meta.values, meta.v ?? 0, this);
+    }
+    if (meta?.referentialEqualities) {
+      result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities, meta.v ?? 0);
+    }
+    return result;
+  }
+  stringify(object) {
+    return JSON.stringify(this.serialize(object));
+  }
+  parse(string) {
+    return this.deserialize(JSON.parse(string), { inPlace: true });
+  }
+  registerClass(v, options) {
+    this.classRegistry.register(v, options);
+  }
+  registerSymbol(v, identifier) {
+    this.symbolRegistry.register(v, identifier);
+  }
+  registerCustom(transformer, name) {
+    this.customTransformerRegistry.register({
+      name,
+      ...transformer
+    });
+  }
+  allowErrorProps(...props) {
+    this.allowedErrorProps.push(...props);
+  }
+};
+SuperJSON.defaultInstance = new SuperJSON();
+SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+var dist_default = SuperJSON;
+var serialize = SuperJSON.serialize;
+var deserialize = SuperJSON.deserialize;
+var stringify = SuperJSON.stringify;
+var parse = SuperJSON.parse;
+var registerClass = SuperJSON.registerClass;
+var registerCustom = SuperJSON.registerCustom;
+var registerSymbol = SuperJSON.registerSymbol;
+var allowErrorProps = SuperJSON.allowErrorProps;
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/data-llm.js
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+var import_react2 = __toESM(require_react(), 1);
+var WIDGET_CONTEXT_KEY = "__widget_context";
+var nodes = /* @__PURE__ */ new Map();
+function setNode(node) {
+  nodes.set(node.id, node);
+  onChange();
+}
+function removeNode(id) {
+  nodes.delete(id);
+  onChange();
+}
+function onChange() {
+  const description = getLLMDescriptionString();
+  const adaptor = getAdaptor();
+  adaptor.setWidgetState((prevState) => ({
+    ...prevState,
+    [WIDGET_CONTEXT_KEY]: description
+  }));
+}
+var ParentIdContext = (0, import_react2.createContext)(null);
+function DataLLM({ content, children }) {
+  const parentId = (0, import_react2.useContext)(ParentIdContext);
+  const id = (0, import_react2.useId)();
+  (0, import_react2.useEffect)(() => {
+    if (content) {
+      setNode({
+        id,
+        parentId,
+        content
+      });
+    } else {
+      removeNode(id);
+    }
+    return () => {
+      removeNode(id);
+    };
+  }, [id, parentId, content]);
+  return (0, import_jsx_runtime.jsx)(ParentIdContext.Provider, { value: id, children });
+}
+function getLLMDescriptionString() {
+  const byParent = /* @__PURE__ */ new Map();
+  for (const node of Array.from(nodes.values())) {
+    const key = node.parentId ?? null;
+    if (!byParent.has(key)) {
+      byParent.set(key, []);
+    }
+    byParent.get(key)?.push(node);
+  }
+  for (const list of byParent.values()) {
+    list.sort((a, b) => a.id.localeCompare(b.id));
+  }
+  const lines = [];
+  function traverseTree(parentId, depth) {
+    const children = byParent.get(parentId);
+    if (!children) {
+      return;
+    }
+    for (const child of children) {
+      if (child.content?.trim()) {
+        const indent = "  ".repeat(depth);
+        lines.push(`${indent}- ${child.content.trim()}`);
+      }
+      traverseTree(child.id, depth + 1);
+    }
+  }
+  traverseTree(null, 0);
+  return lines.join("\n");
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/helpers/state.js
+function filterWidgetContext(state) {
+  if (state === null || state === void 0) {
+    return null;
+  }
+  const { [WIDGET_CONTEXT_KEY]: _, ...filteredState } = state;
+  return filteredState;
+}
+function injectWidgetContext(newState) {
+  if (newState === null) {
+    return null;
+  }
+  const currentState = getAdaptor().getHostContextStore("widgetState").getSnapshot();
+  if (currentState !== null && currentState !== void 0 && WIDGET_CONTEXT_KEY in currentState) {
+    return {
+      ...newState,
+      [WIDGET_CONTEXT_KEY]: currentState[WIDGET_CONTEXT_KEY]
+    };
+  }
+  return newState;
+}
+function serializeState(value) {
+  return dist_default.parse(dist_default.stringify(value));
+}
+function getInitialState(defaultState) {
+  const widgetState = getAdaptor().getHostContextStore("widgetState").getSnapshot();
+  if (widgetState !== null && widgetState !== void 0) {
+    return filterWidgetContext(widgetState);
+  }
+  return typeof defaultState === "function" ? defaultState() : defaultState ?? null;
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/create-store.js
+function createStore2(storeCreator, defaultState) {
+  const initialState = getInitialState(defaultState);
+  const store = create()((...args) => {
+    const baseStore = storeCreator(...args);
+    if (initialState !== null) {
+      return { ...baseStore, ...initialState };
+    }
+    return baseStore;
+  });
+  store.subscribe((state) => {
+    const serializedState = serializeState(state);
+    if (serializedState !== null && serializedState !== void 0) {
+      const stateToPersist = injectWidgetContext(serializedState);
+      if (stateToPersist !== null) {
+        getAdaptor().setWidgetState(stateToPersist);
+      }
+    }
+  });
+  return store;
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/hooks/use-call-tool.js
+var import_react3 = __toESM(require_react(), 1);
+var useCallTool = (name) => {
+  const [{ status, data, error }, setCallToolState] = (0, import_react3.useState)({ status: "idle", data: void 0, error: void 0 });
+  const callIdRef = (0, import_react3.useRef)(0);
+  const adaptor = getAdaptor();
+  const execute = async (toolArgs) => {
+    const callId = ++callIdRef.current;
+    setCallToolState({ status: "pending", data: void 0, error: void 0 });
+    try {
+      const data2 = await adaptor.callTool(name, toolArgs);
+      if (callId === callIdRef.current) {
+        setCallToolState({ status: "success", data: data2, error: void 0 });
+      }
+      return data2;
+    } catch (error2) {
+      if (callId === callIdRef.current) {
+        setCallToolState({ status: "error", data: void 0, error: error2 });
+      }
+      throw error2;
+    }
+  };
+  const callToolAsync = ((toolArgs) => {
+    if (toolArgs === void 0) {
+      return execute(null);
+    }
+    return execute(toolArgs);
+  });
+  const callTool = ((firstArg, sideEffects) => {
+    let toolArgs;
+    if (firstArg && typeof firstArg === "object" && ("onSuccess" in firstArg || "onError" in firstArg || "onSettled" in firstArg)) {
+      toolArgs = null;
+      sideEffects = firstArg;
+    } else {
+      toolArgs = firstArg === void 0 ? null : firstArg;
+    }
+    execute(toolArgs).then((data2) => {
+      sideEffects?.onSuccess?.(data2, toolArgs);
+      sideEffects?.onSettled?.(data2, void 0, toolArgs);
+    }).catch((error2) => {
+      sideEffects?.onError?.(error2, toolArgs);
+      sideEffects?.onSettled?.(void 0, error2, toolArgs);
+    });
+  });
+  const callToolState = {
+    status,
+    data,
+    error,
+    isIdle: status === "idle",
+    isPending: status === "pending",
+    isSuccess: status === "success",
+    isError: status === "error"
+  };
+  return {
+    ...callToolState,
+    callTool,
+    callToolAsync
+  };
+};
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/hooks/use-tool-info.js
+function deriveStatus(input, output, responseMetadata) {
+  if (input === null) {
+    return "idle";
+  }
+  if (output === null && responseMetadata === null) {
+    return "pending";
+  }
+  return "success";
+}
+function useToolInfo() {
+  const input = useHostContext("toolInput");
+  const output = useHostContext("toolOutput");
+  const responseMetadata = useHostContext("toolResponseMetadata");
+  const status = deriveStatus(input, output, responseMetadata);
+  return {
+    input,
+    status,
+    isIdle: status === "idle",
+    isPending: status === "pending",
+    isSuccess: status === "success",
+    output,
+    responseMetadata
+  };
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/generate-helpers.js
+function generateHelpers() {
+  return {
+    /**
+     * Typed version of `useCallTool` that provides autocomplete for tool names
+     * and type inference for inputs and outputs.
+     *
+     * @param name - The name of the widget to call. Autocompletes based on your server's widget registry.
+     * @returns A hook with typed `callTool` function and `data` property.
+     *
+     * @example
+     * ```typescript
+     * const { callTool, data, isPending } = useCallTool("search-voyage");
+     * // TypeScript knows callTool expects { destination: string }
+     * callTool({ destination: "Spain" });
+     *
+     * // data.structuredContent is typed based on your outputSchema
+     * if (data) {
+     *   console.log(data.structuredContent.results);
+     * }
+     * ```
+     */
+    useCallTool: (name) => {
+      return useCallTool(name);
+    },
+    /**
+     * Typed version of `useToolInfo` that provides autocomplete for widget names
+     * and type inference for inputs, outputs, and responseMetadata.
+     *
+     * @typeParam K - The name of the widget. Autocompletes based on your server's widget registry.
+     * @returns A discriminated union with `status: "pending" | "success"` that narrows correctly.
+     *
+     * @example
+     * ```typescript
+     * const toolInfo = useToolInfo<"search-voyage">();
+     * // toolInfo.input is typed as { destination: string; ... }
+     * // toolInfo.output is typed as { results: Array<...>; ... }
+     * // toolInfo.responseMetadata is typed based on _meta in callback return
+     * // toolInfo.status narrows correctly: "pending" | "success"
+     *
+     * if (toolInfo.isPending) {
+     *   // TypeScript knows output and responseMetadata are undefined here
+     *   console.log(toolInfo.input.destination);
+     * }
+     *
+     * if (toolInfo.isSuccess) {
+     *   // TypeScript knows output and responseMetadata are defined here
+     *   console.log(toolInfo.output.results);
+     *   console.log(toolInfo.responseMetadata);
+     * }
+     * ```
+     */
+    useToolInfo: () => {
+      return useToolInfo();
+    }
+  };
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/hooks/use-display-mode.js
+var import_react4 = __toESM(require_react(), 1);
+function useDisplayMode() {
+  const displayMode = useHostContext("displayMode");
+  const adaptor = getAdaptor();
+  const setDisplayMode = (0, import_react4.useCallback)((mode) => adaptor.requestDisplayMode(mode), [adaptor]);
+  return [displayMode, setDisplayMode];
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/hooks/use-files.js
+function useFiles() {
+  const adaptor = getAdaptor();
+  return {
+    upload: adaptor.uploadFile,
+    getDownloadUrl: adaptor.getFileDownloadUrl
+  };
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/hooks/use-layout.js
+function useLayout() {
+  const theme = useHostContext("theme");
+  const maxHeight = useHostContext("maxHeight");
+  const safeArea = useHostContext("safeArea");
+  return { theme, maxHeight, safeArea };
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/hooks/use-open-external.js
+var import_react5 = __toESM(require_react(), 1);
+function useOpenExternal() {
+  const adaptor = getAdaptor();
+  const openExternal = (0, import_react5.useCallback)((href) => adaptor.openExternal(href), [adaptor]);
+  return openExternal;
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/hooks/use-request-modal.js
+var import_react6 = __toESM(require_react(), 1);
+function useRequestModal() {
+  const adaptor = getAdaptor();
+  const view = useHostContext("view");
+  const open = (0, import_react6.useCallback)((opts) => adaptor.openModal(opts), [adaptor]);
+  return {
+    isOpen: view.mode === "modal",
+    params: view.params,
+    open
+  };
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/hooks/use-send-follow-up-message.js
+var import_react7 = __toESM(require_react(), 1);
+function useSendFollowUpMessage() {
+  const adaptor = getAdaptor();
+  const sendFollowUpMessage = (0, import_react7.useCallback)((prompt) => adaptor.sendFollowUpMessage(prompt), [adaptor]);
+  return sendFollowUpMessage;
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/hooks/use-set-open-in-app-url.js
+var import_react8 = __toESM(require_react(), 1);
+function useSetOpenInAppUrl() {
+  const adaptor = getAdaptor();
+  const setOpenInAppUrl = (0, import_react8.useCallback)((href) => adaptor.setOpenInAppUrl(href), [adaptor]);
+  return setOpenInAppUrl;
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/hooks/use-user.js
+function useUser() {
+  const locale = useHostContext("locale");
+  const userAgent = useHostContext("userAgent");
+  return { locale, userAgent };
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/hooks/use-widget-state.js
+var import_react9 = __toESM(require_react(), 1);
+function useWidgetState(defaultState) {
+  const adaptor = getAdaptor();
+  const widgetStateFromBridge = useHostContext("widgetState");
+  const [widgetState, _setWidgetState] = (0, import_react9.useState)(() => {
+    if (widgetStateFromBridge !== null) {
+      return filterWidgetContext(widgetStateFromBridge);
+    }
+    return typeof defaultState === "function" ? defaultState() : defaultState ?? null;
+  });
+  (0, import_react9.useEffect)(() => {
+    if (widgetStateFromBridge !== null) {
+      _setWidgetState(filterWidgetContext(widgetStateFromBridge));
+    }
+  }, [widgetStateFromBridge]);
+  const setWidgetState = (0, import_react9.useCallback)((state) => {
+    _setWidgetState((prevState) => {
+      const newState = typeof state === "function" ? state(prevState) : state;
+      const stateToSet = injectWidgetContext(newState);
+      if (stateToSet !== null) {
+        adaptor.setWidgetState(stateToSet);
+      }
+      return filterWidgetContext(stateToSet);
+    });
+  }, [adaptor]);
+  return [widgetState, setWidgetState];
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/mount-widget.js
+var import_react10 = __toESM(require_react(), 1);
+var import_client = __toESM(require_client(), 1);
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/proxy.js
+var colors = {
+  brand: "#6366f1",
+  info: "#22223b",
+  success: "#22c55e",
+  error: "#ef4444"
+};
+function installOpenAILoggingProxy() {
+  if (typeof window === "undefined" || !window.openai) {
+    return;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(window, "openai");
+  if (descriptor?.configurable === false || descriptor?.writable === false) {
+    console.warn("[openai-proxy] window.openai is not configurable or writable, skipping proxy installation");
+    return;
+  }
+  const originalOpenAI = window.openai;
+  const handler = {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      return (...args) => {
+        const methodName = String(prop);
+        console.group(`%c[openai] %cmethod %c${methodName}`, `color: ${colors.brand}; font-weight: normal`, `color: ${colors.info}; font-weight: normal`, `color: ${colors.success}`);
+        console.log("%c← args:", `color: ${colors.info}`, args);
+        const result = value.apply(target, args);
+        if (result && typeof result.then === "function") {
+          return result.then((resolved) => {
+            console.log("%c→ resolved:", `color: ${colors.success}`, resolved);
+            console.groupEnd();
+            return resolved;
+          }, (error) => {
+            console.error("%c→ rejected:", `color: ${colors.error}`, error);
+            console.groupEnd();
+            throw error;
+          });
+        }
+        console.log("%c→ returned:", `color: ${colors.success}`, result);
+        console.groupEnd();
+        return result;
+      };
+    },
+    set(target, prop, value, receiver) {
+      console.log(`%c[openai] %cupdate %c${String(prop)}`, `color: ${colors.brand}`, `color: ${colors.info}`, `color: ${colors.success}; font-weight: bold`, "←", value);
+      return Reflect.set(target, prop, value, receiver);
+    }
+  };
+  window.openai = new Proxy(originalOpenAI, handler);
+  console.log("%c[openai-proxy] %cInstalled logging proxy for window.openai", `color: ${colors.brand}`, `color: ${colors.info}`);
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/mount-widget.js
+var rootInstance = null;
+var mountWidget = (component) => {
+  const rootElement = document.getElementById("root");
+  if (!rootElement) {
+    throw new Error("Root element not found");
+  }
+  if (!rootInstance) {
+    rootInstance = (0, import_client.createRoot)(rootElement);
+  }
+  if (import.meta.env.DEV) {
+    installOpenAILoggingProxy();
+  }
+  const hostType = window.skybridge?.hostType;
+  (async () => {
+    let app = component;
+    if (hostType === "mcp-app") {
+      const { ModalProvider } = await import("./modal-provider-67CS7MKL.js");
+      app = (0, import_react10.createElement)(ModalProvider, null, component);
+    }
+    rootInstance.render((0, import_react10.createElement)(import_react10.StrictMode, null, app));
+  })();
+};
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/plugin/transform-data-llm.js
+var LLM_IMPORT_SOURCE = "skybridge/web";
+function createBabelPlugin(t) {
+  return {
+    name: "data-llm-babel",
+    visitor: {
+      Program: {
+        enter(path, state) {
+          state.hasDataLLMImport = false;
+          state.needsDataLLMImport = false;
+          for (const node of path.node.body) {
+            if (!t.isImportDeclaration(node)) {
+              continue;
+            }
+            if (node.source.value !== LLM_IMPORT_SOURCE) {
+              continue;
+            }
+            const hasSpecifier = node.specifiers.some((s) => t.isImportSpecifier(s) && t.isIdentifier(s.imported, { name: "DataLLM" }));
+            if (hasSpecifier) {
+              state.hasDataLLMImport = true;
+              break;
+            }
+          }
+        },
+        exit(path, state) {
+          if (state.needsDataLLMImport && !state.hasDataLLMImport) {
+            const importDecl = t.importDeclaration([
+              t.importSpecifier(t.identifier("DataLLM"), t.identifier("DataLLM"))
+            ], t.stringLiteral(LLM_IMPORT_SOURCE));
+            path.node.body.unshift(importDecl);
+          }
+        }
+      },
+      JSXElement(path, state) {
+        const opening = path.node.openingElement;
+        const attributes = opening.attributes;
+        const llmAttributeIndex = attributes.findIndex((attribute) => t.isJSXAttribute(attribute) && t.isJSXIdentifier(attribute.name, { name: "data-llm" }));
+        if (llmAttributeIndex === -1) {
+          return;
+        }
+        const llmAttribute = attributes[llmAttributeIndex];
+        let contentExpression;
+        if (t.isStringLiteral(llmAttribute.value)) {
+          contentExpression = llmAttribute.value;
+        } else if (t.isJSXExpressionContainer(llmAttribute.value)) {
+          contentExpression = llmAttribute.value.expression;
+        } else {
+          return;
+        }
+        const contentAttr = t.jsxAttribute(t.jsxIdentifier("content"), t.isStringLiteral(contentExpression) ? contentExpression : t.jsxExpressionContainer(contentExpression));
+        const filteredAttributes = attributes.filter((_, index) => index !== llmAttributeIndex);
+        const newOpening = t.jsxOpeningElement(opening.name, filteredAttributes, opening.selfClosing);
+        const elementWithoutLlm = t.jsxElement(newOpening, path.node.closingElement, path.node.children, path.node.selfClosing);
+        const llmOpening = t.jsxOpeningElement(t.jsxIdentifier("DataLLM"), [
+          contentAttr
+        ]);
+        const llmClosing = t.jsxClosingElement(t.jsxIdentifier("DataLLM"));
+        const wrapped = t.jsxElement(llmOpening, llmClosing, [elementWithoutLlm], false);
+        state.needsDataLLMImport = true;
+        path.replaceWith(wrapped);
+      }
+    }
+  };
+}
+var transform = async (code, id) => {
+  if (!/\.(jsx|tsx)$/.test(id)) {
+    return null;
+  }
+  if (id.includes("node_modules")) {
+    return null;
+  }
+  const { types: t, transformSync } = await import("./lib-355XMAFY.js");
+  const babelOptions = {
+    plugins: [createBabelPlugin(t)],
+    parserOpts: {
+      plugins: ["jsx", "typescript"]
+    },
+    filename: id,
+    sourceFileName: id
+  };
+  const result = transformSync(code, babelOptions);
+  if (!result || !result.code) {
+    return null;
+  }
+  return {
+    code: result.code,
+    map: result.map || null
+  };
+};
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/plugin/plugin.js
+function skybridge() {
+  return {
+    name: "skybridge",
+    async config(config) {
+      const { globSync } = await import("./node_fs-3RO563AW.js");
+      const { basename, dirname, parse: parse2, resolve } = await import("./node_path-5FHEC5YD.js");
+      const projectRoot = config.root || process.cwd();
+      const flatWidgetPattern = resolve(projectRoot, "src/widgets/*.{js,ts,jsx,tsx,html}");
+      const dirWidgetPattern = resolve(projectRoot, "src/widgets/*/index.tsx");
+      const flatWidgets = globSync(flatWidgetPattern).map((file) => {
+        const name = parse2(file).name;
+        return [name, file];
+      });
+      const dirWidgets = globSync(dirWidgetPattern).map((file) => {
+        const name = basename(dirname(file));
+        return [name, file];
+      });
+      const input = Object.fromEntries([...flatWidgets, ...dirWidgets]);
+      return {
+        base: "/assets",
+        build: {
+          manifest: true,
+          minify: true,
+          cssCodeSplit: false,
+          rollupOptions: {
+            input
+          }
+        },
+        experimental: {
+          renderBuiltUrl: (filename) => {
+            return {
+              runtime: `window.skybridge.serverUrl + "/assets/${filename}"`
+            };
+          }
+        }
+      };
+    },
+    enforce: "pre",
+    async transform(code, id) {
+      return await transform(code, id);
+    }
+  };
+}
+
+// ../../../node_modules/.pnpm/skybridge@0.32.0_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__@skybridge+devtools@0.32.0_8c938528707c936d391357462b94034d/node_modules/skybridge/dist/web/types.js
+var import_react11 = __toESM(require_react(), 1);
+export {
+  AppsSdkAdaptor,
+  AppsSdkBridge,
+  DataLLM,
+  McpAppAdaptor,
+  McpAppBridge,
+  SET_GLOBALS_EVENT_TYPE,
+  SetGlobalsEvent,
+  TOOL_RESPONSE_EVENT_TYPE,
+  WIDGET_CONTEXT_KEY,
+  createStore2 as createStore,
+  generateHelpers,
+  getAdaptor,
+  mountWidget,
+  skybridge,
+  useAppsSdkContext,
+  useCallTool,
+  useDisplayMode,
+  useFiles,
+  useHostContext,
+  useLayout,
+  useMcpAppContext,
+  useOpenExternal,
+  useRequestModal,
+  useSendFollowUpMessage,
+  useSetOpenInAppUrl,
+  useToolInfo,
+  useUser,
+  useWidgetState
+};
+//# sourceMappingURL=skybridge_web.js.map