@gr33n-ai/jade-sdk-client 0.1.0 → 0.1.3

package/dist/react/index.js

@@ -1,2070 +0,0 @@
-import { createContext, useMemo, useContext, useState, useRef, useCallback } from 'react';
-import { jsx } from 'react/jsx-runtime';
-import useSWR from 'swr';
-
-// ../../agent-sdk/client/dist/react/index.mjs
-
-// ../../node_modules/.pnpm/@microsoft+fetch-event-source@2.0.1/node_modules/@microsoft/fetch-event-source/lib/esm/parse.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
-  };
-}
-
-// ../../node_modules/.pnpm/@microsoft+fetch-event-source@2.0.1/node_modules/@microsoft/fetch-event-source/lib/esm/fetch.js
-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));
-  }
-};
-var AgentContext = createContext(null);
-function AgentProvider({ children, config }) {
-  const client = useMemo(
-    () => new AgentClient(config),
-    // Only recreate client if endpoint changes
-    // getAuthToken is a function and should not trigger recreation
-    [config.endpoint, config.apiVersion, config.timeout]
-  );
-  return /* @__PURE__ */ jsx(AgentContext.Provider, { value: { client }, children });
-}
-function useAgentClient() {
-  const context = useContext(AgentContext);
-  if (!context) {
-    throw new Error("useAgentClient must be used within an AgentProvider");
-  }
-  return context.client;
-}
-function useAgentSession(options = {}) {
-  const client = useAgentClient();
-  const { initialSessionId, initialConversation, onMediaGenerated } = options;
-  const [session, setSession] = useState({
-    sessionId: initialSessionId,
-    conversation: initialConversation ?? [],
-    isStreaming: false
-  });
-  const abortRef = useRef(null);
-  const accumulatedTextRef = useRef({});
-  const setupEventHandlers = 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: "assistant_text",
-              text: `Error: ${data.error}`,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            }
-          ],
-          isStreaming: false,
-          showTinkering: false
-        }));
-        abortRef.current = null;
-      });
-    },
-    [onMediaGenerated]
-  );
-  const sendMessage = 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 = useCallback(async () => {
-    abortRef.current?.();
-    abortRef.current = null;
-    if (session.sessionId) {
-      try {
-        await client.cancelSession(session.sessionId);
-      } catch (error) {
-        console.error("[Cancel] Server-side cancel failed:", error);
-      }
-    }
-    setSession((prev) => ({
-      ...prev,
-      isStreaming: false,
-      showTinkering: false,
-      streamingText: void 0,
-      streamingToolCall: void 0
-    }));
-  }, [client, session.sessionId]);
-  const clear = useCallback(() => {
-    setSession({
-      conversation: [],
-      isStreaming: false
-    });
-  }, []);
-  const setSessionId = useCallback((id) => {
-    setSession((prev) => ({ ...prev, sessionId: id }));
-  }, []);
-  const setConversation = useCallback(
-    (entries, sessionId) => {
-      setSession((prev) => ({
-        ...prev,
-        conversation: entries,
-        sessionId: sessionId ?? prev.sessionId,
-        isStreaming: false,
-        streamingText: void 0,
-        streamingToolCall: void 0,
-        showTinkering: false
-      }));
-    },
-    []
-  );
-  const reconnect = 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 = 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 useSkills() {
-  const client = useAgentClient();
-  const [isSaving, setIsSaving] = useState(false);
-  const {
-    data: skillsData,
-    error: skillsError,
-    mutate: mutateSkills,
-    isLoading: isLoadingSkills
-  } = useSWR("agent-sdk-skills", () => client.listSkills(), {
-    revalidateOnFocus: false,
-    dedupingInterval: 6e4
-    // 1 minute
-  });
-  const {
-    data: orgSkillsData,
-    error: orgSkillsError,
-    mutate: mutateOrgSkills,
-    isLoading: isLoadingOrgSkills
-  } = useSWR(
-    client.hasOrgContext ? "agent-sdk-skills-org" : null,
-    () => client.listOrgSkills(),
-    {
-      revalidateOnFocus: false,
-      dedupingInterval: 6e4
-    }
-  );
-  const saveSkill = useCallback(
-    async (skill) => {
-      setIsSaving(true);
-      try {
-        await client.saveSkill(skill);
-        await mutateSkills();
-      } finally {
-        setIsSaving(false);
-      }
-    },
-    [client, mutateSkills]
-  );
-  const deleteSkill = useCallback(
-    async (name) => {
-      await client.deleteSkill(name);
-      await mutateSkills();
-    },
-    [client, mutateSkills]
-  );
-  const refresh = useCallback(async () => {
-    await mutateSkills();
-  }, [mutateSkills]);
-  const saveOrgSkill = useCallback(
-    async (skill) => {
-      setIsSaving(true);
-      try {
-        await client.saveOrgSkill(skill);
-        await mutateOrgSkills();
-      } finally {
-        setIsSaving(false);
-      }
-    },
-    [client, mutateOrgSkills]
-  );
-  const deleteOrgSkill = useCallback(
-    async (name) => {
-      await client.deleteOrgSkill(name);
-      await mutateOrgSkills();
-    },
-    [client, mutateOrgSkills]
-  );
-  const refreshOrg = useCallback(async () => {
-    await mutateOrgSkills();
-  }, [mutateOrgSkills]);
-  return {
-    // Personal skills
-    skills: skillsData?.skills ?? [],
-    isLoading: isLoadingSkills || isSaving,
-    error: skillsError,
-    refresh,
-    saveSkill,
-    deleteSkill,
-    // Org skills
-    orgSkills: orgSkillsData?.skills ?? [],
-    isLoadingOrg: isLoadingOrgSkills,
-    orgError: orgSkillsError,
-    refreshOrg,
-    saveOrgSkill,
-    deleteOrgSkill
-  };
-}
-
-// src/jade/tools/parsers.ts
-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
-  };
-}
-
-// src/jade/tools/registry.ts
-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];
-}
-
-// src/jade/processing/suggestion-parser.ts
-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);
-}
-
-// src/jade/processing/conversation-processor.ts
-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;
-}
-
-// src/jade/processing/media-utils.ts
-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);
-  }
-}
-
-// src/jade/processing/media-extractor.ts
-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/jade/react/use-jade-session.ts
-function useJadeSession(options = {}) {
-  const {
-    skipSkillContext = true,
-    processingOptions,
-    ...agentOptions
-  } = options;
-  const session = useAgentSession(agentOptions);
-  const processedConversation = useMemo(
-    () => processConversation(session.conversation, {
-      skipSkillContext,
-      pairToolResults: true,
-      extractMedia: true,
-      ...processingOptions
-    }),
-    [session.conversation, skipSkillContext, processingOptions]
-  );
-  const media = useMemo(
-    () => extractMedia(session.conversation),
-    [session.conversation]
-  );
-  return {
-    ...session,
-    processedConversation,
-    media
-  };
-}
-function useMedia(conversation) {
-  return useMemo(() => extractMedia(conversation), [conversation]);
-}
-
-// src/jade/react/JadeProvider.tsx
-var JadeProvider = AgentProvider;
-
-export { AgentProvider, JadeProvider, useAgentClient, useAgentSession, useJadeSession, useMedia, useSkills };