@gr33n-ai/jade-sdk-rn-client 0.1.0 → 0.1.2

package/dist/react-native/index.js

@@ -1,2795 +0,0 @@
-'use strict';
-
-var react = require('react');
-var reactNative = require('react-native');
-var jsxRuntime = require('react/jsx-runtime');
-
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// ../../node_modules/.pnpm/react-native-sse@1.2.1/node_modules/react-native-sse/src/EventSource.js
-var EventSource_exports = {};
-__export(EventSource_exports, {
-  default: () => EventSource_default
-});
-var XMLReadyStateMap, EventSource, EventSource_default;
-var init_EventSource = __esm({
-  "../../node_modules/.pnpm/react-native-sse@1.2.1/node_modules/react-native-sse/src/EventSource.js"() {
-    XMLReadyStateMap = [
-      "UNSENT",
-      "OPENED",
-      "HEADERS_RECEIVED",
-      "LOADING",
-      "DONE"
-    ];
-    EventSource = class {
-      ERROR = -1;
-      CONNECTING = 0;
-      OPEN = 1;
-      CLOSED = 2;
-      CRLF = "\r\n";
-      LF = "\n";
-      CR = "\r";
-      constructor(url, options = {}) {
-        this.lastEventId = null;
-        this.status = this.CONNECTING;
-        this.eventHandlers = {
-          open: [],
-          message: [],
-          error: [],
-          close: []
-        };
-        this.method = options.method || "GET";
-        this.timeout = options.timeout ?? 0;
-        this.timeoutBeforeConnection = options.timeoutBeforeConnection ?? 500;
-        this.withCredentials = options.withCredentials || false;
-        this.headers = options.headers || {};
-        this.body = options.body || void 0;
-        this.debug = options.debug || false;
-        this.interval = options.pollingInterval ?? 5e3;
-        this.lineEndingCharacter = options.lineEndingCharacter || null;
-        this._xhr = null;
-        this._pollTimer = null;
-        this._lastIndexProcessed = 0;
-        if (!url || typeof url !== "string" && typeof url.toString !== "function") {
-          throw new SyntaxError("[EventSource] Invalid URL argument.");
-        }
-        if (typeof url.toString === "function") {
-          this.url = url.toString();
-        } else {
-          this.url = url;
-        }
-        this._pollAgain(this.timeoutBeforeConnection, true);
-      }
-      _pollAgain(time, allowZero) {
-        if (time > 0 || allowZero) {
-          this._logDebug(`[EventSource] Will open new connection in ${time} ms.`);
-          this._pollTimer = setTimeout(() => {
-            this.open();
-          }, time);
-        }
-      }
-      open() {
-        try {
-          this.status = this.CONNECTING;
-          this._lastIndexProcessed = 0;
-          this._xhr = new XMLHttpRequest();
-          this._xhr.open(this.method, this.url, true);
-          if (this.withCredentials) {
-            this._xhr.withCredentials = true;
-          }
-          this._xhr.setRequestHeader("Accept", "text/event-stream");
-          this._xhr.setRequestHeader("Cache-Control", "no-cache");
-          this._xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
-          if (this.headers) {
-            for (const [key, value] of Object.entries(this.headers)) {
-              this._xhr.setRequestHeader(key, value);
-            }
-          }
-          if (this.lastEventId !== null) {
-            this._xhr.setRequestHeader("Last-Event-ID", this.lastEventId);
-          }
-          this._xhr.timeout = this.timeout;
-          this._xhr.onreadystatechange = () => {
-            if (this.status === this.CLOSED) {
-              return;
-            }
-            const xhr = this._xhr;
-            this._logDebug(`[EventSource][onreadystatechange] ReadyState: ${XMLReadyStateMap[xhr.readyState] || "Unknown"}(${xhr.readyState}), status: ${xhr.status}`);
-            if (![XMLHttpRequest.DONE, XMLHttpRequest.LOADING].includes(xhr.readyState)) {
-              return;
-            }
-            if (xhr.status >= 200 && xhr.status < 400) {
-              if (this.status === this.CONNECTING) {
-                this.status = this.OPEN;
-                this.dispatch("open", { type: "open" });
-                this._logDebug("[EventSource][onreadystatechange][OPEN] Connection opened.");
-              }
-              this._handleEvent(xhr.responseText || "");
-              if (xhr.readyState === XMLHttpRequest.DONE) {
-                this._logDebug("[EventSource][onreadystatechange][DONE] Operation done.");
-                this._pollAgain(this.interval, false);
-              }
-            } else if (xhr.status !== 0) {
-              this.status = this.ERROR;
-              this.dispatch("error", {
-                type: "error",
-                message: xhr.responseText,
-                xhrStatus: xhr.status,
-                xhrState: xhr.readyState
-              });
-              if (xhr.readyState === XMLHttpRequest.DONE) {
-                this._logDebug("[EventSource][onreadystatechange][ERROR] Response status error.");
-                this._pollAgain(this.interval, false);
-              }
-            }
-          };
-          this._xhr.onerror = () => {
-            if (this.status === this.CLOSED) {
-              return;
-            }
-            this.status = this.ERROR;
-            this.dispatch("error", {
-              type: "error",
-              message: this._xhr.responseText,
-              xhrStatus: this._xhr.status,
-              xhrState: this._xhr.readyState
-            });
-          };
-          if (this.body) {
-            this._xhr.send(this.body);
-          } else {
-            this._xhr.send();
-          }
-          if (this.timeout > 0) {
-            setTimeout(() => {
-              if (this._xhr.readyState === XMLHttpRequest.LOADING) {
-                this.dispatch("error", { type: "timeout" });
-                this.close();
-              }
-            }, this.timeout);
-          }
-        } catch (e) {
-          this.status = this.ERROR;
-          this.dispatch("error", {
-            type: "exception",
-            message: e.message,
-            error: e
-          });
-        }
-      }
-      _logDebug(...msg) {
-        if (this.debug) {
-          console.debug(...msg);
-        }
-      }
-      _handleEvent(response) {
-        if (this.lineEndingCharacter === null) {
-          const detectedNewlineChar = this._detectNewlineChar(response);
-          if (detectedNewlineChar !== null) {
-            this._logDebug(`[EventSource] Automatically detected lineEndingCharacter: ${JSON.stringify(detectedNewlineChar).slice(1, -1)}`);
-            this.lineEndingCharacter = detectedNewlineChar;
-          } else {
-            console.warn("[EventSource] Unable to identify the line ending character. Ensure your server delivers a standard line ending character: \\r\\n, \\n, \\r, or specify your custom character using the 'lineEndingCharacter' option.");
-            return;
-          }
-        }
-        const indexOfDoubleNewline = this._getLastDoubleNewlineIndex(response);
-        if (indexOfDoubleNewline <= this._lastIndexProcessed) {
-          return;
-        }
-        const parts = response.substring(this._lastIndexProcessed, indexOfDoubleNewline).split(this.lineEndingCharacter);
-        this._lastIndexProcessed = indexOfDoubleNewline;
-        let type = void 0;
-        let id = null;
-        let data = [];
-        let retry = 0;
-        let line = "";
-        for (let i = 0; i < parts.length; i++) {
-          line = parts[i].trim();
-          if (line.startsWith("event")) {
-            type = line.replace(/event:?\s*/, "");
-          } else if (line.startsWith("retry")) {
-            retry = parseInt(line.replace(/retry:?\s*/, ""), 10);
-            if (!isNaN(retry)) {
-              this.interval = retry;
-            }
-          } else if (line.startsWith("data")) {
-            data.push(line.replace(/data:?\s*/, ""));
-          } else if (line.startsWith("id")) {
-            id = line.replace(/id:?\s*/, "");
-            if (id !== "") {
-              this.lastEventId = id;
-            } else {
-              this.lastEventId = null;
-            }
-          } else if (line === "") {
-            if (data.length > 0) {
-              const eventType = type || "message";
-              const event = {
-                type: eventType,
-                data: data.join("\n"),
-                url: this.url,
-                lastEventId: this.lastEventId
-              };
-              this.dispatch(eventType, event);
-              data = [];
-              type = void 0;
-            }
-          }
-        }
-      }
-      _detectNewlineChar(response) {
-        const supportedLineEndings = [this.CRLF, this.LF, this.CR];
-        for (const char of supportedLineEndings) {
-          if (response.includes(char)) {
-            return char;
-          }
-        }
-        return null;
-      }
-      _getLastDoubleNewlineIndex(response) {
-        const doubleLineEndingCharacter = this.lineEndingCharacter + this.lineEndingCharacter;
-        const lastIndex = response.lastIndexOf(doubleLineEndingCharacter);
-        if (lastIndex === -1) {
-          return -1;
-        }
-        return lastIndex + doubleLineEndingCharacter.length;
-      }
-      addEventListener(type, listener) {
-        if (this.eventHandlers[type] === void 0) {
-          this.eventHandlers[type] = [];
-        }
-        this.eventHandlers[type].push(listener);
-      }
-      removeEventListener(type, listener) {
-        if (this.eventHandlers[type] !== void 0) {
-          this.eventHandlers[type] = this.eventHandlers[type].filter((handler) => handler !== listener);
-        }
-      }
-      removeAllEventListeners(type) {
-        const availableTypes = Object.keys(this.eventHandlers);
-        if (type === void 0) {
-          for (const eventType of availableTypes) {
-            this.eventHandlers[eventType] = [];
-          }
-        } else {
-          if (!availableTypes.includes(type)) {
-            throw Error(`[EventSource] '${type}' type is not supported event type.`);
-          }
-          this.eventHandlers[type] = [];
-        }
-      }
-      dispatch(type, data) {
-        const availableTypes = Object.keys(this.eventHandlers);
-        if (!availableTypes.includes(type)) {
-          return;
-        }
-        for (const handler of Object.values(this.eventHandlers[type])) {
-          handler(data);
-        }
-      }
-      close() {
-        if (this.status !== this.CLOSED) {
-          this.status = this.CLOSED;
-          this.dispatch("close", { type: "close" });
-        }
-        clearTimeout(this._pollTimer);
-        if (this._xhr) {
-          this._xhr.abort();
-        }
-      }
-    };
-    EventSource_default = EventSource;
-  }
-});
-
-// ../../node_modules/.pnpm/react-native-sse@1.2.1/node_modules/react-native-sse/index.js
-var require_react_native_sse = __commonJS({
-  "../../node_modules/.pnpm/react-native-sse@1.2.1/node_modules/react-native-sse/index.js"(exports$1, module) {
-    var EventSource3 = (init_EventSource(), __toCommonJS(EventSource_exports));
-    module.exports = EventSource3;
-  }
-});
-
-// ../ts-client/dist/index.js
-async function getBytes(stream, onChunk) {
-  const reader = stream.getReader();
-  let result;
-  while (!(result = await reader.read()).done) {
-    onChunk(result.value);
-  }
-}
-function getLines(onLine) {
-  let buffer;
-  let position;
-  let fieldLength;
-  let discardTrailingNewline = false;
-  return function onChunk(arr) {
-    if (buffer === void 0) {
-      buffer = arr;
-      position = 0;
-      fieldLength = -1;
-    } else {
-      buffer = concat(buffer, arr);
-    }
-    const bufLength = buffer.length;
-    let lineStart = 0;
-    while (position < bufLength) {
-      if (discardTrailingNewline) {
-        if (buffer[position] === 10) {
-          lineStart = ++position;
-        }
-        discardTrailingNewline = false;
-      }
-      let lineEnd = -1;
-      for (; position < bufLength && lineEnd === -1; ++position) {
-        switch (buffer[position]) {
-          case 58:
-            if (fieldLength === -1) {
-              fieldLength = position - lineStart;
-            }
-            break;
-          case 13:
-            discardTrailingNewline = true;
-          case 10:
-            lineEnd = position;
-            break;
-        }
-      }
-      if (lineEnd === -1) {
-        break;
-      }
-      onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
-      lineStart = position;
-      fieldLength = -1;
-    }
-    if (lineStart === bufLength) {
-      buffer = void 0;
-    } else if (lineStart !== 0) {
-      buffer = buffer.subarray(lineStart);
-      position -= lineStart;
-    }
-  };
-}
-function getMessages(onId, onRetry, onMessage) {
-  let message = newMessage();
-  const decoder = new TextDecoder();
-  return function onLine(line, fieldLength) {
-    if (line.length === 0) {
-      onMessage === null || onMessage === void 0 ? void 0 : onMessage(message);
-      message = newMessage();
-    } else if (fieldLength > 0) {
-      const field = decoder.decode(line.subarray(0, fieldLength));
-      const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
-      const value = decoder.decode(line.subarray(valueOffset));
-      switch (field) {
-        case "data":
-          message.data = message.data ? message.data + "\n" + value : value;
-          break;
-        case "event":
-          message.event = value;
-          break;
-        case "id":
-          onId(message.id = value);
-          break;
-        case "retry":
-          const retry = parseInt(value, 10);
-          if (!isNaN(retry)) {
-            onRetry(message.retry = retry);
-          }
-          break;
-      }
-    }
-  };
-}
-function concat(a, b) {
-  const res = new Uint8Array(a.length + b.length);
-  res.set(a);
-  res.set(b, a.length);
-  return res;
-}
-function newMessage() {
-  return {
-    data: "",
-    event: "",
-    id: "",
-    retry: void 0
-  };
-}
-var __rest = function(s, e) {
-  var t = {};
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-    t[p] = s[p];
-  if (s != null && typeof Object.getOwnPropertySymbols === "function")
-    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-        t[p[i]] = s[p[i]];
-    }
-  return t;
-};
-var EventStreamContentType = "text/event-stream";
-var DefaultRetryInterval = 1e3;
-var LastEventId = "last-event-id";
-function fetchEventSource(input, _a) {
-  var { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, fetch: inputFetch } = _a, rest = __rest(_a, ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden", "fetch"]);
-  return new Promise((resolve, reject) => {
-    const headers = Object.assign({}, inputHeaders);
-    if (!headers.accept) {
-      headers.accept = EventStreamContentType;
-    }
-    let curRequestController;
-    function onVisibilityChange() {
-      curRequestController.abort();
-      if (!document.hidden) {
-        create();
-      }
-    }
-    if (!openWhenHidden) {
-      document.addEventListener("visibilitychange", onVisibilityChange);
-    }
-    let retryInterval = DefaultRetryInterval;
-    let retryTimer = 0;
-    function dispose() {
-      document.removeEventListener("visibilitychange", onVisibilityChange);
-      window.clearTimeout(retryTimer);
-      curRequestController.abort();
-    }
-    inputSignal === null || inputSignal === void 0 ? void 0 : inputSignal.addEventListener("abort", () => {
-      dispose();
-      resolve();
-    });
-    const fetch2 = inputFetch !== null && inputFetch !== void 0 ? inputFetch : window.fetch;
-    const onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
-    async function create() {
-      var _a2;
-      curRequestController = new AbortController();
-      try {
-        const response = await fetch2(input, Object.assign(Object.assign({}, rest), { headers, signal: curRequestController.signal }));
-        await onopen(response);
-        await getBytes(response.body, getLines(getMessages((id) => {
-          if (id) {
-            headers[LastEventId] = id;
-          } else {
-            delete headers[LastEventId];
-          }
-        }, (retry) => {
-          retryInterval = retry;
-        }, onmessage)));
-        onclose === null || onclose === void 0 ? void 0 : onclose();
-        dispose();
-        resolve();
-      } catch (err) {
-        if (!curRequestController.signal.aborted) {
-          try {
-            const interval = (_a2 = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _a2 !== void 0 ? _a2 : retryInterval;
-            window.clearTimeout(retryTimer);
-            retryTimer = window.setTimeout(create, interval);
-          } catch (innerErr) {
-            dispose();
-            reject(innerErr);
-          }
-        }
-      }
-    }
-    create();
-  });
-}
-function defaultOnOpen(response) {
-  const contentType = response.headers.get("content-type");
-  if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith(EventStreamContentType))) {
-    throw new Error(`Expected content-type to be ${EventStreamContentType}, Actual: ${contentType}`);
-  }
-}
-var AgentEventEmitter = class {
-  constructor() {
-    this.handlers = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Subscribe to an event.
-   * @returns Unsubscribe function
-   */
-  on(event, handler) {
-    if (!this.handlers.has(event)) {
-      this.handlers.set(event, /* @__PURE__ */ new Set());
-    }
-    this.handlers.get(event).add(handler);
-    return () => this.off(event, handler);
-  }
-  /**
-   * Unsubscribe from an event.
-   */
-  off(event, handler) {
-    this.handlers.get(event)?.delete(handler);
-  }
-  /**
-   * Emit an event to all handlers.
-   */
-  emit(event, data) {
-    this.handlers.get(event)?.forEach((handler) => {
-      try {
-        handler(data);
-      } catch (err) {
-        console.error(`[AgentEventEmitter] Error in ${event} handler:`, err);
-      }
-    });
-  }
-  /**
-   * Remove all event handlers.
-   */
-  removeAllListeners() {
-    this.handlers.clear();
-  }
-};
-var AgentClientError = class extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.name = "AgentClientError";
-  }
-};
-var AuthenticationError = class extends AgentClientError {
-  constructor(message = "Authentication failed") {
-    super(message);
-    this.name = "AuthenticationError";
-  }
-};
-var SessionNotFoundError = class extends AgentClientError {
-  constructor(sessionId) {
-    super(`Session not found: ${sessionId}`);
-    this.sessionId = sessionId;
-    this.name = "SessionNotFoundError";
-  }
-};
-var SkillNotFoundError = class extends AgentClientError {
-  constructor(skillName) {
-    super(`Skill not found: ${skillName}`);
-    this.skillName = skillName;
-    this.name = "SkillNotFoundError";
-  }
-};
-var RequestError = class extends AgentClientError {
-  constructor(message, statusCode) {
-    super(message);
-    this.statusCode = statusCode;
-    this.name = "RequestError";
-  }
-};
-var FatalSSEError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "FatalSSEError";
-  }
-};
-var MAX_RETRIES = 5;
-var INITIAL_RETRY_DELAY = 1e3;
-var MAX_RETRY_DELAY = 1e4;
-async function createSSEStream(options) {
-  const {
-    url,
-    method,
-    headers,
-    body,
-    emitter,
-    signal,
-    onOpen,
-    onClose,
-    lastEventId
-  } = options;
-  const processedIds = /* @__PURE__ */ new Set();
-  let retryCount = 0;
-  try {
-    await fetchEventSource(url, {
-      method,
-      headers: {
-        "Content-Type": "application/json",
-        ...lastEventId ? { "Last-Event-ID": lastEventId } : {},
-        ...headers
-      },
-      body: JSON.stringify(body),
-      signal,
-      async onopen(response) {
-        if (response.ok && response.headers.get("content-type")?.includes(EventStreamContentType)) {
-          onOpen?.();
-          return;
-        }
-        if (response.status === 401 || response.status === 403) {
-          throw new FatalSSEError(`Authentication failed: ${response.status}`);
-        }
-        if (response.status === 404) {
-          throw new FatalSSEError("Session not found or not active");
-        }
-        if (response.status === 503) {
-          const text = await response.text().catch(() => "Service unavailable");
-          throw new FatalSSEError(`Server unavailable: ${text}`);
-        }
-        if (response.status >= 400 && response.status < 500) {
-          const text = await response.text().catch(() => `Error ${response.status}`);
-          throw new FatalSSEError(text);
-        }
-        throw new Error(`Failed to connect: ${response.status}`);
-      },
-      onmessage(event) {
-        if (event.id && processedIds.has(event.id)) {
-          return;
-        }
-        if (event.id) {
-          processedIds.add(event.id);
-        }
-        if (!event.data) {
-          return;
-        }
-        try {
-          const data = JSON.parse(event.data);
-          const eventType = event.event || "message";
-          switch (eventType) {
-            case "init":
-            case "session":
-              emitter.emit("session", { session_id: data.session_id });
-              break;
-            case "entry":
-              emitter.emit("entry", { entry: data });
-              break;
-            case "stream_event":
-              handleStreamEvent(data, emitter);
-              break;
-            case "content_block_start":
-              emitter.emit("content_block_start", data);
-              break;
-            case "content_block_delta":
-              emitter.emit("content_block_delta", data);
-              break;
-            case "content_block_stop":
-              emitter.emit("content_block_stop", data);
-              break;
-            case "complete":
-              emitter.emit("complete", data);
-              break;
-            case "error":
-              emitter.emit("error", { error: data.error });
-              break;
-            case "heartbeat":
-              emitter.emit("heartbeat", {});
-              break;
-            default:
-              break;
-          }
-        } catch (e) {
-          console.error("[SSE] Failed to parse event:", event.data, e);
-        }
-      },
-      onerror(err) {
-        if (signal?.aborted) {
-          throw err;
-        }
-        if (err instanceof FatalSSEError) {
-          emitter.emit("error", { error: err.message });
-          throw err;
-        }
-        retryCount++;
-        if (retryCount > MAX_RETRIES) {
-          const error = `Connection failed after ${MAX_RETRIES} retries`;
-          emitter.emit("error", { error });
-          throw new FatalSSEError(error);
-        }
-        const delay = Math.min(INITIAL_RETRY_DELAY * Math.pow(2, retryCount - 1), MAX_RETRY_DELAY);
-        console.log(`[SSE] Retry ${retryCount}/${MAX_RETRIES} in ${delay}ms`);
-        return delay;
-      },
-      onclose() {
-        onClose?.();
-      },
-      // Keep connection open when tab is hidden - heartbeats keep it alive
-      openWhenHidden: true
-    });
-  } catch (error) {
-    if (error instanceof FatalSSEError) {
-      if (error.message.includes("Authentication")) {
-        throw new AuthenticationError(error.message);
-      }
-      throw new RequestError(error.message, 500);
-    }
-    if (error instanceof Error) {
-      emitter.emit("error", { error: error.message });
-    }
-    throw error;
-  }
-}
-function handleStreamEvent(data, emitter) {
-  const streamEvent = data.event || data;
-  const eventData = streamEvent;
-  switch (eventData.type) {
-    case "content_block_start":
-      emitter.emit("content_block_start", eventData);
-      break;
-    case "content_block_delta":
-      emitter.emit("content_block_delta", eventData);
-      break;
-    case "content_block_stop":
-      emitter.emit("content_block_stop", eventData);
-      break;
-  }
-}
-var AgentClient = class {
-  constructor(config) {
-    this.activeStreams = /* @__PURE__ */ new Map();
-    this.config = {
-      apiVersion: "/v1",
-      timeout: 3e4,
-      ...config
-    };
-  }
-  // ===========================================================================
-  // Public getters
-  // ===========================================================================
-  /** Whether org context is configured (orgId is set) */
-  get hasOrgContext() {
-    return !!this.config.orgId;
-  }
-  // ===========================================================================
-  // Private helpers
-  // ===========================================================================
-  get baseUrl() {
-    return `${this.config.endpoint}${this.config.apiVersion}`;
-  }
-  async getHeaders() {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    const token = await this.config.getAuthToken();
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    return headers;
-  }
-  async request(path, options = {}) {
-    const url = `${this.baseUrl}${path}`;
-    const headers = await this.getHeaders();
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-    try {
-      const response = await fetch(url, {
-        ...options,
-        headers: { ...headers, ...options.headers || {} },
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        await this.handleErrorResponse(response, path);
-      }
-      return response.json();
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  async handleErrorResponse(response, path) {
-    if (response.status === 401 || response.status === 403) {
-      throw new AuthenticationError();
-    }
-    if (response.status === 404) {
-      const text = await response.text();
-      if (text.toLowerCase().includes("session")) {
-        const sessionId = path.split("/").pop() || "";
-        throw new SessionNotFoundError(sessionId);
-      }
-      if (text.toLowerCase().includes("skill")) {
-        const skillName = path.split("/").pop() || "";
-        throw new SkillNotFoundError(skillName);
-      }
-    }
-    throw new RequestError(`Request failed: ${response.status}`, response.status);
-  }
-  // ===========================================================================
-  // Messages API
-  // ===========================================================================
-  /**
-   * Send a message and stream responses.
-   * @returns Object with event emitter and abort function
-   */
-  stream(request) {
-    const emitter = new AgentEventEmitter();
-    const controller = new AbortController();
-    const streamId = request.session_id || `stream-${Date.now()}`;
-    this.activeStreams.set(streamId, controller);
-    (async () => {
-      try {
-        const headers = await this.getHeaders();
-        await createSSEStream({
-          url: `${this.baseUrl}/messages`,
-          method: "POST",
-          headers,
-          body: { ...request, stream: true },
-          emitter,
-          signal: controller.signal
-        });
-      } catch (error) {
-        emitter.emit("error", {
-          error: error instanceof Error ? error.message : "Unknown error"
-        });
-      } finally {
-        this.activeStreams.delete(streamId);
-      }
-    })();
-    return {
-      emitter,
-      abort: () => controller.abort()
-    };
-  }
-  // ===========================================================================
-  // Sessions API
-  // ===========================================================================
-  /**
-   * List all sessions for the authenticated user.
-   */
-  async listSessions() {
-    return this.request("/sessions");
-  }
-  /**
-   * Get session content in display format.
-   */
-  async getSession(sessionId) {
-    return this.request(`/sessions/${sessionId}`);
-  }
-  /**
-   * Get session content as raw JSONL.
-   */
-  async getSessionRaw(sessionId) {
-    return this.request(`/sessions/${sessionId}?format=raw`);
-  }
-  /**
-   * Check if a session is actively streaming.
-   */
-  async getSessionStatus(sessionId) {
-    return this.request(`/sessions/${sessionId}/status`);
-  }
-  /**
-   * Update session metadata (name).
-   */
-  async updateSession(sessionId, updates) {
-    return this.request(`/sessions/${sessionId}`, {
-      method: "PATCH",
-      body: JSON.stringify(updates)
-    });
-  }
-  /**
-   * Delete a session.
-   */
-  async deleteSession(sessionId) {
-    return this.request(`/sessions/${sessionId}`, {
-      method: "DELETE"
-    });
-  }
-  /**
-   * Cancel an active session query.
-   */
-  async cancelSession(sessionId) {
-    return this.request(`/sessions/${sessionId}/cancel`, {
-      method: "POST"
-    });
-  }
-  /**
-   * Reconnect to an active streaming session.
-   * @returns Object with event emitter and abort function
-   */
-  reconnect(sessionId, lastEventId = -1) {
-    const emitter = new AgentEventEmitter();
-    const controller = new AbortController();
-    (async () => {
-      try {
-        const headers = await this.getHeaders();
-        await createSSEStream({
-          url: `${this.baseUrl}/sessions/${sessionId}/reconnect`,
-          method: "POST",
-          headers,
-          body: { last_event_id: lastEventId },
-          emitter,
-          signal: controller.signal
-        });
-      } catch (error) {
-        emitter.emit("error", {
-          error: error instanceof Error ? error.message : "Unknown error"
-        });
-      }
-    })();
-    return {
-      emitter,
-      abort: () => controller.abort()
-    };
-  }
-  // ===========================================================================
-  // Skills API - Personal
-  // ===========================================================================
-  /**
-   * List personal skills.
-   */
-  async listSkills() {
-    return this.request("/skills");
-  }
-  /**
-   * Get personal skill content.
-   */
-  async getSkill(name) {
-    const response = await this.request(`/skills/${name}`);
-    return this.decodeBase64(response.content);
-  }
-  /**
-   * Create or update a personal skill.
-   */
-  async saveSkill(skill) {
-    const content = this.encodeBase64(skill.content);
-    return this.request("/skills", {
-      method: "POST",
-      body: JSON.stringify({ ...skill, content })
-    });
-  }
-  /**
-   * Delete a personal skill.
-   */
-  async deleteSkill(name) {
-    return this.request(`/skills/${name}`, {
-      method: "DELETE"
-    });
-  }
-  // ===========================================================================
-  // Skills API - Organization
-  // ===========================================================================
-  /**
-   * List organization skills.
-   */
-  async listOrgSkills() {
-    return this.request("/skills/org");
-  }
-  /**
-   * Get organization skill content.
-   */
-  async getOrgSkill(name) {
-    const response = await this.request(
-      `/skills/org/${name}`
-    );
-    return this.decodeBase64(response.content);
-  }
-  /**
-   * Create or update an organization skill.
-   */
-  async saveOrgSkill(skill) {
-    const content = this.encodeBase64(skill.content);
-    return this.request("/skills/org", {
-      method: "POST",
-      body: JSON.stringify({ ...skill, content })
-    });
-  }
-  /**
-   * Delete an organization skill.
-   */
-  async deleteOrgSkill(name) {
-    return this.request(`/skills/org/${name}`, {
-      method: "DELETE"
-    });
-  }
-  // ===========================================================================
-  // Plugins API
-  // ===========================================================================
-  /**
-   * Get plugin manifest for client sync.
-   */
-  async getPluginManifest() {
-    return this.request("/plugins/manifest");
-  }
-  /**
-   * Download plugin bundle.
-   */
-  async getPluginBundle(skills) {
-    const query = skills?.length ? `?skills=${skills.join(",")}` : "";
-    return this.request(`/plugins/bundle${query}`);
-  }
-  // ===========================================================================
-  // Utility methods
-  // ===========================================================================
-  encodeBase64(data) {
-    if (typeof data === "string") {
-      const encoder = new TextEncoder();
-      data = encoder.encode(data);
-    }
-    return btoa(String.fromCharCode(...data));
-  }
-  decodeBase64(base64) {
-    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
-  }
-};
-function parseToolResultContent(content) {
-  try {
-    const pythonMatch = content.match(/\[\{'type':\s*'text',\s*'text':\s*'([\s\S]+)'\}\]$/);
-    if (pythonMatch) {
-      const innerText = pythonMatch[1].replace(/\\n/g, "\n").replace(/\\"/g, '"');
-      const parsed2 = JSON.parse(innerText);
-      if (parsed2 && typeof parsed2 === "object" && !Array.isArray(parsed2)) {
-        return parsed2;
-      }
-    }
-    const parsed = JSON.parse(content);
-    if (Array.isArray(parsed) && parsed.length > 0 && parsed[0].type === "text" && parsed[0].text) {
-      const unescapedText = parsed[0].text.replace(/\\n/g, "\n").replace(/\\"/g, '"');
-      const innerParsed = JSON.parse(unescapedText);
-      if (innerParsed && typeof innerParsed === "object" && !Array.isArray(innerParsed)) {
-        return innerParsed;
-      }
-    }
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
-    }
-  } catch {
-  }
-  const jadeUrlMatch = content.match(/https?:\/\/jade\.gr33n\.ai\/media\/([a-zA-Z0-9_-]+)/);
-  const falUrl = extractFalMediaUrl(content);
-  if (jadeUrlMatch || falUrl) {
-    const request_id = jadeUrlMatch ? jadeUrlMatch[1] : "unknown";
-    const output_cdn_urls = falUrl ? [falUrl] : [];
-    return {
-      request_id,
-      output_cdn_urls,
-      status: "completed"
-    };
-  }
-  return null;
-}
-function extractFalMediaUrl(content) {
-  const urlMatch = content.match(/https?:\/\/[^\/]*fal\.media\/files\/[^\s"')]+/);
-  return urlMatch ? urlMatch[0] : null;
-}
-function extractMediaInfoFromToolResult(content) {
-  const parsed = parseToolResultContent(content);
-  if (!parsed) return null;
-  const urls = parsed.output_cdn_urls || parsed.urls;
-  if (!parsed.request_id || typeof parsed.request_id !== "string" || !Array.isArray(urls) || urls.length === 0) {
-    return null;
-  }
-  return {
-    requestId: parsed.request_id,
-    urls,
-    fileType: parsed.file_type,
-    metadata: parsed.metadata,
-    originalSource: parsed.original_source
-  };
-}
-function createMediaParseResult(displayType) {
-  return (content) => {
-    const mediaInfo = extractMediaInfoFromToolResult(content);
-    if (mediaInfo) {
-      return {
-        type: displayType,
-        data: { mediaInfo }
-      };
-    }
-    return null;
-  };
-}
-function extractMediaInfo(content) {
-  try {
-    const parsed = parseToolResultContent(content);
-    if (parsed?.request_id) {
-      const urls2 = parsed.output_cdn_urls || parsed.urls;
-      if (Array.isArray(urls2) && urls2.length > 0) {
-        return {
-          requestId: parsed.request_id,
-          urls: urls2
-        };
-      }
-    }
-  } catch {
-  }
-  const jadeUrlMatch = content.match(/https?:\/\/jade\.gr33n\.ai\/media\/([a-zA-Z0-9_-]+)/);
-  if (!jadeUrlMatch) return null;
-  const requestId = jadeUrlMatch[1];
-  const cdnUrlMatches = content.matchAll(/https?:\/\/[^\/]*fal\.media\/files\/[^\s"')]+/g);
-  const urls = Array.from(cdnUrlMatches, (match) => match[0]);
-  if (urls.length === 0) return null;
-  return {
-    requestId,
-    urls
-  };
-}
-var TOOL_REGISTRY = {
-  "Skill": {
-    name: "Skill",
-    displayName: "Skill",
-    iconName: "BookOpenText",
-    category: "system",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      const command = inputObj?.skill || inputObj?.command;
-      if (!command) return null;
-      return {
-        type: "skill",
-        data: { command }
-      };
-    },
-    parseResult: (content) => ({
-      type: "skill_result",
-      data: { content }
-    })
-  },
-  "Bash": {
-    name: "Bash",
-    displayName: "Bash",
-    iconName: "Terminal",
-    category: "system",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      return {
-        type: "bash",
-        data: {
-          command: inputObj?.command,
-          description: inputObj?.description
-        }
-      };
-    },
-    parseResult: (content) => ({
-      type: "bash_output",
-      data: { output: content }
-    })
-  },
-  "TodoWrite": {
-    name: "TodoWrite",
-    displayName: "Todo List",
-    iconName: "ListTodo",
-    category: "system",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      if (!inputObj?.todos) return null;
-      return {
-        type: "todo_list",
-        data: { todos: inputObj.todos }
-      };
-    },
-    parseResult: (content) => ({
-      type: "todo_result",
-      data: { content }
-    })
-  },
-  "Read": {
-    name: "Read",
-    displayName: "Read",
-    iconName: "BookOpenCheck",
-    category: "system",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      if (!inputObj?.file_path) return null;
-      return {
-        type: "read",
-        data: {
-          file_path: inputObj.file_path,
-          offset: inputObj.offset,
-          limit: inputObj.limit
-        }
-      };
-    },
-    parseResult: (content) => ({
-      type: "read_output",
-      data: { output: content }
-    })
-  },
-  "Glob": {
-    name: "Glob",
-    displayName: "File Search",
-    iconName: "FolderSearch",
-    category: "system",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      if (!inputObj?.pattern) return null;
-      return {
-        type: "glob",
-        data: {
-          pattern: inputObj.pattern,
-          path: inputObj.path
-        }
-      };
-    },
-    parseResult: (content) => {
-      const files = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-      return {
-        type: "glob_output",
-        data: { files }
-      };
-    }
-  },
-  "WebSearch": {
-    name: "WebSearch",
-    displayName: "Web Search",
-    iconName: "Search",
-    category: "system",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      if (!inputObj?.query) return null;
-      return {
-        type: "web_search",
-        data: {
-          query: inputObj.query,
-          allowed_domains: inputObj.allowed_domains,
-          blocked_domains: inputObj.blocked_domains
-        }
-      };
-    },
-    parseResult: (content) => ({
-      type: "web_search_output",
-      data: { output: content }
-    })
-  },
-  "Edit": {
-    name: "Edit",
-    displayName: "Edit File",
-    iconName: "Pencil",
-    category: "system",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      if (!inputObj?.file_path) return null;
-      return {
-        type: "edit",
-        data: {
-          file_path: inputObj.file_path,
-          old_string: inputObj.old_string,
-          new_string: inputObj.new_string,
-          replace_all: inputObj.replace_all
-        }
-      };
-    },
-    parseResult: (content) => ({
-      type: "edit_result",
-      data: { output: content }
-    })
-  },
-  "Write": {
-    name: "Write",
-    displayName: "Write File",
-    iconName: "FilePlus",
-    category: "system",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      if (!inputObj?.file_path) return null;
-      return {
-        type: "write",
-        data: {
-          file_path: inputObj.file_path,
-          content: inputObj.content
-        }
-      };
-    },
-    parseResult: (content) => ({
-      type: "write_result",
-      data: { output: content }
-    })
-  },
-  "WebFetch": {
-    name: "WebFetch",
-    displayName: "Web Fetch",
-    iconName: "Globe",
-    category: "system",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      if (!inputObj?.url) return null;
-      return {
-        type: "web_fetch",
-        data: {
-          url: inputObj.url,
-          prompt: inputObj.prompt
-        }
-      };
-    },
-    parseResult: (content) => ({
-      type: "web_fetch_result",
-      data: { response: content }
-    })
-  },
-  "mcp__jade__request_status": {
-    name: "mcp__jade__request_status",
-    displayName: "Request Status",
-    iconName: "Loader",
-    category: "utility",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      return {
-        type: "request_status_check",
-        data: { requestId: inputObj?.request_id }
-      };
-    },
-    parseResult: (content) => {
-      const mediaInfo = extractMediaInfoFromToolResult(content);
-      if (mediaInfo) {
-        return {
-          type: "request_status_completed",
-          data: { mediaInfo }
-        };
-      }
-      try {
-        const parsed = parseToolResultContent(content);
-        if (parsed?.request_id && parsed?.status === "processing") {
-          return {
-            type: "request_status_processing",
-            data: { requestId: parsed.request_id }
-          };
-        }
-      } catch {
-      }
-      return null;
-    }
-  },
-  "mcp__jade__generative_audio": {
-    name: "mcp__jade__generative_audio",
-    displayName: "Generative Audio",
-    iconName: "AudioLines",
-    iconVariant: (input) => {
-      const inputObj = input;
-      const mode = inputObj?.mode;
-      if (mode === "narration") return "Speech";
-      if (mode === "sound_effects") return "AudioLines";
-      if (mode === "music") return "Music";
-      return "AudioLines";
-    },
-    category: "generation",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      return {
-        type: "audio_generation",
-        data: {
-          textInput: inputObj?.text_input,
-          videoUrl: inputObj?.video_url,
-          mode: inputObj?.mode,
-          duration: inputObj?.duration
-        }
-      };
-    },
-    parseResult: createMediaParseResult("audio_generation_complete")
-  },
-  "mcp__jade__generative_image": {
-    name: "mcp__jade__generative_image",
-    displayName: "Generative Image",
-    iconName: "Image",
-    category: "generation",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      const additionalUrls = inputObj?.additional_image_urls ? typeof inputObj.additional_image_urls === "string" ? inputObj.additional_image_urls.split(",").map((url) => url.trim()).filter(Boolean) : inputObj.additional_image_urls : [];
-      const inputImageUrls = [
-        inputObj?.image_url,
-        ...additionalUrls
-      ].filter((url) => url && url !== "");
-      return {
-        type: "image_generation",
-        data: {
-          prompt: inputObj?.prompt,
-          inputImageUrls,
-          model: inputObj?.model,
-          aspectRatio: inputObj?.aspect_ratio,
-          numImages: inputObj?.num_images
-        }
-      };
-    },
-    parseResult: createMediaParseResult("image_generation_complete")
-  },
-  "mcp__jade__generative_video": {
-    name: "mcp__jade__generative_video",
-    displayName: "Generative Video",
-    iconName: "Video",
-    category: "generation",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      const inputMediaUrls = [];
-      if (inputObj?.input_url) {
-        inputMediaUrls.push(inputObj.input_url);
-      }
-      const lastFrameUrl = inputObj?.last_frame_url;
-      if (lastFrameUrl) {
-        inputMediaUrls.push(lastFrameUrl);
-      }
-      const elements = inputObj?.elements;
-      if (elements && Array.isArray(elements)) {
-        for (const element of elements) {
-          if (Array.isArray(element)) {
-            for (const url of element) {
-              if (url && typeof url === "string") {
-                inputMediaUrls.push(url);
-              }
-            }
-          }
-        }
-      }
-      return {
-        type: "video_generation",
-        data: {
-          prompt: inputObj?.prompt,
-          inputMediaUrls,
-          lastFrameUrl,
-          elements,
-          model: inputObj?.model_id,
-          aspectRatio: inputObj?.aspect_ratio,
-          numVideos: inputObj?.num_videos || 1
-        }
-      };
-    },
-    parseResult: createMediaParseResult("video_generation_complete")
-  },
-  "mcp__jade__background_removal": {
-    name: "mcp__jade__background_removal",
-    displayName: "Background Removal",
-    iconName: "ImageOff",
-    category: "processing",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      return {
-        type: "background_removal",
-        data: { inputUrl: inputObj?.input_url }
-      };
-    },
-    parseResult: createMediaParseResult("background_removal_complete")
-  },
-  "mcp__jade__upscale": {
-    name: "mcp__jade__upscale",
-    displayName: "Upscale",
-    iconName: "Maximize2",
-    category: "processing",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      return {
-        type: "upscale",
-        data: {
-          inputUrl: inputObj?.input_url,
-          upscaleFactor: inputObj?.upscale_factor,
-          targetResolution: inputObj?.target_resolution
-        }
-      };
-    },
-    parseResult: createMediaParseResult("upscale_complete")
-  },
-  "mcp__jade__generative_character": {
-    name: "mcp__jade__generative_character",
-    displayName: "Generative Character",
-    iconName: "SquareUser",
-    category: "generation",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      return {
-        type: "character_generation",
-        data: {
-          inputImageUrl: inputObj?.image_url,
-          inputAudioUrl: inputObj?.audio_url
-        }
-      };
-    },
-    parseResult: createMediaParseResult("character_generation_complete")
-  },
-  "mcp__jade__import_media": {
-    name: "mcp__jade__import_media",
-    displayName: "Import Media",
-    iconName: "CloudDownload",
-    category: "utility",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      return {
-        type: "media_import",
-        data: { source: inputObj?.source }
-      };
-    },
-    parseResult: createMediaParseResult("media_import_complete")
-  },
-  "mcp__jade__captions_highlights": {
-    name: "mcp__jade__captions_highlights",
-    displayName: "Captions & Highlights",
-    iconName: "Captions",
-    category: "processing",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      return {
-        type: "captions_highlights",
-        data: {
-          inputUrl: inputObj?.input_url,
-          style: inputObj?.style
-        }
-      };
-    },
-    parseResult: createMediaParseResult("captions_highlights_complete")
-  },
-  "mcp__olive__save_skill": {
-    name: "mcp__olive__save_skill",
-    displayName: "Save Skill",
-    iconName: "BookPlus",
-    category: "utility",
-    consumesResult: true,
-    parseInput: (input) => {
-      const inputObj = input;
-      return {
-        type: "save_skill",
-        data: {
-          source: inputObj?.source,
-          name: inputObj?.name,
-          scope: inputObj?.scope || "personal",
-          edit: inputObj?.edit
-        }
-      };
-    },
-    parseResult: (content) => {
-      const parsed = parseToolResultContent(content);
-      return {
-        type: "save_skill_result",
-        data: {
-          name: parsed?.name,
-          description: parsed?.description,
-          scope: parsed?.scope,
-          action: parsed?.action,
-          hasElements: parsed?.has_elements,
-          sourceType: parsed?.source_type,
-          sizeKb: parsed?.size_kb,
-          elements: parsed?.elements || []
-        }
-      };
-    }
-  }
-};
-function getToolDefinition(toolName) {
-  return TOOL_REGISTRY[toolName];
-}
-var SUGGESTION_REGEX = /<gr3\.suggestion>([\s\S]*?)<\/gr3\.suggestion>/g;
-function parseSuggestions(text) {
-  const suggestions = [];
-  const segments = [];
-  let lastIndex = 0;
-  let cleanText = "";
-  let match;
-  const regex = new RegExp(SUGGESTION_REGEX.source, "g");
-  while ((match = regex.exec(text)) !== null) {
-    const suggestionText = match[1].trim();
-    const matchStart = match.index;
-    const matchEnd = match.index + match[0].length;
-    if (matchStart > lastIndex) {
-      const textBefore = text.slice(lastIndex, matchStart);
-      segments.push({ type: "text", content: textBefore });
-      cleanText += textBefore;
-    }
-    const startIndex = cleanText.length;
-    cleanText += suggestionText;
-    const endIndex = cleanText.length;
-    suggestions.push({
-      text: suggestionText,
-      startIndex,
-      endIndex
-    });
-    segments.push({ type: "suggestion", content: suggestionText });
-    lastIndex = matchEnd;
-  }
-  if (lastIndex < text.length) {
-    const remainingText = text.slice(lastIndex);
-    segments.push({ type: "text", content: remainingText });
-    cleanText += remainingText;
-  }
-  return { cleanText, suggestions, segments };
-}
-function hasSuggestions(text) {
-  return SUGGESTION_REGEX.test(text);
-}
-function processConversation(conversation, options = {}) {
-  const {
-    skipSkillContext = true,
-    pairToolResults = true,
-    extractMedia: _extractMedia = true
-  } = options;
-  const processed = [];
-  const consumed = /* @__PURE__ */ new Set();
-  const resultsByToolUseId = /* @__PURE__ */ new Map();
-  const mediaUrlsByRequestId = /* @__PURE__ */ new Map();
-  const metadataByRequestId = /* @__PURE__ */ new Map();
-  for (let i = 0; i < conversation.length; i++) {
-    const entry = conversation[i];
-    if (entry.type === "tool_result" && entry.tool_use_id) {
-      resultsByToolUseId.set(entry.tool_use_id, i);
-      if (typeof entry.content === "string") {
-        const parsed = parseToolResultContent(entry.content);
-        if (parsed?.request_id && parsed?.status === "completed" && Array.isArray(parsed?.output_cdn_urls) && parsed.output_cdn_urls.length > 0) {
-          mediaUrlsByRequestId.set(parsed.request_id, parsed.output_cdn_urls);
-        }
-        if (parsed?.request_id && parsed?.status === "completed" && Array.isArray(parsed?.urls) && parsed.urls.length > 0) {
-          mediaUrlsByRequestId.set(parsed.request_id, parsed.urls);
-        }
-      }
-    }
-  }
-  for (let i = 0; i < conversation.length; i++) {
-    if (consumed.has(i)) continue;
-    const entry = conversation[i];
-    if (entry.type === "tool_call" && entry.tool_name) {
-      const toolDef = getToolDefinition(entry.tool_name);
-      const parsedInput = toolDef?.parseInput?.(entry.tool_input) || null;
-      let parsedResult = null;
-      if (pairToolResults && toolDef?.consumesResult && toolDef.parseResult && entry.tool_use_id) {
-        const resultIndex = resultsByToolUseId.get(entry.tool_use_id);
-        if (resultIndex !== void 0) {
-          const resultEntry = conversation[resultIndex];
-          if (resultEntry.type === "tool_result" && typeof resultEntry.content === "string") {
-            parsedResult = toolDef.parseResult(resultEntry.content);
-            consumed.add(resultIndex);
-            const immediateResult = parseToolResultContent(resultEntry.content);
-            const requestId = immediateResult?.request_id;
-            if (requestId) {
-              const isGenerativeTool = entry.tool_name?.includes("generative_");
-              if (isGenerativeTool && entry.tool_use_id && parsedInput?.data) {
-                metadataByRequestId.set(requestId, {
-                  toolUseId: entry.tool_use_id,
-                  toolName: entry.tool_name,
-                  prompt: parsedInput.data.prompt,
-                  model: parsedInput.data.model,
-                  aspectRatio: parsedInput.data.aspectRatio,
-                  inputMediaUrls: parsedInput.data.inputMediaUrls || parsedInput.data.inputImageUrls,
-                  lastFrameUrl: parsedInput.data.lastFrameUrl,
-                  elements: parsedInput.data.elements
-                });
-              }
-              const eventualUrls = mediaUrlsByRequestId.get(requestId);
-              if (eventualUrls) {
-                if (!parsedResult) {
-                  const mediaType = entry.tool_name?.includes("video") ? "video" : entry.tool_name?.includes("audio") ? "audio" : "image";
-                  parsedResult = {
-                    type: `${mediaType}_generation_complete`,
-                    data: { mediaInfo: { urls: eventualUrls, requestId } }
-                  };
-                } else if (!parsedResult.data?.mediaInfo) {
-                  parsedResult.data.mediaInfo = { urls: eventualUrls, requestId };
-                }
-              }
-            }
-            if (toolDef.consumeExtra && toolDef.consumeExtra > 0) {
-              for (let j = 1; j <= toolDef.consumeExtra; j++) {
-                const extraIndex = resultIndex + j;
-                if (extraIndex < conversation.length) {
-                  consumed.add(extraIndex);
-                }
-              }
-            }
-            if (parsedResult?.type === "request_status_completed") {
-              const mediaInfo = parsedResult.data?.mediaInfo;
-              if (mediaInfo?.requestId) {
-                const originalMetadata = metadataByRequestId.get(mediaInfo.requestId);
-                if (originalMetadata) {
-                  mediaInfo.originalToolUseId = originalMetadata.toolUseId;
-                  mediaInfo.originalToolName = originalMetadata.toolName;
-                  mediaInfo.prompt = originalMetadata.prompt;
-                  mediaInfo.model = originalMetadata.model;
-                  mediaInfo.aspectRatio = originalMetadata.aspectRatio;
-                  mediaInfo.inputMediaUrls = originalMetadata.inputMediaUrls;
-                  mediaInfo.lastFrameUrl = originalMetadata.lastFrameUrl;
-                  mediaInfo.elements = originalMetadata.elements;
-                }
-              }
-            }
-          }
-        }
-      }
-      processed.push({
-        entry,
-        originalType: "tool_call",
-        displayType: parsedInput?.type || "unknown_tool",
-        iconName: toolDef?.iconName || "Wrench",
-        iconData: entry.tool_input,
-        title: toolDef && entry.tool_name.startsWith("mcp__jade__") ? toolDef.displayName : void 0,
-        data: {
-          toolName: entry.tool_name,
-          toolUseId: entry.tool_use_id,
-          input: parsedInput,
-          result: parsedResult
-        },
-        timestamp: entry.timestamp,
-        toolDefinition: toolDef,
-        parsedInput: parsedInput || void 0,
-        parsedResult: parsedResult || void 0
-      });
-      continue;
-    }
-    if (entry.type === "tool_result" && typeof entry.content === "string") {
-      try {
-        const parsed = parseToolResultContent(entry.content);
-        if (parsed?.request_id && parsed?.status && parsed?.message) {
-          processed.push({
-            entry,
-            originalType: "tool_result",
-            displayType: "simple_message",
-            iconName: "Wrench",
-            data: { message: parsed.message },
-            timestamp: entry.timestamp
-          });
-          continue;
-        }
-      } catch {
-      }
-      const mediaInfo = extractMediaInfo(entry.content);
-      if (mediaInfo) {
-        processed.push({
-          entry,
-          originalType: "tool_result",
-          displayType: "media_carousel",
-          iconName: "Wrench",
-          data: {
-            mediaInfo: {
-              requestId: mediaInfo.requestId,
-              urls: mediaInfo.urls
-            }
-          },
-          timestamp: entry.timestamp
-        });
-        continue;
-      }
-      processed.push({
-        entry,
-        originalType: "tool_result",
-        displayType: "raw_content",
-        iconName: "Wrench",
-        data: { content: entry.content },
-        timestamp: entry.timestamp
-      });
-      continue;
-    }
-    if (skipSkillContext) {
-      if (entry.type === "user_text" && entry.text?.startsWith("Base directory for this skill:")) {
-        continue;
-      }
-      if (entry.type === "user_text" && entry.text?.startsWith("Caveat:")) {
-        continue;
-      }
-    }
-    if (entry.type === "user_text" && entry.text) {
-      const isCompactSummary = entry.text.startsWith("This session is being continued from a previous conversation");
-      if (isCompactSummary) {
-        processed.push({
-          entry,
-          originalType: "compact",
-          displayType: "compact",
-          iconName: "Sparkles",
-          data: {
-            isCompacting: false,
-            summary: entry.text
-          },
-          timestamp: entry.timestamp
-        });
-        continue;
-      }
-      processed.push({
-        entry,
-        originalType: "user_text",
-        displayType: "user_text",
-        iconName: "User",
-        data: { text: entry.text },
-        timestamp: entry.timestamp
-      });
-      continue;
-    }
-    if (entry.type === "assistant_text" && entry.text) {
-      const processedEntry = {
-        entry,
-        originalType: "assistant_text",
-        displayType: "markdown_text",
-        iconName: "Bot",
-        data: { text: entry.text },
-        timestamp: entry.timestamp
-      };
-      if (hasSuggestions(entry.text)) {
-        const { cleanText, suggestions, segments } = parseSuggestions(entry.text);
-        processedEntry.data = { text: cleanText };
-        processedEntry.suggestions = suggestions;
-        processedEntry.textSegments = segments;
-      }
-      processed.push(processedEntry);
-      continue;
-    }
-    if (entry.type === "compact_boundary") {
-      const nextEntry = conversation[i + 1];
-      const isNextSummary = nextEntry?.type === "compact_summary" || nextEntry?.type === "user_text" && nextEntry.text?.startsWith("This session is being continued from a previous conversation");
-      if (isNextSummary) {
-        consumed.add(i + 1);
-        processed.push({
-          entry,
-          originalType: "compact",
-          displayType: "compact",
-          iconName: "Sparkles",
-          data: {
-            isCompacting: false,
-            summary: nextEntry.text || ""
-          },
-          timestamp: entry.timestamp
-        });
-      } else {
-        processed.push({
-          entry,
-          originalType: "compact",
-          displayType: "compact",
-          iconName: "Sparkles",
-          data: {
-            isCompacting: true,
-            summary: null
-          },
-          timestamp: entry.timestamp
-        });
-      }
-      continue;
-    }
-    if (entry.type === "compact_summary") {
-      processed.push({
-        entry,
-        originalType: "compact",
-        displayType: "compact",
-        iconName: "Sparkles",
-        data: {
-          isCompacting: false,
-          summary: entry.text || ""
-        },
-        timestamp: entry.timestamp
-      });
-      continue;
-    }
-    if (entry.type === "error") {
-      processed.push({
-        entry,
-        originalType: "error",
-        displayType: "error",
-        iconName: "AlertTriangle",
-        data: {
-          text: entry.text || "Unknown error"
-        },
-        timestamp: entry.timestamp
-      });
-      continue;
-    }
-  }
-  return processed;
-}
-var ACCEPTED_EXTENSIONS = {
-  image: [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".svg"],
-  video: [".mp4", ".mov", ".webm", ".avi", ".mkv", ".m4v"],
-  audio: [".mp3", ".wav", ".m4a", ".aac", ".ogg", ".oga", ".mpeg"],
-  document: [".pdf"]
-};
-function getMediaTypeFromExtension(filename) {
-  const normalizedFilename = filename.toLowerCase();
-  for (const [type, extensions] of Object.entries(ACCEPTED_EXTENSIONS)) {
-    if (extensions.some((ext) => normalizedFilename.endsWith(ext))) {
-      return type;
-    }
-  }
-  return null;
-}
-function getMediaTypeFromUrl(url) {
-  try {
-    const urlObj = new URL(url);
-    const pathname = urlObj.pathname;
-    const filename = pathname.split("/").pop() || "";
-    return getMediaTypeFromExtension(filename);
-  } catch {
-    const cleanUrl = url.split("?")[0];
-    return getMediaTypeFromExtension(cleanUrl);
-  }
-}
-function extractMedia(conversation) {
-  const urlMap = /* @__PURE__ */ new Map();
-  const processed = processConversation(conversation);
-  for (const entry of processed) {
-    if (entry.originalType === "tool_call") {
-      const data = entry.data;
-      const result = data?.result;
-      const resultData = result?.data;
-      const mediaInfo = resultData?.mediaInfo;
-      const urls = mediaInfo?.urls;
-      if (urls && Array.isArray(urls)) {
-        const input = data?.input;
-        const inputData = input?.data;
-        const toolName = data?.toolName;
-        const toolUseId = data?.toolUseId;
-        for (const url of urls) {
-          if (typeof url !== "string") continue;
-          const detectedType = getMediaTypeFromUrl(url);
-          const type = detectedType === "video" ? "video" : detectedType === "audio" ? "audio" : "image";
-          const existing = urlMap.get(url);
-          const hasInputMetadata = !!(inputData?.prompt || inputData?.model);
-          const existingHasMetadata = !!(existing?.prompt || existing?.model);
-          if (!existing || hasInputMetadata && !existingHasMetadata) {
-            urlMap.set(url, {
-              url,
-              type,
-              timestamp: entry.timestamp,
-              toolName,
-              toolUseId,
-              prompt: inputData?.prompt,
-              model: inputData?.model,
-              aspectRatio: inputData?.aspectRatio,
-              inputMediaUrls: inputData?.inputImageUrls || inputData?.inputMediaUrls
-            });
-          }
-        }
-        continue;
-      }
-    }
-    if (entry.originalType === "tool_result" && entry.displayType === "media_carousel") {
-      const data = entry.data;
-      const mediaInfo = data?.mediaInfo;
-      const urls = mediaInfo?.urls;
-      if (urls && Array.isArray(urls)) {
-        for (const url of urls) {
-          if (typeof url !== "string") continue;
-          const detectedType = getMediaTypeFromUrl(url);
-          const type = detectedType === "video" ? "video" : detectedType === "audio" ? "audio" : "image";
-          if (!urlMap.has(url)) {
-            urlMap.set(url, {
-              url,
-              type,
-              timestamp: entry.timestamp
-            });
-          }
-        }
-      }
-    }
-  }
-  const mediaArray = Array.from(urlMap.values());
-  mediaArray.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
-  return mediaArray;
-}
-
-// src/react-native/sse-adapter.ts
-var import_react_native_sse = __toESM(require_react_native_sse());
-var MAX_RETRIES2 = 5;
-var INITIAL_RETRY_DELAY2 = 1e3;
-var MAX_RETRY_DELAY2 = 1e4;
-async function createRNSSEStream(options) {
-  const {
-    url,
-    headers,
-    body,
-    emitter,
-    signal,
-    onOpen,
-    onClose,
-    lastEventId
-  } = options;
-  const processedIds = /* @__PURE__ */ new Set();
-  let retryCount = 0;
-  return new Promise((resolve, reject) => {
-    let es = null;
-    let isClosed = false;
-    const cleanup = () => {
-      if (!isClosed) {
-        isClosed = true;
-        es?.close();
-        onClose?.();
-        resolve();
-      }
-    };
-    const abortHandler = () => {
-      cleanup();
-    };
-    signal?.addEventListener("abort", abortHandler);
-    const connect = () => {
-      if (isClosed || signal?.aborted) {
-        return;
-      }
-      es = new import_react_native_sse.default(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...lastEventId ? { "Last-Event-ID": lastEventId } : {},
-          ...headers
-        },
-        body: JSON.stringify({ ...body, stream: true }),
-        pollingInterval: 0
-        // Disable polling, we handle reconnection manually
-      });
-      es.addEventListener("open", () => {
-        retryCount = 0;
-        onOpen?.();
-      });
-      const eventTypes = [
-        "init",
-        "session",
-        "entry",
-        "stream_event",
-        "content_block_start",
-        "content_block_delta",
-        "content_block_stop",
-        "complete",
-        "error",
-        "heartbeat"
-      ];
-      for (const eventType of eventTypes) {
-        es.addEventListener(eventType, (event) => {
-          console.log(`[RN-SSE] Received ${eventType} event:`, event.data?.substring?.(0, 100) || event.data);
-          const eventData = {
-            data: event.data,
-            lastEventId: event.lastEventId ?? void 0
-          };
-          handleSSEEvent(eventType, eventData, emitter, processedIds);
-        });
-      }
-      es.addEventListener("message", (event) => {
-        console.log("[RN-SSE] Received message event:", event.data?.substring?.(0, 100) || event.data);
-        const eventData = {
-          data: event.data,
-          lastEventId: event.lastEventId ?? void 0
-        };
-        handleSSEEvent("message", eventData, emitter, processedIds);
-      });
-      es.addEventListener("error", (event) => {
-        console.log("[RN-SSE] Error event:", JSON.stringify(event));
-        if (signal?.aborted || isClosed) {
-          cleanup();
-          return;
-        }
-        const errorMessage = event.message || "Connection error";
-        const status = event.xhrStatus;
-        if (status === 401 || status === 403 || errorMessage.includes("401") || errorMessage.includes("403") || errorMessage.includes("Authentication")) {
-          const authError = `Authentication failed (${status || "unknown"}): ${errorMessage}`;
-          console.log("[RN-SSE] Auth error detected:", authError);
-          emitter.emit("error", { error: authError });
-          cleanup();
-          reject(new Error(authError));
-          return;
-        }
-        if (errorMessage.includes("404")) {
-          emitter.emit("error", { error: "Session not found or not active" });
-          cleanup();
-          reject(new Error("Session not found or not active"));
-          return;
-        }
-        if (errorMessage.includes("503")) {
-          emitter.emit("error", { error: `Server unavailable: ${errorMessage}` });
-          cleanup();
-          reject(new Error(errorMessage));
-          return;
-        }
-        retryCount++;
-        if (retryCount > MAX_RETRIES2) {
-          const error = `Connection failed after ${MAX_RETRIES2} retries`;
-          emitter.emit("error", { error });
-          cleanup();
-          reject(new Error(error));
-          return;
-        }
-        const delay = Math.min(
-          INITIAL_RETRY_DELAY2 * Math.pow(2, retryCount - 1),
-          MAX_RETRY_DELAY2
-        );
-        console.log(`[RN-SSE] Retry ${retryCount}/${MAX_RETRIES2} in ${delay}ms`);
-        es?.close();
-        setTimeout(connect, delay);
-      });
-      es.addEventListener("close", () => {
-        cleanup();
-      });
-    };
-    connect();
-  });
-}
-function handleSSEEvent(eventType, event, emitter, processedIds) {
-  if (event.lastEventId && processedIds.has(event.lastEventId)) {
-    return;
-  }
-  if (event.lastEventId) {
-    processedIds.add(event.lastEventId);
-  }
-  if (!event.data) {
-    return;
-  }
-  try {
-    const data = JSON.parse(event.data);
-    switch (eventType) {
-      case "init":
-      case "session":
-        emitter.emit("session", { session_id: data.session_id });
-        break;
-      case "entry":
-        emitter.emit("entry", { entry: data });
-        break;
-      case "stream_event":
-        handleStreamEvent2(data, emitter);
-        break;
-      case "content_block_start":
-        emitter.emit("content_block_start", data);
-        break;
-      case "content_block_delta":
-        emitter.emit("content_block_delta", data);
-        break;
-      case "content_block_stop":
-        emitter.emit("content_block_stop", data);
-        break;
-      case "complete":
-        emitter.emit("complete", data);
-        break;
-      case "error":
-        emitter.emit("error", { error: data.error });
-        break;
-      case "heartbeat":
-        emitter.emit("heartbeat", {});
-        break;
-      case "message":
-        if (data.type) {
-          handleSSEEvent(data.type, { data: JSON.stringify(data) }, emitter, processedIds);
-        }
-        break;
-      default:
-        break;
-    }
-  } catch (e) {
-    console.error("[RN-SSE] Failed to parse event:", event.data, e);
-  }
-}
-function handleStreamEvent2(data, emitter) {
-  const streamEvent = data.event || data;
-  const eventData = streamEvent;
-  switch (eventData.type) {
-    case "content_block_start":
-      emitter.emit("content_block_start", eventData);
-      break;
-    case "content_block_delta":
-      emitter.emit("content_block_delta", eventData);
-      break;
-    case "content_block_stop":
-      emitter.emit("content_block_stop", eventData);
-      break;
-  }
-}
-
-// src/react-native/client.ts
-var RNAgentClient = class {
-  config;
-  baseClient;
-  activeStreams = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = {
-      apiVersion: "/v1",
-      timeout: 3e4,
-      ...config
-    };
-    this.baseClient = new AgentClient(config);
-  }
-  // ===========================================================================
-  // Public getters
-  // ===========================================================================
-  /** Whether org context is configured (orgId is set) */
-  get hasOrgContext() {
-    return this.baseClient.hasOrgContext;
-  }
-  // ===========================================================================
-  // Private helpers
-  // ===========================================================================
-  get baseUrl() {
-    return `${this.config.endpoint}${this.config.apiVersion}`;
-  }
-  async getHeaders() {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    const token = await this.config.getAuthToken();
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    return headers;
-  }
-  // ===========================================================================
-  // Messages API - React Native specific SSE implementation
-  // ===========================================================================
-  /**
-   * Send a message and stream responses using React Native SSE.
-   * @returns Object with event emitter and abort function
-   */
-  stream(request) {
-    const emitter = new AgentEventEmitter();
-    const controller = new AbortController();
-    const streamId = request.session_id || `stream-${Date.now()}`;
-    this.activeStreams.set(streamId, controller);
-    (async () => {
-      try {
-        const headers = await this.getHeaders();
-        await createRNSSEStream({
-          url: `${this.baseUrl}/messages`,
-          method: "POST",
-          headers,
-          body: { ...request, stream: true },
-          emitter,
-          signal: controller.signal
-        });
-      } catch (error) {
-        emitter.emit("error", {
-          error: error instanceof Error ? error.message : "Unknown error"
-        });
-      } finally {
-        this.activeStreams.delete(streamId);
-      }
-    })();
-    return {
-      emitter,
-      abort: () => controller.abort()
-    };
-  }
-  /**
-   * Reconnect to an active streaming session using React Native SSE.
-   * @returns Object with event emitter and abort function
-   */
-  reconnect(sessionId, lastEventId = -1) {
-    const emitter = new AgentEventEmitter();
-    const controller = new AbortController();
-    (async () => {
-      try {
-        const headers = await this.getHeaders();
-        await createRNSSEStream({
-          url: `${this.baseUrl}/sessions/${sessionId}/reconnect`,
-          method: "POST",
-          headers,
-          body: { last_event_id: lastEventId },
-          emitter,
-          signal: controller.signal
-        });
-      } catch (error) {
-        emitter.emit("error", {
-          error: error instanceof Error ? error.message : "Unknown error"
-        });
-      }
-    })();
-    return {
-      emitter,
-      abort: () => controller.abort()
-    };
-  }
-  // ===========================================================================
-  // Sessions API - Delegate to base client
-  // ===========================================================================
-  /**
-   * List all sessions for the authenticated user.
-   */
-  async listSessions() {
-    return this.baseClient.listSessions();
-  }
-  /**
-   * Get session content in display format.
-   */
-  async getSession(sessionId) {
-    return this.baseClient.getSession(sessionId);
-  }
-  /**
-   * Get session content as raw JSONL.
-   */
-  async getSessionRaw(sessionId) {
-    return this.baseClient.getSessionRaw(sessionId);
-  }
-  /**
-   * Check if a session is actively streaming.
-   */
-  async getSessionStatus(sessionId) {
-    return this.baseClient.getSessionStatus(sessionId);
-  }
-  /**
-   * Update session metadata (name).
-   */
-  async updateSession(sessionId, updates) {
-    return this.baseClient.updateSession(sessionId, updates);
-  }
-  /**
-   * Delete a session.
-   */
-  async deleteSession(sessionId) {
-    return this.baseClient.deleteSession(sessionId);
-  }
-  /**
-   * Cancel an active session query.
-   */
-  async cancelSession(sessionId) {
-    return this.baseClient.cancelSession(sessionId);
-  }
-  // ===========================================================================
-  // Skills API - Personal - Delegate to base client
-  // ===========================================================================
-  /**
-   * List personal skills.
-   */
-  async listSkills() {
-    return this.baseClient.listSkills();
-  }
-  /**
-   * Get personal skill content.
-   */
-  async getSkill(name) {
-    return this.baseClient.getSkill(name);
-  }
-  /**
-   * Create or update a personal skill.
-   */
-  async saveSkill(skill) {
-    return this.baseClient.saveSkill(skill);
-  }
-  /**
-   * Delete a personal skill.
-   */
-  async deleteSkill(name) {
-    return this.baseClient.deleteSkill(name);
-  }
-  // ===========================================================================
-  // Skills API - Organization - Delegate to base client
-  // ===========================================================================
-  /**
-   * List organization skills.
-   */
-  async listOrgSkills() {
-    return this.baseClient.listOrgSkills();
-  }
-  /**
-   * Get organization skill content.
-   */
-  async getOrgSkill(name) {
-    return this.baseClient.getOrgSkill(name);
-  }
-  /**
-   * Create or update an organization skill.
-   */
-  async saveOrgSkill(skill) {
-    return this.baseClient.saveOrgSkill(skill);
-  }
-  /**
-   * Delete an organization skill.
-   */
-  async deleteOrgSkill(name) {
-    return this.baseClient.deleteOrgSkill(name);
-  }
-  // ===========================================================================
-  // Plugins API - Delegate to base client
-  // ===========================================================================
-  /**
-   * Get plugin manifest for client sync.
-   */
-  async getPluginManifest() {
-    return this.baseClient.getPluginManifest();
-  }
-  /**
-   * Download plugin bundle.
-   */
-  async getPluginBundle(skills) {
-    return this.baseClient.getPluginBundle(skills);
-  }
-};
-var RNAgentContext = react.createContext(null);
-function RNAgentProvider({
-  children,
-  config,
-  storage,
-  pauseOnBackground = true
-}) {
-  const [appState, setAppState] = react.useState(reactNative.AppState.currentState);
-  react.useEffect(() => {
-    if (!pauseOnBackground) return;
-    const subscription = reactNative.AppState.addEventListener("change", (nextState) => {
-      setAppState(nextState);
-    });
-    return () => subscription.remove();
-  }, [pauseOnBackground]);
-  const client = react.useMemo(
-    () => new RNAgentClient(config),
-    // Only recreate client if endpoint changes
-    [config.endpoint, config.apiVersion, config.timeout]
-  );
-  const value = react.useMemo(
-    () => ({ client, storage, appState }),
-    [client, storage, appState]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(RNAgentContext.Provider, { value, children });
-}
-function useRNAgentClient() {
-  const context = react.useContext(RNAgentContext);
-  if (!context) {
-    throw new Error("useRNAgentClient must be used within an RNAgentProvider");
-  }
-  return context.client;
-}
-function useStorage() {
-  const context = react.useContext(RNAgentContext);
-  if (!context) {
-    throw new Error("useStorage must be used within an RNAgentProvider");
-  }
-  return context.storage;
-}
-function useAppState() {
-  const context = react.useContext(RNAgentContext);
-  if (!context) {
-    throw new Error("useAppState must be used within an RNAgentProvider");
-  }
-  return context.appState;
-}
-function useRNAgentSession(options = {}) {
-  const client = useRNAgentClient();
-  const appState = useAppState();
-  const {
-    initialSessionId,
-    initialConversation,
-    onMediaGenerated,
-    pauseOnBackground = true
-  } = options;
-  const [session, setSession] = react.useState({
-    sessionId: initialSessionId,
-    conversation: initialConversation ?? [],
-    isStreaming: false
-  });
-  const abortRef = react.useRef(null);
-  const cancelInProgressRef = react.useRef(false);
-  const accumulatedTextRef = react.useRef({});
-  react.useEffect(() => {
-    if (pauseOnBackground && appState !== "active" && session.isStreaming) {
-      console.log("[RNAgentSession] App went to background while streaming");
-    }
-  }, [appState, pauseOnBackground, session.isStreaming]);
-  const setupEventHandlers = react.useCallback(
-    (emitter) => {
-      emitter.on("session", (data) => {
-        setSession((prev) => ({ ...prev, sessionId: data.session_id }));
-      });
-      emitter.on("content_block_start", (data) => {
-        const block = data.content_block;
-        if (block?.type === "text") {
-          accumulatedTextRef.current[data.index] = "";
-          setSession((prev) => ({ ...prev, showTinkering: false }));
-        } else if (block?.type === "tool_use") {
-          setSession((prev) => ({
-            ...prev,
-            streamingToolCall: {
-              tool_name: block.name || "",
-              tool_use_id: block.id || "",
-              block_index: data.index,
-              accumulated_input: ""
-            },
-            showTinkering: false
-          }));
-        }
-      });
-      emitter.on("content_block_delta", (data) => {
-        const delta = data.delta;
-        if (delta?.type === "text_delta" && delta.text) {
-          const idx = data.index ?? 0;
-          accumulatedTextRef.current[idx] = (accumulatedTextRef.current[idx] || "") + delta.text;
-          setSession((prev) => ({
-            ...prev,
-            streamingText: accumulatedTextRef.current[idx],
-            streamingBlockIndex: idx,
-            showTinkering: false
-          }));
-        } else if (delta?.type === "input_json_delta" && delta.partial_json) {
-          setSession((prev) => {
-            if (!prev.streamingToolCall) return prev;
-            return {
-              ...prev,
-              streamingToolCall: {
-                ...prev.streamingToolCall,
-                accumulated_input: (prev.streamingToolCall.accumulated_input || "") + delta.partial_json
-              }
-            };
-          });
-        }
-      });
-      emitter.on("content_block_stop", (data) => {
-        const idx = data.index ?? 0;
-        if (accumulatedTextRef.current[idx] !== void 0) {
-          delete accumulatedTextRef.current[idx];
-          setSession((prev) => ({
-            ...prev,
-            streamingText: void 0,
-            streamingBlockIndex: void 0
-          }));
-        }
-      });
-      emitter.on("entry", (data) => {
-        const entry = data.entry;
-        if (entry.type === "tool_result" && onMediaGenerated) {
-          const media = extractMediaFromEntry(entry);
-          if (media) {
-            onMediaGenerated(media.urls, media.type);
-          }
-        }
-        if (entry.type === "tool_call") {
-          setSession((prev) => ({
-            ...prev,
-            conversation: [...prev.conversation, entry],
-            streamingToolCall: void 0
-          }));
-        } else {
-          setSession((prev) => ({
-            ...prev,
-            conversation: [...prev.conversation, entry]
-          }));
-        }
-      });
-      emitter.on("complete", (data) => {
-        setSession((prev) => ({
-          ...prev,
-          sessionId: data.session_id || prev.sessionId,
-          isStreaming: false,
-          showTinkering: false
-        }));
-        abortRef.current = null;
-      });
-      emitter.on("error", (data) => {
-        setSession((prev) => ({
-          ...prev,
-          conversation: [
-            ...prev.conversation,
-            {
-              type: "error",
-              text: data.error,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            }
-          ],
-          isStreaming: false,
-          showTinkering: false
-        }));
-        abortRef.current = null;
-      });
-    },
-    [onMediaGenerated]
-  );
-  const sendMessage = react.useCallback(
-    async (prompt, skills) => {
-      if (!prompt.trim() || session.isStreaming) return;
-      const userEntry = {
-        type: "user_text",
-        text: prompt,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      setSession((prev) => ({
-        ...prev,
-        conversation: [...prev.conversation, userEntry],
-        isStreaming: true,
-        showTinkering: true
-      }));
-      accumulatedTextRef.current = {};
-      const { emitter, abort } = client.stream({
-        prompt,
-        session_id: session.sessionId,
-        skills
-      });
-      abortRef.current = abort;
-      setupEventHandlers(emitter);
-    },
-    [client, session.sessionId, session.isStreaming, setupEventHandlers]
-  );
-  const cancel = react.useCallback(async () => {
-    if (cancelInProgressRef.current) {
-      return;
-    }
-    cancelInProgressRef.current = true;
-    try {
-      if (session.sessionId) {
-        try {
-          await client.cancelSession(session.sessionId);
-        } catch (error) {
-          console.error("[RNAgentSession] Server-side cancel failed:", error);
-        }
-      } else {
-        console.warn("[RNAgentSession] No sessionId available for server-side cancel");
-      }
-      if (abortRef.current) {
-        abortRef.current();
-        abortRef.current = null;
-      }
-      setSession((prev) => ({
-        ...prev,
-        isStreaming: false,
-        showTinkering: false,
-        streamingText: void 0,
-        streamingToolCall: void 0
-      }));
-    } finally {
-      cancelInProgressRef.current = false;
-    }
-  }, [client, session.sessionId]);
-  const clear = react.useCallback(() => {
-    setSession({
-      conversation: [],
-      isStreaming: false
-    });
-  }, []);
-  const setSessionId = react.useCallback((id) => {
-    setSession((prev) => ({ ...prev, sessionId: id }));
-  }, []);
-  const setConversation = react.useCallback(
-    (entries, sessionId) => {
-      setSession((prev) => ({
-        ...prev,
-        conversation: entries,
-        sessionId: sessionId ?? prev.sessionId,
-        isStreaming: false,
-        streamingText: void 0,
-        streamingToolCall: void 0,
-        showTinkering: false
-      }));
-    },
-    []
-  );
-  const reconnect = react.useCallback(
-    async (targetSessionId, freshConversation, streamingPrompt) => {
-      let conversation = freshConversation ?? [];
-      if (streamingPrompt) {
-        conversation = [
-          ...conversation,
-          {
-            type: "user_text",
-            text: streamingPrompt,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        ];
-      }
-      setSession((prev) => ({
-        ...prev,
-        sessionId: targetSessionId,
-        conversation,
-        isStreaming: true,
-        showTinkering: true
-      }));
-      accumulatedTextRef.current = {};
-      const { emitter, abort } = client.reconnect(targetSessionId, -1);
-      abortRef.current = abort;
-      setupEventHandlers(emitter);
-    },
-    [client, setupEventHandlers]
-  );
-  const loadSession = react.useCallback(
-    async (sessionId) => {
-      const response = await client.getSession(sessionId);
-      return response.conversation;
-    },
-    [client]
-  );
-  return {
-    sessionId: session.sessionId,
-    conversation: session.conversation,
-    isStreaming: session.isStreaming,
-    streamingText: session.streamingText,
-    streamingToolCall: session.streamingToolCall,
-    showTinkering: session.showTinkering ?? false,
-    sendMessage,
-    cancel,
-    clear,
-    reconnect,
-    setSessionId,
-    setConversation,
-    loadSession
-  };
-}
-function detectMediaType(url) {
-  if (/\.(mp4|mov|webm|avi|mkv|m4v)(\?|$)/i.test(url)) return "video";
-  if (/\.(mp3|wav|m4a|aac|ogg)(\?|$)/i.test(url)) return "audio";
-  return "image";
-}
-function extractMediaFromEntry(entry) {
-  if (entry.type !== "tool_result") return null;
-  let result = null;
-  if (typeof entry.content === "string") {
-    try {
-      result = JSON.parse(entry.content);
-    } catch {
-      return null;
-    }
-  }
-  if (!result) return null;
-  const mediaInfo = result.mediaInfo || result.data?.mediaInfo;
-  if (mediaInfo?.urls && mediaInfo.urls.length > 0) {
-    const type = detectMediaType(mediaInfo.urls[0]);
-    return { urls: mediaInfo.urls, type };
-  }
-  const cdnUrls = result.output_cdn_urls || result.data?.output_cdn_urls;
-  if (cdnUrls && cdnUrls.length > 0) {
-    const type = detectMediaType(cdnUrls[0]);
-    return { urls: cdnUrls, type };
-  }
-  return null;
-}
-function useJadeSession(options = {}) {
-  const {
-    skipSkillContext = true,
-    processingOptions,
-    ...agentOptions
-  } = options;
-  const session = useRNAgentSession(agentOptions);
-  const processedConversation = react.useMemo(() => {
-    return processConversation(session.conversation, {
-      skipSkillContext,
-      pairToolResults: true,
-      extractMedia: true,
-      ...processingOptions
-    });
-  }, [session.conversation, skipSkillContext, processingOptions]);
-  const media = react.useMemo(() => {
-    return extractMedia(session.conversation);
-  }, [session.conversation]);
-  return {
-    ...session,
-    processedConversation,
-    media
-  };
-}
-
-// src/react-native/storage-adapter.ts
-function createAsyncStorageAdapter(asyncStorage) {
-  return {
-    getItem: (key) => asyncStorage.getItem(key),
-    setItem: (key, value) => asyncStorage.setItem(key, value),
-    removeItem: (key) => asyncStorage.removeItem(key)
-  };
-}
-function createMMKVAdapter(mmkv) {
-  return {
-    getItem: async (key) => mmkv.getString(key) ?? null,
-    setItem: async (key, value) => mmkv.set(key, value),
-    removeItem: async (key) => mmkv.delete(key)
-  };
-}
-function createMemoryStorageAdapter() {
-  const store = /* @__PURE__ */ new Map();
-  return {
-    getItem: async (key) => store.get(key) ?? null,
-    setItem: async (key, value) => {
-      store.set(key, value);
-    },
-    removeItem: async (key) => {
-      store.delete(key);
-    }
-  };
-}
-var STORAGE_KEYS = {
-  AUTH_TOKEN: "@gr33n-ai/auth-token",
-  ENDPOINT: "@gr33n-ai/endpoint",
-  ORG_ID: "@gr33n-ai/org-id",
-  LAST_SESSION_ID: "@gr33n-ai/last-session-id",
-  USER_PREFERENCES: "@gr33n-ai/user-preferences"
-};
-
-exports.RNAgentProvider = RNAgentProvider;
-exports.STORAGE_KEYS = STORAGE_KEYS;
-exports.createAsyncStorageAdapter = createAsyncStorageAdapter;
-exports.createMMKVAdapter = createMMKVAdapter;
-exports.createMemoryStorageAdapter = createMemoryStorageAdapter;
-exports.useAppState = useAppState;
-exports.useJadeSession = useJadeSession;
-exports.useRNAgentClient = useRNAgentClient;
-exports.useRNAgentSession = useRNAgentSession;
-exports.useStorage = useStorage;