@4djs/assistant 0.0.0 → 0.0.1

package/dist/core/index.js

@@ -0,0 +1,2876 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../../node_modules/.bun/react@19.2.7/node_modules/react/cjs/react.development.js
+var require_react_development = __commonJS((exports, module) => {
+  (function() {
+    function defineDeprecationWarning(methodName, info) {
+      Object.defineProperty(Component.prototype, methodName, {
+        get: function() {
+          console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
+        }
+      });
+    }
+    function getIteratorFn(maybeIterable) {
+      if (maybeIterable === null || typeof maybeIterable !== "object")
+        return null;
+      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+      return typeof maybeIterable === "function" ? maybeIterable : null;
+    }
+    function warnNoop(publicInstance, callerName) {
+      publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
+      var warningKey = publicInstance + "." + callerName;
+      didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, publicInstance), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
+    }
+    function Component(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    function ComponentDummy() {}
+    function PureComponent(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    function noop() {}
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+        return testStringCoercion(value);
+      }
+    }
+    function getComponentNameFromType(type) {
+      if (type == null)
+        return null;
+      if (typeof type === "function")
+        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if (typeof type === "string")
+        return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+        case REACT_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if (typeof type === "object")
+        switch (typeof type.tag === "number" && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+          case REACT_PORTAL_TYPE:
+            return "Portal";
+          case REACT_CONTEXT_TYPE:
+            return type.displayName || "Context";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = type !== "" ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, innerType !== null ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
+            try {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {}
+        }
+      return null;
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE)
+        return "<>";
+      if (typeof type === "object" && type !== null && type.$$typeof === REACT_LAZY_TYPE)
+        return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return dispatcher === null ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning)
+          return false;
+      }
+      return config.key !== undefined;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+      componentName = this.props.ref;
+      return componentName !== undefined ? componentName : null;
+    }
+    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+      var refProp = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      (refProp !== undefined ? refProp : null) !== null ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function cloneAndReplaceKey(oldElement, newKey) {
+      newKey = ReactElement(oldElement.type, newKey, oldElement.props, oldElement._owner, oldElement._debugStack, oldElement._debugTask);
+      oldElement._store && (newKey._store.validated = oldElement._store.validated);
+      return newKey;
+    }
+    function validateChildKeys(node) {
+      isValidElement(node) ? node._store && (node._store.validated = 1) : typeof node === "object" && node !== null && node.$$typeof === REACT_LAZY_TYPE && (node._payload.status === "fulfilled" ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    }
+    function isValidElement(object) {
+      return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function escape(key) {
+      var escaperLookup = { "=": "=0", ":": "=2" };
+      return "$" + key.replace(/[=:]/g, function(match) {
+        return escaperLookup[match];
+      });
+    }
+    function getElementKey(element, index) {
+      return typeof element === "object" && element !== null && element.key != null ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
+    }
+    function resolveThenable(thenable) {
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+        default:
+          switch (typeof thenable.status === "string" ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(function(fulfilledValue) {
+            thenable.status === "pending" && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+          }, function(error) {
+            thenable.status === "pending" && (thenable.status = "rejected", thenable.reason = error);
+          })), thenable.status) {
+            case "fulfilled":
+              return thenable.value;
+            case "rejected":
+              throw thenable.reason;
+          }
+      }
+      throw thenable;
+    }
+    function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+      var type = typeof children;
+      if (type === "undefined" || type === "boolean")
+        children = null;
+      var invokeCallback = false;
+      if (children === null)
+        invokeCallback = true;
+      else
+        switch (type) {
+          case "bigint":
+          case "string":
+          case "number":
+            invokeCallback = true;
+            break;
+          case "object":
+            switch (children.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+              case REACT_PORTAL_TYPE:
+                invokeCallback = true;
+                break;
+              case REACT_LAZY_TYPE:
+                return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback);
+            }
+        }
+      if (invokeCallback) {
+        invokeCallback = children;
+        callback = callback(invokeCallback);
+        var childKey = nameSoFar === "" ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
+        isArrayImpl(callback) ? (escapedPrefix = "", childKey != null && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
+          return c;
+        })) : callback != null && (isValidElement(callback) && (callback.key != null && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(callback, escapedPrefix + (callback.key == null || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + childKey), nameSoFar !== "" && invokeCallback != null && isValidElement(invokeCallback) && invokeCallback.key == null && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
+        return 1;
+      }
+      invokeCallback = 0;
+      childKey = nameSoFar === "" ? "." : nameSoFar + ":";
+      if (isArrayImpl(children))
+        for (var i = 0;i < children.length; i++)
+          nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+      else if (i = getIteratorFn(children), typeof i === "function")
+        for (i === children.entries && (didWarnAboutMaps || console.warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = true), children = i.call(children), i = 0;!(nameSoFar = children.next()).done; )
+          nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+      else if (type === "object") {
+        if (typeof children.then === "function")
+          return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback);
+        array = String(children);
+        throw Error("Objects are not valid as a React child (found: " + (array === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead.");
+      }
+      return invokeCallback;
+    }
+    function mapChildren(children, func, context) {
+      if (children == null)
+        return children;
+      var result = [], count = 0;
+      mapIntoArray(children, result, "", "", function(child) {
+        return func.call(context, child, count++);
+      });
+      return result;
+    }
+    function lazyInitializer(payload) {
+      if (payload._status === -1) {
+        var ioInfo = payload._ioInfo;
+        ioInfo != null && (ioInfo.start = ioInfo.end = performance.now());
+        ioInfo = payload._result;
+        var thenable = ioInfo();
+        thenable.then(function(moduleObject) {
+          if (payload._status === 0 || payload._status === -1) {
+            payload._status = 1;
+            payload._result = moduleObject;
+            var _ioInfo = payload._ioInfo;
+            _ioInfo != null && (_ioInfo.end = performance.now());
+            thenable.status === undefined && (thenable.status = "fulfilled", thenable.value = moduleObject);
+          }
+        }, function(error) {
+          if (payload._status === 0 || payload._status === -1) {
+            payload._status = 2;
+            payload._result = error;
+            var _ioInfo2 = payload._ioInfo;
+            _ioInfo2 != null && (_ioInfo2.end = performance.now());
+            thenable.status === undefined && (thenable.status = "rejected", thenable.reason = error);
+          }
+        });
+        ioInfo = payload._ioInfo;
+        if (ioInfo != null) {
+          ioInfo.value = thenable;
+          var displayName = thenable.displayName;
+          typeof displayName === "string" && (ioInfo.name = displayName);
+        }
+        payload._status === -1 && (payload._status = 0, payload._result = thenable);
+      }
+      if (payload._status === 1)
+        return ioInfo = payload._result, ioInfo === undefined && console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`, ioInfo), "default" in ioInfo || console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`, ioInfo), ioInfo.default;
+      throw payload._result;
+    }
+    function resolveDispatcher() {
+      var dispatcher = ReactSharedInternals.H;
+      dispatcher === null && console.error(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`);
+      return dispatcher;
+    }
+    function releaseAsyncTransition() {
+      ReactSharedInternals.asyncTransitions--;
+    }
+    function enqueueTask(task) {
+      if (enqueueTaskImpl === null)
+        try {
+          var requireString = ("require" + Math.random()).slice(0, 7);
+          enqueueTaskImpl = (module && module[requireString]).call(module, "timers").setImmediate;
+        } catch (_err) {
+          enqueueTaskImpl = function(callback) {
+            didWarnAboutMessageChannel === false && (didWarnAboutMessageChannel = true, typeof MessageChannel === "undefined" && console.error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."));
+            var channel = new MessageChannel;
+            channel.port1.onmessage = callback;
+            channel.port2.postMessage(undefined);
+          };
+        }
+      return enqueueTaskImpl(task);
+    }
+    function aggregateErrors(errors) {
+      return 1 < errors.length && typeof AggregateError === "function" ? new AggregateError(errors) : errors[0];
+    }
+    function popActScope(prevActQueue, prevActScopeDepth) {
+      prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
+      actScopeDepth = prevActScopeDepth;
+    }
+    function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+      var queue = ReactSharedInternals.actQueue;
+      if (queue !== null)
+        if (queue.length !== 0)
+          try {
+            flushActQueue(queue);
+            enqueueTask(function() {
+              return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+            });
+            return;
+          } catch (error) {
+            ReactSharedInternals.thrownErrors.push(error);
+          }
+        else
+          ReactSharedInternals.actQueue = null;
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
+    }
+    function flushActQueue(queue) {
+      if (!isFlushing) {
+        isFlushing = true;
+        var i = 0;
+        try {
+          for (;i < queue.length; i++) {
+            var callback = queue[i];
+            do {
+              ReactSharedInternals.didUsePromise = false;
+              var continuation = callback(false);
+              if (continuation !== null) {
+                if (ReactSharedInternals.didUsePromise) {
+                  queue[i] = callback;
+                  queue.splice(0, i);
+                  return;
+                }
+                callback = continuation;
+              } else
+                break;
+            } while (1);
+          }
+          queue.length = 0;
+        } catch (error) {
+          queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
+        } finally {
+          isFlushing = false;
+        }
+      }
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
+      isMounted: function() {
+        return false;
+      },
+      enqueueForceUpdate: function(publicInstance) {
+        warnNoop(publicInstance, "forceUpdate");
+      },
+      enqueueReplaceState: function(publicInstance) {
+        warnNoop(publicInstance, "replaceState");
+      },
+      enqueueSetState: function(publicInstance) {
+        warnNoop(publicInstance, "setState");
+      }
+    }, assign = Object.assign, emptyObject = {};
+    Object.freeze(emptyObject);
+    Component.prototype.isReactComponent = {};
+    Component.prototype.setState = function(partialState, callback) {
+      if (typeof partialState !== "object" && typeof partialState !== "function" && partialState != null)
+        throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
+      this.updater.enqueueSetState(this, partialState, callback, "setState");
+    };
+    Component.prototype.forceUpdate = function(callback) {
+      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+    };
+    var deprecatedAPIs = {
+      isMounted: [
+        "isMounted",
+        "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+      ],
+      replaceState: [
+        "replaceState",
+        "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+      ]
+    };
+    for (fnName in deprecatedAPIs)
+      deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+    ComponentDummy.prototype = Component.prototype;
+    deprecatedAPIs = PureComponent.prototype = new ComponentDummy;
+    deprecatedAPIs.constructor = PureComponent;
+    assign(deprecatedAPIs, Component.prototype);
+    deprecatedAPIs.isPureReactComponent = true;
+    var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = {
+      H: null,
+      A: null,
+      T: null,
+      S: null,
+      actQueue: null,
+      asyncTransitions: 0,
+      isBatchingLegacy: false,
+      didScheduleLegacyUpdate: false,
+      didUsePromise: false,
+      thrownErrors: [],
+      getCurrentStack: null,
+      recentlyCreatedOwnerStacks: 0
+    }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    deprecatedAPIs = {
+      react_stack_bottom_frame: function(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(deprecatedAPIs, UnknownOwner)();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = typeof reportError === "function" ? reportError : function(error) {
+      if (typeof window === "object" && typeof window.ErrorEvent === "function") {
+        var event = new window.ErrorEvent("error", {
+          bubbles: true,
+          cancelable: true,
+          message: typeof error === "object" && error !== null && typeof error.message === "string" ? String(error.message) : String(error),
+          error
+        });
+        if (!window.dispatchEvent(event))
+          return;
+      } else if (typeof process === "object" && typeof process.emit === "function") {
+        process.emit("uncaughtException", error);
+        return;
+      }
+      console.error(error);
+    }, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = typeof queueMicrotask === "function" ? function(callback) {
+      queueMicrotask(function() {
+        return queueMicrotask(callback);
+      });
+    } : enqueueTask;
+    deprecatedAPIs = Object.freeze({
+      __proto__: null,
+      c: function(size) {
+        return resolveDispatcher().useMemoCache(size);
+      }
+    });
+    var fnName = {
+      map: mapChildren,
+      forEach: function(children, forEachFunc, forEachContext) {
+        mapChildren(children, function() {
+          forEachFunc.apply(this, arguments);
+        }, forEachContext);
+      },
+      count: function(children) {
+        var n = 0;
+        mapChildren(children, function() {
+          n++;
+        });
+        return n;
+      },
+      toArray: function(children) {
+        return mapChildren(children, function(child) {
+          return child;
+        }) || [];
+      },
+      only: function(children) {
+        if (!isValidElement(children))
+          throw Error("React.Children.only expected to receive a single React element child.");
+        return children;
+      }
+    };
+    exports.Activity = REACT_ACTIVITY_TYPE;
+    exports.Children = fnName;
+    exports.Component = Component;
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.Profiler = REACT_PROFILER_TYPE;
+    exports.PureComponent = PureComponent;
+    exports.StrictMode = REACT_STRICT_MODE_TYPE;
+    exports.Suspense = REACT_SUSPENSE_TYPE;
+    exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+    exports.__COMPILER_RUNTIME = deprecatedAPIs;
+    exports.act = function(callback) {
+      var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
+      actScopeDepth++;
+      var queue = ReactSharedInternals.actQueue = prevActQueue !== null ? prevActQueue : [], didAwaitActCall = false;
+      try {
+        var result = callback();
+      } catch (error) {
+        ReactSharedInternals.thrownErrors.push(error);
+      }
+      if (0 < ReactSharedInternals.thrownErrors.length)
+        throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+      if (result !== null && typeof result === "object" && typeof result.then === "function") {
+        var thenable = result;
+        queueSeveralMicrotasks(function() {
+          didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
+        });
+        return {
+          then: function(resolve, reject) {
+            didAwaitActCall = true;
+            thenable.then(function(returnValue) {
+              popActScope(prevActQueue, prevActScopeDepth);
+              if (prevActScopeDepth === 0) {
+                try {
+                  flushActQueue(queue), enqueueTask(function() {
+                    return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                  });
+                } catch (error$0) {
+                  ReactSharedInternals.thrownErrors.push(error$0);
+                }
+                if (0 < ReactSharedInternals.thrownErrors.length) {
+                  var _thrownError = aggregateErrors(ReactSharedInternals.thrownErrors);
+                  ReactSharedInternals.thrownErrors.length = 0;
+                  reject(_thrownError);
+                }
+              } else
+                resolve(returnValue);
+            }, function(error) {
+              popActScope(prevActQueue, prevActScopeDepth);
+              0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
+            });
+          }
+        };
+      }
+      var returnValue$jscomp$0 = result;
+      popActScope(prevActQueue, prevActScopeDepth);
+      prevActScopeDepth === 0 && (flushActQueue(queue), queue.length !== 0 && queueSeveralMicrotasks(function() {
+        didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"));
+      }), ReactSharedInternals.actQueue = null);
+      if (0 < ReactSharedInternals.thrownErrors.length)
+        throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+      return {
+        then: function(resolve, reject) {
+          didAwaitActCall = true;
+          prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve, reject);
+          })) : resolve(returnValue$jscomp$0);
+        }
+      };
+    };
+    exports.cache = function(fn) {
+      return function() {
+        return fn.apply(null, arguments);
+      };
+    };
+    exports.cacheSignal = function() {
+      return null;
+    };
+    exports.captureOwnerStack = function() {
+      var getCurrentStack = ReactSharedInternals.getCurrentStack;
+      return getCurrentStack === null ? null : getCurrentStack();
+    };
+    exports.cloneElement = function(element, config, children) {
+      if (element === null || element === undefined)
+        throw Error("The argument must be a React element, but you passed " + element + ".");
+      var props = assign({}, element.props), key = element.key, owner = element._owner;
+      if (config != null) {
+        var JSCompiler_inline_result;
+        a: {
+          if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(config, "ref").get) && JSCompiler_inline_result.isReactWarning) {
+            JSCompiler_inline_result = false;
+            break a;
+          }
+          JSCompiler_inline_result = config.ref !== undefined;
+        }
+        JSCompiler_inline_result && (owner = getOwner());
+        hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
+        for (propName in config)
+          !hasOwnProperty.call(config, propName) || propName === "key" || propName === "__self" || propName === "__source" || propName === "ref" && config.ref === undefined || (props[propName] = config[propName]);
+      }
+      var propName = arguments.length - 2;
+      if (propName === 1)
+        props.children = children;
+      else if (1 < propName) {
+        JSCompiler_inline_result = Array(propName);
+        for (var i = 0;i < propName; i++)
+          JSCompiler_inline_result[i] = arguments[i + 2];
+        props.children = JSCompiler_inline_result;
+      }
+      props = ReactElement(element.type, key, props, owner, element._debugStack, element._debugTask);
+      for (key = 2;key < arguments.length; key++)
+        validateChildKeys(arguments[key]);
+      return props;
+    };
+    exports.createContext = function(defaultValue) {
+      defaultValue = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        _currentValue: defaultValue,
+        _currentValue2: defaultValue,
+        _threadCount: 0,
+        Provider: null,
+        Consumer: null
+      };
+      defaultValue.Provider = defaultValue;
+      defaultValue.Consumer = {
+        $$typeof: REACT_CONSUMER_TYPE,
+        _context: defaultValue
+      };
+      defaultValue._currentRenderer = null;
+      defaultValue._currentRenderer2 = null;
+      return defaultValue;
+    };
+    exports.createElement = function(type, config, children) {
+      for (var i = 2;i < arguments.length; i++)
+        validateChildKeys(arguments[i]);
+      i = {};
+      var key = null;
+      if (config != null)
+        for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = true, console.warn("Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform")), hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key), config)
+          hasOwnProperty.call(config, propName) && propName !== "key" && propName !== "__self" && propName !== "__source" && (i[propName] = config[propName]);
+      var childrenLength = arguments.length - 2;
+      if (childrenLength === 1)
+        i.children = children;
+      else if (1 < childrenLength) {
+        for (var childArray = Array(childrenLength), _i = 0;_i < childrenLength; _i++)
+          childArray[_i] = arguments[_i + 2];
+        Object.freeze && Object.freeze(childArray);
+        i.children = childArray;
+      }
+      if (type && type.defaultProps)
+        for (propName in childrenLength = type.defaultProps, childrenLength)
+          i[propName] === undefined && (i[propName] = childrenLength[propName]);
+      key && defineKeyPropWarningGetter(i, typeof type === "function" ? type.displayName || type.name || "Unknown" : type);
+      var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return ReactElement(type, key, i, getOwner(), propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack, propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+    exports.createRef = function() {
+      var refObject = { current: null };
+      Object.seal(refObject);
+      return refObject;
+    };
+    exports.forwardRef = function(render) {
+      render != null && render.$$typeof === REACT_MEMO_TYPE ? console.error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : typeof render !== "function" ? console.error("forwardRef requires a render function but was given %s.", render === null ? "null" : typeof render) : render.length !== 0 && render.length !== 2 && console.error("forwardRef render functions accept exactly two parameters: props and ref. %s", render.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
+      render != null && render.defaultProps != null && console.error("forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?");
+      var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
+      Object.defineProperty(elementType, "displayName", {
+        enumerable: false,
+        configurable: true,
+        get: function() {
+          return ownName;
+        },
+        set: function(name) {
+          ownName = name;
+          render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
+        }
+      });
+      return elementType;
+    };
+    exports.isValidElement = isValidElement;
+    exports.lazy = function(ctor) {
+      ctor = { _status: -1, _result: ctor };
+      var lazyType = {
+        $$typeof: REACT_LAZY_TYPE,
+        _payload: ctor,
+        _init: lazyInitializer
+      }, ioInfo = {
+        name: "lazy",
+        start: -1,
+        end: -1,
+        value: null,
+        owner: null,
+        debugStack: Error("react-stack-top-frame"),
+        debugTask: console.createTask ? console.createTask("lazy()") : null
+      };
+      ctor._ioInfo = ioInfo;
+      lazyType._debugInfo = [{ awaited: ioInfo }];
+      return lazyType;
+    };
+    exports.memo = function(type, compare) {
+      type == null && console.error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type);
+      compare = {
+        $$typeof: REACT_MEMO_TYPE,
+        type,
+        compare: compare === undefined ? null : compare
+      };
+      var ownName;
+      Object.defineProperty(compare, "displayName", {
+        enumerable: false,
+        configurable: true,
+        get: function() {
+          return ownName;
+        },
+        set: function(name) {
+          ownName = name;
+          type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
+        }
+      });
+      return compare;
+    };
+    exports.startTransition = function(scope) {
+      var prevTransition = ReactSharedInternals.T, currentTransition = {};
+      currentTransition._updatedFibers = new Set;
+      ReactSharedInternals.T = currentTransition;
+      try {
+        var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
+        onStartTransitionFinish !== null && onStartTransitionFinish(currentTransition, returnValue);
+        typeof returnValue === "object" && returnValue !== null && typeof returnValue.then === "function" && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError));
+      } catch (error) {
+        reportGlobalError(error);
+      } finally {
+        prevTransition === null && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table.")), prevTransition !== null && currentTransition.types !== null && (prevTransition.types !== null && prevTransition.types !== currentTransition.types && console.error("We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+      }
+    };
+    exports.unstable_useCacheRefresh = function() {
+      return resolveDispatcher().useCacheRefresh();
+    };
+    exports.use = function(usable) {
+      return resolveDispatcher().use(usable);
+    };
+    exports.useActionState = function(action, initialState, permalink) {
+      return resolveDispatcher().useActionState(action, initialState, permalink);
+    };
+    exports.useCallback = function(callback, deps) {
+      return resolveDispatcher().useCallback(callback, deps);
+    };
+    exports.useContext = function(Context) {
+      var dispatcher = resolveDispatcher();
+      Context.$$typeof === REACT_CONSUMER_TYPE && console.error("Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?");
+      return dispatcher.useContext(Context);
+    };
+    exports.useDebugValue = function(value, formatterFn) {
+      return resolveDispatcher().useDebugValue(value, formatterFn);
+    };
+    exports.useDeferredValue = function(value, initialValue) {
+      return resolveDispatcher().useDeferredValue(value, initialValue);
+    };
+    exports.useEffect = function(create, deps) {
+      create == null && console.warn("React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useEffect(create, deps);
+    };
+    exports.useEffectEvent = function(callback) {
+      return resolveDispatcher().useEffectEvent(callback);
+    };
+    exports.useId = function() {
+      return resolveDispatcher().useId();
+    };
+    exports.useImperativeHandle = function(ref, create, deps) {
+      return resolveDispatcher().useImperativeHandle(ref, create, deps);
+    };
+    exports.useInsertionEffect = function(create, deps) {
+      create == null && console.warn("React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useInsertionEffect(create, deps);
+    };
+    exports.useLayoutEffect = function(create, deps) {
+      create == null && console.warn("React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useLayoutEffect(create, deps);
+    };
+    exports.useMemo = function(create, deps) {
+      return resolveDispatcher().useMemo(create, deps);
+    };
+    exports.useOptimistic = function(passthrough, reducer) {
+      return resolveDispatcher().useOptimistic(passthrough, reducer);
+    };
+    exports.useReducer = function(reducer, initialArg, init) {
+      return resolveDispatcher().useReducer(reducer, initialArg, init);
+    };
+    exports.useRef = function(initialValue) {
+      return resolveDispatcher().useRef(initialValue);
+    };
+    exports.useState = function(initialState) {
+      return resolveDispatcher().useState(initialState);
+    };
+    exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
+      return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    };
+    exports.useTransition = function() {
+      return resolveDispatcher().useTransition();
+    };
+    exports.version = "19.2.7";
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })();
+});
+
+// ../../node_modules/.bun/react@19.2.7/node_modules/react/index.js
+var require_react = __commonJS((exports, module) => {
+  var react_development = __toESM(require_react_development());
+  if (false) {} else {
+    module.exports = react_development;
+  }
+});
+
+// src/core/chat-activity.ts
+function summarizeActivityResult(result) {
+  if (result === undefined || result === null)
+    return result;
+  if (typeof result !== "object")
+    return result;
+  const value = result;
+  if ("structuredContent" in value) {
+    return value.structuredContent ?? value;
+  }
+  if ("content" in value && Array.isArray(value.content)) {
+    return value.content;
+  }
+  return result;
+}
+function chatActivityStepLabel(step) {
+  if (step.status === "active") {
+    if (step.name === "request_confirmation")
+      return "Waiting for confirmation…";
+    if (step.name === "request_choices")
+      return "Waiting for your choice…";
+    if (step.name === "suggest_replies")
+      return "Suggesting replies…";
+    return `Running ${step.name}…`;
+  }
+  if (step.status === "error")
+    return `${step.name} failed`;
+  if (step.name === "request_confirmation")
+    return "Confirmation answered";
+  if (step.name === "request_choices")
+    return "Choice submitted";
+  if (step.name === "suggest_replies")
+    return "Reply suggestions shown";
+  return `Ran ${step.name}`;
+}
+function formatJsonIfLarge(raw) {
+  const trimmed = raw.trim();
+  const JSON_PRETTY_MIN_LENGTH = 80;
+  if (trimmed.length < JSON_PRETTY_MIN_LENGTH) {
+    return trimmed;
+  }
+  try {
+    return JSON.stringify(JSON.parse(trimmed), null, 2);
+  } catch {
+    return trimmed;
+  }
+}
+// src/core/chat-commands.ts
+var CHAT_COMMANDS = [
+  {
+    name: "clear",
+    description: "Clear the current conversation",
+    surfaces: ["assistant"],
+    run: async (args, deps) => {
+      if (args) {
+        throw new Error("The /clear command does not accept arguments.");
+      }
+      if (deps.streaming) {
+        throw new Error("Wait for the assistant to finish before clearing.");
+      }
+      deps.clearMessages();
+      deps.setError(null);
+    }
+  }
+];
+function getChatCommandSuggestions(surface) {
+  return CHAT_COMMANDS.filter((command) => command.surfaces.includes(surface)).map(({ name, description }) => ({
+    name,
+    description,
+    usage: `/${name}`
+  }));
+}
+function isChatCommandInput(value) {
+  return value.trimStart().startsWith("/");
+}
+function filterChatCommands(value, surface) {
+  if (!isChatCommandInput(value)) {
+    return [];
+  }
+  const query = value.trimStart().slice(1).toLowerCase();
+  const commands = getChatCommandSuggestions(surface);
+  if (!query) {
+    return commands;
+  }
+  return commands.filter((command) => command.name.startsWith(query) || command.usage.toLowerCase().startsWith(`/${query}`));
+}
+function shouldShowChatCommandMenu(value, surface) {
+  if (!isChatCommandInput(value) || value.includes(`
+`)) {
+    return false;
+  }
+  const trimmed = value.trimStart();
+  if (trimmed.includes(" ")) {
+    return false;
+  }
+  return filterChatCommands(value, surface).length > 0;
+}
+function listChatCommands(surface) {
+  return CHAT_COMMANDS.filter((command) => !surface || command.surfaces.includes(surface)).map(({ name, description }) => ({ name, description }));
+}
+function parseChatCommand(input) {
+  const trimmed = input.trim();
+  const match = /^\/([a-z][a-z0-9_-]*)(?:\s+([\s\S]*))?$/i.exec(trimmed);
+  if (!match) {
+    return null;
+  }
+  const name = match[1];
+  if (!name) {
+    return null;
+  }
+  return {
+    name: name.toLowerCase(),
+    args: (match[2] ?? "").trim()
+  };
+}
+async function executeCommand(parsed, deps) {
+  const command = CHAT_COMMANDS.find((entry) => entry.name === parsed.name);
+  if (!command?.surfaces.includes("assistant")) {
+    return {
+      handled: true,
+      clearInput: true,
+      error: `Unknown command: /${parsed.name}`
+    };
+  }
+  try {
+    await command.run(parsed.args, deps);
+    return { handled: true, clearInput: true };
+  } catch (error) {
+    return {
+      handled: true,
+      clearInput: true,
+      error: error instanceof Error ? error.message : "Command failed"
+    };
+  }
+}
+async function runAssistantChatCommand(input, deps) {
+  const parsed = parseChatCommand(input);
+  if (!parsed) {
+    return { handled: false };
+  }
+  return executeCommand(parsed, deps);
+}
+// src/core/interactive-tools/choices.ts
+var REQUEST_CHOICES_TOOL = "request_choices";
+var CHOICES_TOOL = {
+  name: REQUEST_CHOICES_TOOL,
+  description: "Present options when multiple valid paths exist and you need the user to choose before continuing. Supports single-select and multi-select.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        description: "Prompt explaining what the user should choose."
+      },
+      options: {
+        type: "array",
+        minItems: 2,
+        items: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Stable option id returned in the tool result."
+            },
+            label: {
+              type: "string",
+              description: "User-visible option label."
+            },
+            description: {
+              type: "string",
+              description: "Optional longer description for the option."
+            }
+          },
+          required: ["id", "label"],
+          additionalProperties: false
+        }
+      },
+      allowMultiple: {
+        type: "boolean",
+        description: "If true, the user may select multiple options."
+      },
+      minSelections: {
+        type: "integer",
+        description: "Minimum number of selections when allowMultiple is true. Default: 1."
+      },
+      maxSelections: {
+        type: "integer",
+        description: "Maximum number of selections when allowMultiple is true."
+      },
+      submitLabel: {
+        type: "string",
+        description: "Submit button label. Default: Continue."
+      }
+    },
+    required: ["message", "options"],
+    additionalProperties: false
+  }
+};
+function parseChoicesArgs(args) {
+  const message = String(args.message ?? "").trim();
+  if (!message) {
+    throw new Error("request_choices requires a non-empty message");
+  }
+  if (!Array.isArray(args.options) || args.options.length < 2) {
+    throw new Error("request_choices requires at least two options");
+  }
+  const options = [];
+  const seenIds = new Set;
+  for (const entry of args.options) {
+    if (!entry || typeof entry !== "object") {
+      throw new Error("Each choice option must be an object with id and label");
+    }
+    const option = entry;
+    const id = String(option.id ?? "").trim();
+    const label = String(option.label ?? "").trim();
+    if (!id || !label) {
+      throw new Error("Each choice option requires a non-empty id and label");
+    }
+    if (seenIds.has(id)) {
+      throw new Error(`Duplicate choice option id: ${id}`);
+    }
+    seenIds.add(id);
+    options.push({
+      id,
+      label,
+      description: option.description !== undefined ? String(option.description).trim() : undefined
+    });
+  }
+  const allowMultiple = Boolean(args.allowMultiple);
+  const minSelections = typeof args.minSelections === "number" && args.minSelections > 0 ? Math.floor(args.minSelections) : 1;
+  const maxSelections = typeof args.maxSelections === "number" && args.maxSelections > 0 ? Math.floor(args.maxSelections) : undefined;
+  if (allowMultiple && maxSelections !== undefined && maxSelections < minSelections) {
+    throw new Error("maxSelections must be greater than or equal to minSelections");
+  }
+  return {
+    message,
+    options,
+    allowMultiple,
+    minSelections: allowMultiple ? minSelections : 1,
+    maxSelections: allowMultiple ? maxSelections : 1,
+    submitLabel: args.submitLabel ? String(args.submitLabel).trim() : "Continue"
+  };
+}
+// src/core/interactive-tools/confirmation.ts
+var REQUEST_CONFIRMATION_TOOL = "request_confirmation";
+var CONFIRMATION_TOOL = {
+  name: REQUEST_CONFIRMATION_TOOL,
+  description: "Ask the user to confirm before proceeding with an important or irreversible action. Execution pauses until the user confirms or cancels.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        description: "Explanation or question shown to the user."
+      },
+      action: {
+        type: "string",
+        description: "Short summary of what happens if confirmed, e.g. 'Delete 3 User records'."
+      },
+      confirmLabel: {
+        type: "string",
+        description: "Confirm button label. Default: Proceed."
+      },
+      cancelLabel: {
+        type: "string",
+        description: "Cancel button label. Default: Cancel."
+      }
+    },
+    required: ["message"],
+    additionalProperties: false
+  }
+};
+function parseConfirmationArgs(args) {
+  const message = String(args.message ?? "").trim();
+  if (!message) {
+    throw new Error("request_confirmation requires a non-empty message");
+  }
+  return {
+    message,
+    action: args.action !== undefined ? String(args.action).trim() : undefined,
+    confirmLabel: args.confirmLabel ? String(args.confirmLabel).trim() : "Proceed",
+    cancelLabel: args.cancelLabel ? String(args.cancelLabel).trim() : "Cancel"
+  };
+}
+// src/core/interactive-tools/suggestions.ts
+var SUGGEST_REPLIES_TOOL = "suggest_replies";
+var SUGGEST_REPLIES_TOOL_DEFINITION = {
+  name: SUGGEST_REPLIES_TOOL,
+  description: "Required when your message asks the user a question and you can suggest 2–6 short example answers. Call as the ONLY tool in the turn, after writing the question in your message. Use for yes/no, dataclass picks, filter examples, or next-step options. The user can tap a suggestion or type their own reply.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      question: {
+        type: "string",
+        description: "The question from your message, e.g. Which dataclass should I query?"
+      },
+      suggestions: {
+        type: "array",
+        minItems: 2,
+        maxItems: 8,
+        items: {
+          type: "string",
+          description: "A short tap-to-send answer."
+        }
+      }
+    },
+    required: ["question", "suggestions"],
+    additionalProperties: false
+  }
+};
+function parseSuggestRepliesArgs(args) {
+  const question = String(args.question ?? "").trim();
+  if (!question) {
+    throw new Error("suggest_replies requires a non-empty question");
+  }
+  if (!Array.isArray(args.suggestions) || args.suggestions.length < 2) {
+    throw new Error("suggest_replies requires at least two suggestions");
+  }
+  const suggestions = args.suggestions.map((entry) => String(entry ?? "").trim()).filter((entry) => entry.length > 0);
+  if (suggestions.length < 2) {
+    throw new Error("suggest_replies requires at least two non-empty suggestions");
+  }
+  if (suggestions.length > 8) {
+    throw new Error("suggest_replies allows at most 8 suggestions");
+  }
+  return { question, suggestions };
+}
+function isValidReplySuggestions(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const entry = value;
+  if (typeof entry.question !== "string" || !entry.question.trim()) {
+    return false;
+  }
+  if (!Array.isArray(entry.suggestions) || entry.suggestions.length < 2) {
+    return false;
+  }
+  return entry.suggestions.every((suggestion) => typeof suggestion === "string" && suggestion.trim());
+}
+
+// src/core/interactive-tools/constants.ts
+var INTERACTIVE_CHAT_TOOL_NAMES = new Set([
+  REQUEST_CONFIRMATION_TOOL,
+  REQUEST_CHOICES_TOOL
+]);
+var POST_RESPONSE_CHAT_TOOL_NAMES = new Set([SUGGEST_REPLIES_TOOL]);
+function isInteractiveChatTool(name) {
+  return INTERACTIVE_CHAT_TOOL_NAMES.has(name);
+}
+function isPostResponseChatTool(name) {
+  return POST_RESPONSE_CHAT_TOOL_NAMES.has(name);
+}
+function isChatUiTool(name) {
+  return isInteractiveChatTool(name) || isPostResponseChatTool(name);
+}
+// src/core/interactive-tools/waiters.ts
+var waiters = new Map;
+function waitForInteractiveToolResult(callId, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const onAbort = () => {
+      waiters.delete(callId);
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    waiters.set(callId, {
+      resolve: (value) => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      reject: (error) => {
+        signal?.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    });
+  });
+}
+function resolveInteractiveToolResult(callId, value) {
+  const waiter = waiters.get(callId);
+  if (!waiter)
+    return false;
+  waiter.resolve(value);
+  waiters.delete(callId);
+  return true;
+}
+function rejectAllInteractiveToolWaiters(error) {
+  for (const [callId, waiter] of waiters.entries()) {
+    waiter.reject(error);
+    waiters.delete(callId);
+  }
+}
+
+// src/core/interactive-tools/execute.ts
+function getChatInteractiveTools() {
+  return [CONFIRMATION_TOOL, CHOICES_TOOL, SUGGEST_REPLIES_TOOL_DEFINITION];
+}
+async function executeChatInteractiveTool(name, args, callId, signal) {
+  if (name === REQUEST_CONFIRMATION_TOOL) {
+    parseConfirmationArgs(args);
+    const result = await waitForInteractiveToolResult(callId, signal);
+    return { content: JSON.stringify(result) };
+  }
+  if (name === REQUEST_CHOICES_TOOL) {
+    parseChoicesArgs(args);
+    const result = await waitForInteractiveToolResult(callId, signal);
+    return { content: JSON.stringify(result) };
+  }
+  if (name === SUGGEST_REPLIES_TOOL) {
+    const suggestions = parseSuggestRepliesArgs(args);
+    return {
+      content: JSON.stringify({ displayed: true }),
+      postResponse: suggestions
+    };
+  }
+  throw new Error(`Unknown chat UI tool: ${name}`);
+}
+function shouldTerminateTurnAfterTool(name) {
+  return isPostResponseChatTool(name);
+}
+// src/core/chat-history.ts
+var DEFAULT_HISTORY_KEY = "assistant-chat-history";
+var DEFAULT_MAX_STORED = 100;
+function toStored(message) {
+  return {
+    id: message.id,
+    role: message.role,
+    content: message.content,
+    activity: message.activity,
+    toolCall: message.toolCall,
+    replySuggestions: message.replySuggestions,
+    isError: message.isError,
+    llmSetupRequired: message.llmSetupRequired,
+    timestamp: message.timestamp
+  };
+}
+function fromStored(message) {
+  return {
+    id: message.id,
+    role: message.role,
+    content: message.content,
+    activity: message.activity,
+    toolCall: message.toolCall,
+    replySuggestions: isValidReplySuggestions(message.replySuggestions) ? message.replySuggestions : undefined,
+    isError: message.isError,
+    llmSetupRequired: message.llmSetupRequired,
+    timestamp: message.timestamp
+  };
+}
+function isStoredChatMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const message = value;
+  return typeof message.id === "string" && (message.role === "user" || message.role === "assistant" || message.role === "system") && typeof message.content === "string" && typeof message.timestamp === "number";
+}
+function createChatHistoryHelpers(options) {
+  const storageKey = options.storageKey ?? DEFAULT_HISTORY_KEY;
+  const maxStored = options.maxStored ?? DEFAULT_MAX_STORED;
+  function getStored() {
+    try {
+      const raw = localStorage.getItem(storageKey);
+      if (!raw)
+        return null;
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed))
+        return null;
+      const messages = parsed.filter(isStoredChatMessage).map(fromStored);
+      return messages.length > 0 ? messages : null;
+    } catch {
+      return null;
+    }
+  }
+  function persist(messages) {
+    const storable = messages.filter((message) => !message.streaming).slice(-maxStored).map(toStored);
+    localStorage.setItem(storageKey, JSON.stringify(storable));
+  }
+  function clear() {
+    localStorage.removeItem(storageKey);
+  }
+  function loadInitial(ctx) {
+    const stored = getStored();
+    const welcome = options.welcomeMessage(ctx);
+    if (stored) {
+      const hasWelcome = stored.some((message) => message.id === "welcome");
+      if (hasWelcome)
+        return stored;
+      return [welcome, ...stored];
+    }
+    return [welcome];
+  }
+  return { getStored, persist, clear, loadInitial };
+}
+// ../../node_modules/.bun/zustand@5.0.14+93dbe784b8baa420/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 getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const api = { setState, getState, getInitialState, subscribe };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+
+// ../../node_modules/.bun/zustand@5.0.14+93dbe784b8baa420/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;
+
+// src/core/llm-config.ts
+var DEFAULT_LLM_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_LLM_MODEL = "gpt-4o-mini";
+var DEFAULT_ASSISTANT_SYSTEM_PROMPT = "You are a helpful assistant with access to tools. Use tools when they help answer the user.";
+var FALLBACK_MODEL_OPTIONS = [
+  DEFAULT_LLM_MODEL,
+  "gpt-4o",
+  "gpt-4.1",
+  "gpt-4.1-mini",
+  "gpt-4.1-nano",
+  "o3-mini"
+];
+function getFallbackModels(defaultModel) {
+  return [...new Set([defaultModel, ...FALLBACK_MODEL_OPTIONS])];
+}
+function resolveRequestModel(requested, config) {
+  const candidate = requested?.trim();
+  if (candidate)
+    return candidate;
+  return config.model;
+}
+function buildCompletionsUrl(baseUrl) {
+  const base = baseUrl.replace(/\/+$/, "");
+  if (base.endsWith("/v1"))
+    return `${base}/chat/completions`;
+  return `${base}/v1/chat/completions`;
+}
+function buildModelsUrl(baseUrl) {
+  const base = baseUrl.replace(/\/+$/, "");
+  if (base.endsWith("/v1"))
+    return `${base}/models`;
+  return `${base}/v1/models`;
+}
+function isLocalLlmBaseUrl(baseUrl) {
+  try {
+    const normalized = baseUrl.includes("://") ? baseUrl : `http://${baseUrl}`;
+    const hostname = new URL(normalized).hostname.toLowerCase();
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0" || hostname === "[::1]" || hostname.endsWith(".local");
+  } catch {
+    return false;
+  }
+}
+function isLlmConfigured(settings) {
+  if (settings.enabled === false)
+    return false;
+  if (!settings.baseUrl?.trim() || !settings.model?.trim())
+    return false;
+  if (settings.apiKey?.trim())
+    return true;
+  return isLocalLlmBaseUrl(settings.baseUrl);
+}
+var LLM_UNAVAILABLE_MESSAGE = "Chat requires an LLM. Open LLM settings to add your provider base URL, model, and API key (optional for local servers).";
+function isLlmUnavailableMessage(message) {
+  return message.llmSetupRequired === true || message.content.trim() === LLM_UNAVAILABLE_MESSAGE;
+}
+function buildLlmRequestHeaders(apiKey) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  const token = apiKey?.trim();
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  return headers;
+}
+
+// src/core/llm-models.ts
+var CACHE_TTL_MS = 5 * 60 * 1000;
+var EXCLUDED_MODEL_PATTERNS = [
+  /embed/i,
+  /whisper/i,
+  /tts/i,
+  /dall-e/i,
+  /moderation/i,
+  /transcribe/i,
+  /realtime/i,
+  /audio/i,
+  /speech/i,
+  /image/i,
+  /completion$/i
+];
+var modelCache = null;
+async function fetchProviderModels(config) {
+  const cacheKey = `${config.baseUrl}:${config.apiKey?.slice(-6) ?? "local"}`;
+  if (modelCache && modelCache.key === cacheKey && Date.now() - modelCache.fetchedAt < CACHE_TTL_MS) {
+    return modelCache.models;
+  }
+  if (!config.apiKey?.trim()) {
+    if (!isLlmConfigured({ enabled: true, ...config })) {
+      return getFallbackModels(config.model);
+    }
+  }
+  try {
+    const response = await fetch(buildModelsUrl(config.baseUrl), {
+      headers: buildLlmRequestHeaders(config.apiKey)
+    });
+    if (!response.ok) {
+      return getFallbackModels(config.model);
+    }
+    const body = await response.json();
+    const models = normalizeProviderModels(body, config.model);
+    modelCache = { key: cacheKey, models, fetchedAt: Date.now() };
+    return models;
+  } catch {
+    return getFallbackModels(config.model);
+  }
+}
+function normalizeProviderModels(body, defaultModel) {
+  const ids = (body.data ?? []).map((entry) => entry.id?.trim()).filter((id) => Boolean(id)).filter(isChatModel);
+  return mergeModels(defaultModel, ids);
+}
+function isChatModel(modelId) {
+  return !EXCLUDED_MODEL_PATTERNS.some((pattern) => pattern.test(modelId));
+}
+function mergeModels(defaultModel, models) {
+  return [...new Set([defaultModel, ...models])].sort((a, b) => a.localeCompare(b));
+}
+function clearProviderModelCache() {
+  modelCache = null;
+}
+
+// src/core/llm-provider.ts
+var DISABLED_SETTINGS = {
+  enabled: false,
+  baseUrl: DEFAULT_LLM_BASE_URL,
+  apiKey: null,
+  model: DEFAULT_LLM_MODEL
+};
+var resolveSettings = null;
+function normalizeSettings(input) {
+  return {
+    enabled: input.enabled,
+    baseUrl: input.baseUrl?.trim() || DEFAULT_LLM_BASE_URL,
+    apiKey: input.apiKey?.trim() || null,
+    model: input.model?.trim() || DEFAULT_LLM_MODEL,
+    models: input.models?.length ? [...input.models] : undefined,
+    systemPrompt: input.systemPrompt?.trim() || undefined
+  };
+}
+function configureAssistantLlm(config) {
+  if (typeof config === "function") {
+    resolveSettings = async () => normalizeSettings(await config());
+    return;
+  }
+  const settings = normalizeSettings(config);
+  resolveSettings = async () => settings;
+}
+async function resolveAssistantLlmSettings() {
+  if (!resolveSettings)
+    return DISABLED_SETTINGS;
+  return resolveSettings();
+}
+function resetAssistantLlm() {
+  resolveSettings = null;
+}
+async function testLlmConnection(settings) {
+  if (!settings.apiKey?.trim() && !isLocalLlmBaseUrl(settings.baseUrl)) {
+    return {
+      ok: false,
+      error: "API key is required for remote LLM providers."
+    };
+  }
+  try {
+    const response = await fetch(buildCompletionsUrl(settings.baseUrl), {
+      method: "POST",
+      headers: buildLlmRequestHeaders(settings.apiKey),
+      body: JSON.stringify({
+        model: settings.model,
+        messages: [{ role: "user", content: "ping" }],
+        max_tokens: 1
+      })
+    });
+    if (!response.ok) {
+      const raw = await response.text();
+      let message = `Connection failed (${response.status})`;
+      try {
+        const body2 = JSON.parse(raw);
+        if (typeof body2.error === "string")
+          message = body2.error;
+        else if (typeof body2.error?.message === "string") {
+          message = body2.error.message;
+        } else if (typeof body2.message === "string") {
+          message = body2.message;
+        }
+      } catch {
+        if (raw.trim())
+          message = raw.trim();
+      }
+      return { ok: false, error: message };
+    }
+    const body = await response.json();
+    return { ok: true, model: body.model ?? settings.model };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : "Connection failed"
+    };
+  }
+}
+
+// src/core/llm-sse.ts
+function createStreamParser() {
+  let content = "";
+  let model = null;
+  const toolAcc = new Map;
+  function toolCallAt(index) {
+    const existing = toolAcc.get(index);
+    if (existing)
+      return existing;
+    const created = {
+      id: "",
+      type: "function",
+      function: { name: "", arguments: "" }
+    };
+    toolAcc.set(index, created);
+    return created;
+  }
+  function ingestLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:"))
+      return null;
+    const data = trimmed.slice(5).trim();
+    if (data === "[DONE]") {
+      return {
+        contentDelta: "",
+        content,
+        toolCalls: finalizeToolCalls(),
+        model,
+        done: true
+      };
+    }
+    let json;
+    try {
+      json = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    if (typeof json.model === "string")
+      model = json.model;
+    const choice = json.choices?.[0];
+    const delta = choice?.delta;
+    if (!delta)
+      return null;
+    let contentDelta = "";
+    if (typeof delta.content === "string" && delta.content.length > 0) {
+      contentDelta = delta.content;
+      content += contentDelta;
+    }
+    const toolDeltas = delta.tool_calls;
+    if (toolDeltas) {
+      for (const toolDelta of toolDeltas) {
+        const index = toolDelta.index ?? 0;
+        const current = toolCallAt(index);
+        if (typeof toolDelta.id === "string")
+          current.id = toolDelta.id;
+        const fn = toolDelta.function;
+        if (fn && typeof fn.name === "string")
+          current.function.name = fn.name;
+        if (fn && typeof fn.arguments === "string") {
+          current.function.arguments += fn.arguments;
+        }
+      }
+    }
+    return {
+      contentDelta,
+      content,
+      toolCalls: finalizeToolCalls(),
+      model,
+      done: false
+    };
+  }
+  function finalizeToolCalls() {
+    return [...toolAcc.entries()].sort(([a], [b]) => a - b).map(([, value]) => value).filter((value) => Boolean(value.id && value.function.name));
+  }
+  return { ingestLine };
+}
+async function readSseStream(body, onChunk, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  const parser = createStreamParser();
+  let buffer = "";
+  let last = {
+    contentDelta: "",
+    content: "",
+    toolCalls: [],
+    model: null,
+    done: false
+  };
+  const abort = () => {
+    reader.cancel();
+  };
+  if (signal?.aborted) {
+    abort();
+    throw new DOMException("Aborted", "AbortError");
+  }
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+      }
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const chunk = parser.ingestLine(line);
+        if (!chunk)
+          continue;
+        last = chunk;
+        onChunk(chunk);
+        if (chunk.done)
+          return chunk;
+      }
+    }
+  } finally {
+    signal?.removeEventListener("abort", abort);
+  }
+  if (buffer.trim()) {
+    const chunk = parser.ingestLine(buffer);
+    if (chunk) {
+      last = { ...chunk, done: true };
+      onChunk(last);
+    }
+  }
+  return { ...last, done: true };
+}
+
+// src/core/llm-chat.ts
+var MAX_AGENT_STEPS = 8;
+var DEFAULT_SYSTEM_PROMPT = "You are a helpful assistant with access to tools. Use tools when they help answer the user.";
+
+class LlmNotConfiguredError extends Error {
+  code = "LLM_DISABLED";
+  constructor(message = "LLM is not configured. Provide llm settings with a valid apiKey.") {
+    super(message);
+    this.name = "LlmNotConfiguredError";
+  }
+}
+
+class LlmUpstreamError extends Error {
+  status;
+  code;
+  constructor(message, status, code = "LLM_UPSTREAM_ERROR") {
+    super(message);
+    this.name = "LlmUpstreamError";
+    this.status = status;
+    this.code = code;
+  }
+}
+
+class ChatAbortedError extends Error {
+  constructor() {
+    super("Chat aborted");
+    this.name = "ChatAbortedError";
+  }
+}
+async function fetchLlmStatus() {
+  try {
+    const config = await resolveAssistantLlmSettings();
+    if (!isLlmConfigured(config)) {
+      return { enabled: false, model: null, models: [] };
+    }
+    const models = config.models?.length ? config.models : await fetchProviderModels(config);
+    return {
+      enabled: true,
+      model: config.model,
+      models
+    };
+  } catch {
+    return { enabled: false, model: null, models: [] };
+  }
+}
+async function requestLlmCompletion(input) {
+  if (input.stream) {
+    return requestLlmCompletionStream(input, input.stream);
+  }
+  const settings = await requireLlmSettings();
+  const payload = buildChatPayload(input, settings);
+  const res = await fetch(buildCompletionsUrl(settings.baseUrl), {
+    method: "POST",
+    headers: buildLlmRequestHeaders(settings.apiKey),
+    body: JSON.stringify(payload),
+    signal: input.signal
+  });
+  const raw = await res.text();
+  let data = {};
+  try {
+    data = raw ? JSON.parse(raw) : {};
+  } catch {
+    throw new LlmUpstreamError(`LLM returned non-JSON response (${res.status})`, 502, "LLM_BAD_RESPONSE");
+  }
+  if (!res.ok) {
+    throw upstreamError(data, res.status);
+  }
+  const choice = data.choices?.[0];
+  const message = choice?.message;
+  if (!message) {
+    throw new LlmUpstreamError("LLM response missing message", 502, "LLM_BAD_RESPONSE");
+  }
+  return {
+    content: message.content ?? null,
+    toolCalls: message.tool_calls ?? [],
+    model: typeof data.model === "string" ? data.model : settings.model
+  };
+}
+async function requestLlmCompletionStream(input, handlers) {
+  const settings = await requireLlmSettings();
+  const payload = buildChatPayload(input, settings);
+  try {
+    const res = await fetch(buildCompletionsUrl(settings.baseUrl), {
+      method: "POST",
+      headers: buildLlmRequestHeaders(settings.apiKey),
+      body: JSON.stringify({ ...payload, stream: true }),
+      signal: input.signal
+    });
+    if (!res.ok) {
+      const raw = await res.text();
+      let data = {};
+      try {
+        data = raw ? JSON.parse(raw) : {};
+      } catch {}
+      throw upstreamError(data, res.status);
+    }
+    if (!res.body) {
+      throw new LlmUpstreamError("LLM stream missing body", 502, "LLM_BAD_RESPONSE");
+    }
+    const final = await readSseStream(res.body, (chunk) => {
+      if (chunk.contentDelta) {
+        handlers.onUpdate(chunk.content);
+      }
+    }, input.signal);
+    return {
+      content: final.content || null,
+      toolCalls: final.toolCalls,
+      model: final.model ?? settings.model
+    };
+  } catch (error) {
+    if (input.signal?.aborted || error instanceof DOMException && error.name === "AbortError") {
+      throw new ChatAbortedError;
+    }
+    throw error;
+  }
+}
+async function runLlmAgent(input) {
+  const apiMessages = [
+    ...input.history,
+    { role: "user", content: input.userMessage }
+  ];
+  let lastToolResult;
+  const clientTools = [
+    ...input.tools.map(toClientTool),
+    ...getChatInteractiveTools()
+  ];
+  let finalContent = "";
+  let endedWithPostResponseTool = false;
+  for (let step = 0;step < MAX_AGENT_STEPS; step++) {
+    if (input.signal?.aborted) {
+      throw new ChatAbortedError;
+    }
+    const completion = await requestLlmCompletion({
+      messages: apiMessages,
+      tools: clientTools,
+      model: input.model,
+      signal: input.signal,
+      stream: input.stream ? {
+        turnId: input.stream.turnId,
+        onUpdate: (content) => {
+          finalContent = content;
+          input.stream?.onUpdate(content);
+        }
+      } : undefined
+    });
+    if (completion.toolCalls.length === 0) {
+      finalContent = completion.content?.trim() || "I couldn't produce a response. Try rephrasing your request.";
+      input.stream?.onUpdate(finalContent);
+      apiMessages.push({
+        role: "assistant",
+        content: completion.content
+      });
+      break;
+    }
+    apiMessages.push({
+      role: "assistant",
+      content: completion.content,
+      tool_calls: completion.toolCalls
+    });
+    let terminatesTurn = false;
+    for (const call of completion.toolCalls) {
+      const args = parseToolArguments(call.function.arguments);
+      const stepId = crypto.randomUUID();
+      input.toolHandlers?.onStart({
+        id: stepId,
+        name: call.function.name,
+        args,
+        callId: call.id
+      });
+      let toolContent;
+      let finishUpdate;
+      if (isChatUiTool(call.function.name)) {
+        try {
+          const interactiveResult = await executeChatInteractiveTool(call.function.name, args, call.id, input.signal);
+          toolContent = interactiveResult.content;
+          finishUpdate = {
+            status: interactiveResult.isError ? "error" : "done",
+            result: JSON.parse(interactiveResult.content)
+          };
+          if (interactiveResult.postResponse) {
+            input.onPostResponseTool?.(interactiveResult.postResponse);
+            terminatesTurn = true;
+          }
+        } catch (error) {
+          if (input.signal?.aborted || error instanceof DOMException && error.name === "AbortError") {
+            throw new ChatAbortedError;
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          toolContent = message;
+          finishUpdate = { status: "error", error: message };
+        }
+      } else {
+        const result = await input.invokeTool(call.function.name, args);
+        lastToolResult = result;
+        toolContent = formatToolResult(result);
+        finishUpdate = {
+          status: result.isError ? "error" : "done",
+          result: result.structuredContent ?? result,
+          error: result.isError ? result.content[0]?.text : undefined
+        };
+      }
+      input.toolHandlers?.onFinish(stepId, finishUpdate);
+      apiMessages.push({
+        role: "tool",
+        tool_call_id: call.id,
+        content: toolContent
+      });
+      if (shouldTerminateTurnAfterTool(call.function.name)) {
+        terminatesTurn = true;
+      }
+    }
+    if (terminatesTurn) {
+      finalContent = completion.content?.trim() || finalContent.trim() || "Choose an option below or type your reply.";
+      input.stream?.onUpdate(finalContent);
+      endedWithPostResponseTool = true;
+      break;
+    }
+  }
+  if (!endedWithPostResponseTool && apiMessages.at(-1)?.role === "tool") {
+    const completion = await requestLlmCompletion({
+      messages: apiMessages,
+      tools: clientTools,
+      model: input.model,
+      signal: input.signal,
+      stream: input.stream ? {
+        turnId: input.stream.turnId,
+        onUpdate: (content) => {
+          finalContent = content;
+          input.stream?.onUpdate(content);
+        }
+      } : undefined
+    });
+    finalContent = completion.content?.trim() || "Done — see the trace below for details.";
+    input.stream?.onUpdate(finalContent);
+    apiMessages.push({
+      role: "assistant",
+      content: completion.content
+    });
+  }
+  return {
+    assistantMessages: finalContent ? [{ id: input.stream?.turnId, content: finalContent }] : [],
+    apiMessages,
+    lastToolResult
+  };
+}
+function resolveAssistantContentForApi(message) {
+  const content = message.content.trim();
+  if (content)
+    return message.content;
+  if (message.replySuggestions?.question.trim()) {
+    return message.replySuggestions.question;
+  }
+  return message.content;
+}
+var MAX_HISTORY_USER_TURNS = 12;
+function trimMessagesForHistory(messages, maxUserTurns) {
+  if (messages.length === 0 || maxUserTurns <= 0)
+    return messages;
+  let userCount = 0;
+  let start = 0;
+  for (let i = messages.length - 1;i >= 0; i--) {
+    if (messages[i]?.role === "user") {
+      userCount++;
+      if (userCount >= maxUserTurns) {
+        start = i;
+        break;
+      }
+    }
+  }
+  return messages.slice(start);
+}
+function sanitizeLlmMessages(messages) {
+  const out = [];
+  let pendingToolCallIds = null;
+  for (const msg of messages) {
+    if (msg.role === "assistant" && msg.tool_calls?.length) {
+      out.push(msg);
+      pendingToolCallIds = new Set(msg.tool_calls.map((toolCall) => toolCall.id));
+      continue;
+    }
+    if (msg.role === "tool") {
+      const callId = msg.tool_call_id;
+      if (callId && pendingToolCallIds?.has(callId)) {
+        out.push(msg);
+        pendingToolCallIds.delete(callId);
+        if (pendingToolCallIds.size === 0) {
+          pendingToolCallIds = null;
+        }
+      }
+      continue;
+    }
+    pendingToolCallIds = null;
+    out.push(msg);
+  }
+  while (out[0]?.role === "tool") {
+    out.shift();
+  }
+  return out;
+}
+function buildLlmHistory(messages) {
+  const history = [];
+  for (const msg of trimMessagesForHistory(messages, MAX_HISTORY_USER_TURNS)) {
+    if (msg.role === "user") {
+      history.push({ role: "user", content: msg.content });
+      continue;
+    }
+    if (msg.role !== "assistant")
+      continue;
+    if (msg.activity?.length) {
+      const baseId = history.length;
+      const toolCalls = msg.activity.map((step, index) => ({
+        id: `call_${baseId}_${index}`,
+        type: "function",
+        function: {
+          name: step.name,
+          arguments: JSON.stringify(step.args)
+        }
+      }));
+      history.push({
+        role: "assistant",
+        content: resolveAssistantContentForApi(msg) || null,
+        tool_calls: toolCalls
+      });
+      for (const [index, step] of msg.activity.entries()) {
+        history.push({
+          role: "tool",
+          tool_call_id: `call_${baseId}_${index}`,
+          content: step.error ?? (typeof step.result === "string" ? step.result : JSON.stringify(step.result ?? "Result shown in UI."))
+        });
+      }
+      continue;
+    }
+    if (msg.toolCall) {
+      const id = `call_${history.length}`;
+      history.push({
+        role: "assistant",
+        content: msg.content || null,
+        tool_calls: [
+          {
+            id,
+            type: "function",
+            function: {
+              name: msg.toolCall.name,
+              arguments: JSON.stringify(msg.toolCall.args)
+            }
+          }
+        ]
+      });
+      history.push({
+        role: "tool",
+        tool_call_id: id,
+        content: "Result shown in UI."
+      });
+      continue;
+    }
+    history.push({
+      role: "assistant",
+      content: resolveAssistantContentForApi(msg)
+    });
+  }
+  return sanitizeLlmMessages(history);
+}
+async function requireLlmSettings() {
+  const settings = await resolveAssistantLlmSettings();
+  if (!isLlmConfigured(settings)) {
+    throw new LlmNotConfiguredError;
+  }
+  return settings;
+}
+function buildChatPayload(body, settings) {
+  const messages = [
+    {
+      role: "system",
+      content: body.systemPrompt ?? settings.systemPrompt ?? DEFAULT_SYSTEM_PROMPT
+    },
+    ...body.messages.filter((message) => message.role !== "system")
+  ];
+  const payload = {
+    model: resolveRequestModel(body.model, settings),
+    messages
+  };
+  if (body.responseFormat) {
+    payload.response_format = body.responseFormat;
+  }
+  if (body.tools?.length) {
+    payload.tools = body.tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema
+      }
+    }));
+    payload.tool_choice = "auto";
+  }
+  return payload;
+}
+function upstreamError(body, status) {
+  const errorRecord = body.error;
+  const message = typeof errorRecord?.message === "string" && errorRecord.message || typeof body.message === "string" && body.message || typeof body.error === "string" && body.error || `LLM request failed (${status})`;
+  const code = typeof body.code === "string" && body.code || "LLM_UPSTREAM_ERROR";
+  return new LlmUpstreamError(message, status, code);
+}
+function toClientTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema
+  };
+}
+function parseToolArguments(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return { params: parsed };
+  } catch {
+    return { params: [raw] };
+  }
+}
+function formatToolResult(result) {
+  if (result.isError) {
+    return result.content.map((c) => c.text).join(`
+`);
+  }
+  if (result.structuredContent !== undefined) {
+    return JSON.stringify(result.structuredContent);
+  }
+  return result.content.map((c) => c.text).join(`
+`);
+}
+
+// src/core/llm-settings-storage.ts
+var DEFAULT_LLM_SETTINGS_STORAGE_KEY = "assistant-llm-settings";
+function buildDefaultLlmSettings() {
+  return {
+    enabled: false,
+    baseUrl: DEFAULT_LLM_BASE_URL,
+    apiKey: null,
+    model: DEFAULT_LLM_MODEL
+  };
+}
+function assistantToStored(settings) {
+  return {
+    baseUrl: settings.baseUrl?.trim() || DEFAULT_LLM_BASE_URL,
+    apiKey: settings.apiKey?.trim() || null,
+    model: settings.model?.trim() || DEFAULT_LLM_MODEL,
+    models: settings.models?.length ? [...settings.models] : [],
+    systemPrompt: settings.systemPrompt ?? ""
+  };
+}
+function storedToAssistant(stored) {
+  const baseUrl = stored.baseUrl;
+  const apiKey = stored.apiKey;
+  const model = stored.model;
+  return {
+    enabled: isLlmConfigured({
+      enabled: true,
+      baseUrl,
+      apiKey,
+      model
+    }),
+    baseUrl,
+    apiKey,
+    model,
+    models: stored.models.length > 0 ? stored.models : undefined,
+    systemPrompt: stored.systemPrompt || undefined
+  };
+}
+function normalizeStoredSettings(raw, base) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const partial = raw;
+  const baseStored = assistantToStored(base);
+  return {
+    baseUrl: typeof partial.baseUrl === "string" && partial.baseUrl.trim() ? partial.baseUrl.trim() : baseStored.baseUrl,
+    apiKey: typeof partial.apiKey === "string" ? partial.apiKey.trim() || null : partial.apiKey === null ? null : baseStored.apiKey,
+    model: typeof partial.model === "string" && partial.model.trim() ? partial.model.trim() : baseStored.model,
+    models: Array.isArray(partial.models) ? partial.models.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean) : baseStored.models,
+    systemPrompt: typeof partial.systemPrompt === "string" ? partial.systemPrompt : baseStored.systemPrompt
+  };
+}
+function normalizeStoredSystemPrompt(storedPrompt, base) {
+  const trimmed = storedPrompt.trim();
+  if (!trimmed)
+    return "";
+  const basePrompt = base.systemPrompt?.trim() ?? "";
+  return trimmed === basePrompt ? "" : trimmed;
+}
+function createDefaultStoredSettings(base) {
+  return {
+    baseUrl: base.baseUrl?.trim() || DEFAULT_LLM_BASE_URL,
+    apiKey: base.apiKey?.trim() || null,
+    model: base.model?.trim() || DEFAULT_LLM_MODEL,
+    models: base.models?.length ? [...base.models] : [],
+    systemPrompt: ""
+  };
+}
+function storedSettingsHaveOverrides(stored, base) {
+  const normalized = {
+    ...stored,
+    systemPrompt: normalizeStoredSystemPrompt(stored.systemPrompt, base)
+  };
+  return JSON.stringify(normalized) !== JSON.stringify(createDefaultStoredSettings(base));
+}
+function mergeLlmSettings(base, stored) {
+  if (!stored)
+    return base;
+  const merged = storedToAssistant(stored);
+  return {
+    ...merged,
+    systemPrompt: merged.systemPrompt?.trim() || base.systemPrompt,
+    models: merged.models?.length ? merged.models : base.models
+  };
+}
+function isLlmSettingsFormDirty(current, saved) {
+  return current.baseUrl !== saved.baseUrl || current.apiKey !== saved.apiKey || current.model !== saved.model || current.modelsText !== saved.modelsText || current.systemPrompt !== saved.systemPrompt;
+}
+function resolveSelectedModel(storedModel, defaultModel, availableModels) {
+  const preferred = storedModel.trim();
+  if (preferred)
+    return preferred;
+  if (availableModels.includes(defaultModel))
+    return defaultModel;
+  return availableModels[0] ?? defaultModel;
+}
+function peekStoredModel(storageKey) {
+  try {
+    const raw = localStorage.getItem(storageKey);
+    if (!raw)
+      return null;
+    const parsed = JSON.parse(raw);
+    const model = typeof parsed.model === "string" ? parsed.model.trim() : "";
+    return model || null;
+  } catch {
+    return null;
+  }
+}
+function persistStoredModelSelection(storageKey, model) {
+  const trimmed = model.trim();
+  if (!trimmed)
+    return;
+  try {
+    const raw = localStorage.getItem(storageKey);
+    if (!raw)
+      return;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+      return;
+    localStorage.setItem(storageKey, JSON.stringify({ ...parsed, model: trimmed }));
+  } catch {}
+}
+var LEGACY_MODEL_STORAGE_KEYS = [
+  "assistant-llm-model",
+  "4d-llm-model"
+];
+function migrateLegacyModelStorage(llmSettingsKey, legacyModelKey, base) {
+  const legacyKeys = [
+    ...legacyModelKey ? [legacyModelKey] : [],
+    ...LEGACY_MODEL_STORAGE_KEYS
+  ];
+  for (const key of legacyKeys) {
+    const legacyModel = localStorage.getItem(key)?.trim();
+    if (!legacyModel)
+      continue;
+    const storage = createLlmSettingsStorage(llmSettingsKey);
+    const stored = storage.load(base) ?? createDefaultStoredSettings(base);
+    storage.save({ ...stored, model: legacyModel });
+    localStorage.removeItem(key);
+    break;
+  }
+}
+function parseModelsText(text) {
+  return [
+    ...new Set(text.split(/[\n,]/).map((entry) => entry.trim()).filter(Boolean))
+  ];
+}
+function formatModelsText(models) {
+  return models?.join(", ") ?? "";
+}
+function createLlmSettingsStorage(storageKey) {
+  return {
+    load(base) {
+      try {
+        const raw = localStorage.getItem(storageKey);
+        if (!raw)
+          return null;
+        return normalizeStoredSettings(JSON.parse(raw), base);
+      } catch {
+        return null;
+      }
+    },
+    save(settings) {
+      localStorage.setItem(storageKey, JSON.stringify(settings));
+    },
+    clear() {
+      localStorage.removeItem(storageKey);
+    },
+    hasStored() {
+      return localStorage.getItem(storageKey) !== null;
+    }
+  };
+}
+function toStoredSettings(values, existingApiKey) {
+  const apiKeyInput = values.apiKey.trim();
+  return {
+    baseUrl: values.baseUrl.trim() || DEFAULT_LLM_BASE_URL,
+    apiKey: apiKeyInput.length > 0 ? apiKeyInput : existingApiKey,
+    model: values.model.trim() || DEFAULT_LLM_MODEL,
+    models: parseModelsText(values.modelsText),
+    systemPrompt: values.systemPrompt
+  };
+}
+function createLlmSettingsFormState(settings, hasStoredApiKey, defaultSystemPrompt = DEFAULT_ASSISTANT_SYSTEM_PROMPT) {
+  return {
+    baseUrl: settings.baseUrl,
+    apiKey: "",
+    model: settings.model,
+    modelsText: formatModelsText(settings.models),
+    systemPrompt: settings.systemPrompt ?? "",
+    hasStoredApiKey,
+    defaultSystemPrompt
+  };
+}
+function createLlmSettingsFormStateFromStored(stored, defaultSystemPrompt = DEFAULT_ASSISTANT_SYSTEM_PROMPT) {
+  return {
+    baseUrl: stored.baseUrl,
+    apiKey: "",
+    model: stored.model,
+    modelsText: formatModelsText(stored.models),
+    systemPrompt: stored.systemPrompt,
+    hasStoredApiKey: Boolean(stored.apiKey),
+    defaultSystemPrompt
+  };
+}
+
+// src/core/create-assistant-store.ts
+function patchWelcomeMessage(messages, welcomeMessage, model, llmEnabled) {
+  const welcome = welcomeMessage({ llmEnabled, model });
+  return messages.map((message) => message.id === "welcome" ? { ...message, content: welcome.content } : message);
+}
+function patchTurnMessage(messages, turnId, patch) {
+  return messages.map((message) => message.id === turnId ? patch(message) : message);
+}
+function createTurnMessage(turnId) {
+  return {
+    id: turnId,
+    role: "assistant",
+    content: "",
+    activity: [],
+    streaming: true,
+    timestamp: Date.now()
+  };
+}
+function appendActivityStep(messages, turnId, step) {
+  return patchTurnMessage(messages, turnId, (message) => ({
+    ...message,
+    activity: [...message.activity ?? [], step]
+  }));
+}
+function finishActivityStep(messages, turnId, stepId, update) {
+  return patchTurnMessage(messages, turnId, (message) => ({
+    ...message,
+    activity: (message.activity ?? []).map((step) => step.id === stepId ? { ...step, ...update } : step)
+  }));
+}
+function finalizeStoppedMessages(messages) {
+  return messages.map((message) => {
+    if (!message.streaming)
+      return message;
+    const activity = (message.activity ?? []).map((step) => step.status === "active" ? { ...step, status: "error", error: "Stopped" } : step);
+    return {
+      ...message,
+      streaming: false,
+      activity,
+      content: message.content.trim() || "_(stopped)_"
+    };
+  });
+}
+function finalizeErroredMessages(messages, errorMessage) {
+  const hasStreaming = messages.some((message) => message.streaming);
+  if (!hasStreaming) {
+    return [
+      ...messages,
+      {
+        id: crypto.randomUUID(),
+        role: "assistant",
+        content: errorMessage,
+        isError: true,
+        timestamp: Date.now()
+      }
+    ];
+  }
+  return messages.map((message) => {
+    if (!message.streaming)
+      return message;
+    const activity = (message.activity ?? []).map((step) => step.status === "active" ? { ...step, status: "error", error: errorMessage } : step);
+    return {
+      ...message,
+      streaming: false,
+      isError: true,
+      activity,
+      content: errorMessage
+    };
+  });
+}
+function clearReplySuggestions(messages) {
+  return messages.map((message) => message.replySuggestions ? { ...message, replySuggestions: undefined } : message);
+}
+function createAssistantStore(deps) {
+  const historyKey = deps.storageKeys?.history ?? "assistant-chat-history";
+  const llmSettingsKey = deps.storageKeys?.llmSettings ?? "assistant-llm-settings";
+  const llmSettingsStorage = createLlmSettingsStorage(llmSettingsKey);
+  async function resolveBaseLlmSettings() {
+    if (!deps.llm)
+      return buildDefaultLlmSettings();
+    return typeof deps.llm === "function" ? await deps.llm() : deps.llm;
+  }
+  async function ensureLlmSettingsStored() {
+    const base = await resolveBaseLlmSettings();
+    migrateLegacyModelStorage(llmSettingsKey, deps.storageKeys?.model, base);
+    if (llmSettingsStorage.hasStored())
+      return;
+    llmSettingsStorage.save(createDefaultStoredSettings(base));
+  }
+  async function resolveMergedLlmSettings() {
+    const base = await resolveBaseLlmSettings();
+    const stored = llmSettingsStorage.load(base);
+    return mergeLlmSettings(base, stored);
+  }
+  configureAssistantLlm(resolveMergedLlmSettings);
+  const history = createChatHistoryHelpers({
+    storageKey: historyKey,
+    welcomeMessage: deps.welcomeMessage
+  });
+  const initialSelectedModel = peekStoredModel(llmSettingsKey);
+  let chatAbortController = null;
+  const messages = history.loadInitial({
+    llmEnabled: false,
+    model: initialSelectedModel
+  });
+  const store = create((set, get) => {
+    async function runLlmChatTurn(message) {
+      const tools = await deps.listTools();
+      const storedMessages = get().messages.filter((m) => m.id !== "welcome");
+      const priorMessages = storedMessages.at(-1)?.role === "user" ? storedMessages.slice(0, -1) : storedMessages;
+      const llmHistory = buildLlmHistory(priorMessages);
+      const turnId = crypto.randomUUID();
+      set((state) => ({
+        messages: [...state.messages, createTurnMessage(turnId)]
+      }));
+      await runLlmAgent({
+        userMessage: message,
+        history: llmHistory,
+        tools,
+        model: get().selectedModel ?? undefined,
+        signal: chatAbortController?.signal,
+        stream: {
+          turnId,
+          onUpdate: (content) => {
+            set((state) => ({
+              messages: patchTurnMessage(state.messages, turnId, (msg) => ({
+                ...msg,
+                content
+              }))
+            }));
+          }
+        },
+        toolHandlers: {
+          onStart: ({ id, name, args, callId }) => {
+            set((state) => ({
+              messages: appendActivityStep(state.messages, turnId, {
+                id,
+                kind: "tool",
+                name,
+                args,
+                callId,
+                status: "active"
+              })
+            }));
+          },
+          onFinish: (stepId, update) => {
+            set((state) => ({
+              messages: finishActivityStep(state.messages, turnId, stepId, {
+                status: update.status,
+                result: summarizeActivityResult(update.result),
+                error: update.error
+              })
+            }));
+          }
+        },
+        onPostResponseTool: (suggestions) => {
+          set((state) => ({
+            messages: patchTurnMessage(state.messages, turnId, (msg) => ({
+              ...msg,
+              replySuggestions: suggestions
+            }))
+          }));
+        },
+        invokeTool: async (name, args) => {
+          const result = await deps.invokeTool(name, args);
+          deps.onToolInvoked?.(result);
+          return result;
+        }
+      });
+      set((state) => ({
+        messages: state.messages.map((msg) => msg.id === turnId ? {
+          ...msg,
+          streaming: false,
+          content: msg.content.trim() || (msg.activity?.length ? "" : "I couldn't produce a response.")
+        } : msg),
+        chatLoading: false
+      }));
+    }
+    return {
+      messages,
+      chatLoading: false,
+      llmEnabled: false,
+      llmModel: null,
+      llmModels: [],
+      llmModelsLoading: false,
+      selectedModel: initialSelectedModel,
+      loadLlmStatus: async () => {
+        set({ llmModelsLoading: true });
+        try {
+          await ensureLlmSettingsStored();
+          const base = await resolveBaseLlmSettings();
+          const stored = llmSettingsStorage.load(base) ?? createDefaultStoredSettings(base);
+          const status = await fetchLlmStatus();
+          const defaultModel = status.model ?? stored.model ?? DEFAULT_LLM_MODEL;
+          const baseModels = status.models.length ? status.models : [defaultModel];
+          const selectedModel = resolveSelectedModel(stored.model, defaultModel, baseModels);
+          const llmModels = selectedModel && !baseModels.includes(selectedModel) ? [selectedModel, ...baseModels] : baseModels;
+          set((state) => ({
+            llmEnabled: status.enabled,
+            llmModel: defaultModel,
+            llmModels,
+            selectedModel,
+            messages: patchWelcomeMessage(state.messages, deps.welcomeMessage, selectedModel, status.enabled)
+          }));
+        } finally {
+          set({ llmModelsLoading: false });
+        }
+      },
+      getLlmSettingsForm: async () => {
+        await ensureLlmSettingsStored();
+        const base = await resolveBaseLlmSettings();
+        const defaultSystemPrompt = base.systemPrompt?.trim() || DEFAULT_ASSISTANT_SYSTEM_PROMPT;
+        const stored = llmSettingsStorage.load(base);
+        if (stored) {
+          return createLlmSettingsFormStateFromStored({
+            ...stored,
+            systemPrompt: normalizeStoredSystemPrompt(stored.systemPrompt, base)
+          }, defaultSystemPrompt);
+        }
+        return createLlmSettingsFormState(base, Boolean(base.apiKey), defaultSystemPrompt);
+      },
+      saveLlmSettings: async (values) => {
+        const base = await resolveBaseLlmSettings();
+        const defaultSystemPrompt = base.systemPrompt?.trim() || DEFAULT_ASSISTANT_SYSTEM_PROMPT;
+        const current = await resolveAssistantLlmSettings();
+        const normalizedValues = {
+          ...values,
+          systemPrompt: values.systemPrompt.trim() === defaultSystemPrompt ? "" : values.systemPrompt
+        };
+        llmSettingsStorage.save(toStoredSettings(normalizedValues, current.apiKey));
+        await get().loadLlmStatus();
+      },
+      clearLlmSettings: async () => {
+        llmSettingsStorage.clear();
+        const base = await resolveBaseLlmSettings();
+        llmSettingsStorage.save(createDefaultStoredSettings(base));
+        await get().loadLlmStatus();
+      },
+      testLlmSettings: async (values) => {
+        const current = await resolveAssistantLlmSettings();
+        const stored = toStoredSettings(values, current.apiKey);
+        if (!stored.apiKey && !isLocalLlmBaseUrl(stored.baseUrl)) {
+          return {
+            ok: false,
+            error: "API key is required for remote LLM providers."
+          };
+        }
+        return testLlmConnection({
+          baseUrl: stored.baseUrl,
+          apiKey: stored.apiKey,
+          model: stored.model
+        });
+      },
+      llmSettingsHasOverrides: async () => {
+        await ensureLlmSettingsStored();
+        const base = await resolveBaseLlmSettings();
+        const stored = llmSettingsStorage.load(base);
+        if (!stored)
+          return false;
+        return storedSettingsHaveOverrides(stored, base);
+      },
+      setSelectedModel: (model) => {
+        const trimmed = model.trim();
+        if (!trimmed)
+          return;
+        const { llmEnabled, llmModels } = get();
+        const models = llmModels.includes(trimmed) ? llmModels : [trimmed, ...llmModels];
+        persistStoredModelSelection(llmSettingsKey, trimmed);
+        set((state) => ({
+          selectedModel: trimmed,
+          llmModels: models,
+          messages: patchWelcomeMessage(state.messages, deps.welcomeMessage, trimmed, llmEnabled)
+        }));
+      },
+      clearChatHistory: () => {
+        if (get().chatLoading)
+          return;
+        const { llmEnabled, selectedModel } = get();
+        history.clear();
+        set({
+          messages: [deps.welcomeMessage({ llmEnabled, model: selectedModel })]
+        });
+      },
+      stopChat: () => {
+        chatAbortController?.abort();
+        rejectAllInteractiveToolWaiters(new DOMException("Aborted", "AbortError"));
+        set((state) => ({
+          messages: finalizeStoppedMessages(state.messages),
+          chatLoading: false
+        }));
+      },
+      submitInteractiveToolResult: (callId, result) => {
+        resolveInteractiveToolResult(callId, result);
+      },
+      cancelInteractiveToolResult: (callId) => {
+        resolveInteractiveToolResult(callId, {
+          cancelled: true,
+          confirmed: false,
+          selected: []
+        });
+      },
+      sendChat: async (message) => {
+        const userMsg = {
+          id: crypto.randomUUID(),
+          role: "user",
+          content: message,
+          timestamp: Date.now()
+        };
+        chatAbortController?.abort();
+        chatAbortController = new AbortController;
+        set((state) => ({
+          messages: [...clearReplySuggestions(state.messages), userMsg],
+          chatLoading: true
+        }));
+        try {
+          if (!get().llmEnabled) {
+            set((state) => ({
+              messages: [
+                ...state.messages,
+                {
+                  id: crypto.randomUUID(),
+                  role: "assistant",
+                  content: LLM_UNAVAILABLE_MESSAGE,
+                  llmSetupRequired: true,
+                  timestamp: Date.now()
+                }
+              ],
+              chatLoading: false
+            }));
+            return;
+          }
+          await runLlmChatTurn(message);
+        } catch (error) {
+          if (error instanceof ChatAbortedError || error instanceof DOMException && error.name === "AbortError" || chatAbortController?.signal.aborted) {
+            set((state) => ({
+              messages: finalizeStoppedMessages(state.messages),
+              chatLoading: false
+            }));
+            return;
+          }
+          set((state) => ({
+            messages: finalizeErroredMessages(state.messages, `Chat failed: ${error instanceof Error ? error.message : String(error)}`),
+            chatLoading: false
+          }));
+        } finally {
+          chatAbortController = null;
+        }
+      },
+      retryLastChat: async () => {
+        if (get().chatLoading)
+          return;
+        const { messages: messages2 } = get();
+        let errorIndex = -1;
+        for (let i = messages2.length - 1;i >= 0; i--) {
+          const message = messages2[i];
+          if (message?.role === "assistant" && message.isError) {
+            errorIndex = i;
+            break;
+          }
+        }
+        if (errorIndex < 0)
+          return;
+        let userContent = null;
+        for (let i = errorIndex - 1;i >= 0; i--) {
+          const message = messages2[i];
+          if (message?.role === "user") {
+            userContent = message.content;
+            break;
+          }
+        }
+        if (!userContent)
+          return;
+        chatAbortController?.abort();
+        chatAbortController = new AbortController;
+        set((state) => ({
+          messages: state.messages.filter((_, index) => index !== errorIndex),
+          chatLoading: true
+        }));
+        try {
+          if (!get().llmEnabled) {
+            set((state) => ({
+              messages: [
+                ...state.messages,
+                {
+                  id: crypto.randomUUID(),
+                  role: "assistant",
+                  content: LLM_UNAVAILABLE_MESSAGE,
+                  llmSetupRequired: true,
+                  timestamp: Date.now()
+                }
+              ],
+              chatLoading: false
+            }));
+            return;
+          }
+          await runLlmChatTurn(userContent);
+        } catch (error) {
+          if (error instanceof ChatAbortedError || error instanceof DOMException && error.name === "AbortError" || chatAbortController?.signal.aborted) {
+            set((state) => ({
+              messages: finalizeStoppedMessages(state.messages),
+              chatLoading: false
+            }));
+            return;
+          }
+          set((state) => ({
+            messages: finalizeErroredMessages(state.messages, `Chat failed: ${error instanceof Error ? error.message : String(error)}`),
+            chatLoading: false
+          }));
+        } finally {
+          chatAbortController = null;
+        }
+      }
+    };
+  });
+  store.subscribe((state, previousState) => {
+    if (state.messages === previousState.messages)
+      return;
+    history.persist(state.messages);
+  });
+  return store;
+}
+// src/core/fetch-suggested-prompts.ts
+function parseSuggestedPromptsResponse(data) {
+  if (!data || typeof data !== "object")
+    return [];
+  const root = data;
+  const raw = Array.isArray(root.prompts) ? root.prompts : Array.isArray(root.suggestions) ? root.suggestions : [];
+  const prompts = [];
+  for (const [index, entry] of raw.entries()) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const item = entry;
+    const label = typeof item.label === "string" ? item.label.trim() : "";
+    const prompt = typeof item.prompt === "string" ? item.prompt.trim() : typeof item.message === "string" ? item.message.trim() : "";
+    if (!label || !prompt)
+      continue;
+    prompts.push({
+      id: typeof item.id === "string" && item.id.trim() ? item.id.trim() : `prompt-${index + 1}`,
+      label,
+      description: typeof item.description === "string" ? item.description.trim() : typeof item.hint === "string" ? item.hint.trim() : undefined,
+      prompt,
+      icon: typeof item.icon === "string" ? item.icon.trim() : undefined
+    });
+  }
+  return prompts.slice(0, 6);
+}
+// src/core/markdown-utils.ts
+var import_react2 = __toESM(require_react(), 1);
+function childrenToText(children) {
+  if (typeof children === "string")
+    return children;
+  if (typeof children === "number")
+    return String(children);
+  if (Array.isArray(children))
+    return children.map(childrenToText).join("");
+  if (import_react2.isValidElement(children)) {
+    return childrenToText(children.props.children);
+  }
+  return "";
+}
+export {
+  toStoredSettings,
+  testLlmConnection,
+  summarizeActivityResult,
+  storedToAssistant,
+  storedSettingsHaveOverrides,
+  shouldShowChatCommandMenu,
+  sanitizeLlmMessages,
+  runLlmAgent,
+  runAssistantChatCommand,
+  resolveSelectedModel,
+  resolveInteractiveToolResult,
+  resolveAssistantLlmSettings,
+  resetAssistantLlm,
+  requestLlmCompletion,
+  rejectAllInteractiveToolWaiters,
+  persistStoredModelSelection,
+  peekStoredModel,
+  parseSuggestedPromptsResponse,
+  parseModelsText,
+  parseChatCommand,
+  normalizeStoredSystemPrompt,
+  normalizeStoredSettings,
+  migrateLegacyModelStorage,
+  mergeLlmSettings,
+  listChatCommands,
+  isLocalLlmBaseUrl,
+  isLlmUnavailableMessage,
+  isLlmSettingsFormDirty,
+  isLlmConfigured,
+  isChatCommandInput,
+  getFallbackModels,
+  getChatCommandSuggestions,
+  formatModelsText,
+  formatJsonIfLarge,
+  filterChatCommands,
+  fetchProviderModels,
+  fetchLlmStatus,
+  createLlmSettingsStorage,
+  createLlmSettingsFormStateFromStored,
+  createLlmSettingsFormState,
+  createDefaultStoredSettings,
+  createChatHistoryHelpers,
+  createAssistantStore,
+  configureAssistantLlm,
+  clearProviderModelCache,
+  childrenToText,
+  chatActivityStepLabel,
+  buildModelsUrl,
+  buildLlmRequestHeaders,
+  buildLlmHistory,
+  buildDefaultLlmSettings,
+  buildCompletionsUrl,
+  assistantToStored,
+  SUGGEST_REPLIES_TOOL,
+  LlmUpstreamError,
+  LlmNotConfiguredError,
+  LLM_UNAVAILABLE_MESSAGE,
+  DEFAULT_LLM_SETTINGS_STORAGE_KEY,
+  DEFAULT_LLM_MODEL,
+  DEFAULT_LLM_BASE_URL,
+  ChatAbortedError,
+  CONFIRMATION_TOOL,
+  CHOICES_TOOL
+};