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

package/dist/index.cjs

@@ -1,5 +1,13 @@
 'use strict';
 
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var useSWR = require('swr');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var useSWR__default = /*#__PURE__*/_interopDefault(useSWR);
+
 // ../../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();
@@ -1673,11 +1681,925 @@ function extractMedia(conversation) {
   mediaArray.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
   return mediaArray;
 }
+var AgentEventEmitter2 = 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 AgentClientError2 = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "AgentClientError";
+  }
+};
+var AuthenticationError2 = class extends AgentClientError2 {
+  constructor(message = "Authentication failed") {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var SessionNotFoundError2 = class extends AgentClientError2 {
+  constructor(sessionId) {
+    super(`Session not found: ${sessionId}`);
+    this.sessionId = sessionId;
+    this.name = "SessionNotFoundError";
+  }
+};
+var SkillNotFoundError2 = class extends AgentClientError2 {
+  constructor(skillName) {
+    super(`Skill not found: ${skillName}`);
+    this.skillName = skillName;
+    this.name = "SkillNotFoundError";
+  }
+};
+var RequestError2 = class extends AgentClientError2 {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "RequestError";
+  }
+};
+var FatalSSEError2 = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FatalSSEError";
+  }
+};
+var MAX_RETRIES2 = 5;
+var INITIAL_RETRY_DELAY2 = 1e3;
+var MAX_RETRY_DELAY2 = 1e4;
+async function createSSEStream2(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 FatalSSEError2(`Authentication failed: ${response.status}`);
+        }
+        if (response.status === 404) {
+          throw new FatalSSEError2("Session not found or not active");
+        }
+        if (response.status === 503) {
+          const text = await response.text().catch(() => "Service unavailable");
+          throw new FatalSSEError2(`Server unavailable: ${text}`);
+        }
+        if (response.status >= 400 && response.status < 500) {
+          const text = await response.text().catch(() => `Error ${response.status}`);
+          throw new FatalSSEError2(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":
+              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;
+            default:
+              break;
+          }
+        } catch (e) {
+          console.error("[SSE] Failed to parse event:", event.data, e);
+        }
+      },
+      onerror(err) {
+        if (signal?.aborted) {
+          throw err;
+        }
+        if (err instanceof FatalSSEError2) {
+          emitter.emit("error", { error: err.message });
+          throw err;
+        }
+        retryCount++;
+        if (retryCount > MAX_RETRIES2) {
+          const error = `Connection failed after ${MAX_RETRIES2} retries`;
+          emitter.emit("error", { error });
+          throw new FatalSSEError2(error);
+        }
+        const delay = Math.min(INITIAL_RETRY_DELAY2 * Math.pow(2, retryCount - 1), MAX_RETRY_DELAY2);
+        console.log(`[SSE] Retry ${retryCount}/${MAX_RETRIES2} 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 FatalSSEError2) {
+      if (error.message.includes("Authentication")) {
+        throw new AuthenticationError2(error.message);
+      }
+      throw new RequestError2(error.message, 500);
+    }
+    if (error instanceof Error) {
+      emitter.emit("error", { error: error.message });
+    }
+    throw error;
+  }
+}
+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;
+  }
+}
+var AgentClient2 = 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 AuthenticationError2();
+    }
+    if (response.status === 404) {
+      const text = await response.text();
+      if (text.toLowerCase().includes("session")) {
+        const sessionId = path.split("/").pop() || "";
+        throw new SessionNotFoundError2(sessionId);
+      }
+      if (text.toLowerCase().includes("skill")) {
+        const skillName = path.split("/").pop() || "";
+        throw new SkillNotFoundError2(skillName);
+      }
+    }
+    throw new RequestError2(`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 AgentEventEmitter2();
+    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 createSSEStream2({
+          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 AgentEventEmitter2();
+    const controller = new AbortController();
+    (async () => {
+      try {
+        const headers = await this.getHeaders();
+        await createSSEStream2({
+          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 = react.createContext(null);
+function AgentProvider({ children, config }) {
+  const client = react.useMemo(
+    () => new AgentClient2(config),
+    // Only recreate client if endpoint changes
+    // getAuthToken is a function and should not trigger recreation
+    [config.endpoint, config.apiVersion, config.timeout]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(AgentContext.Provider, { value: { client }, children });
+}
+function useAgentClient() {
+  const context = react.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] = react.useState({
+    sessionId: initialSessionId,
+    conversation: initialConversation ?? [],
+    isStreaming: false
+  });
+  const abortRef = react.useRef(null);
+  const accumulatedTextRef = react.useRef({});
+  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: "assistant_text",
+              text: `Error: ${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 () => {
+    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 = 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 useSkills() {
+  const client = useAgentClient();
+  const [isSaving, setIsSaving] = react.useState(false);
+  const {
+    data: skillsData,
+    error: skillsError,
+    mutate: mutateSkills,
+    isLoading: isLoadingSkills
+  } = useSWR__default.default("agent-sdk-skills", () => client.listSkills(), {
+    revalidateOnFocus: false,
+    dedupingInterval: 6e4
+    // 1 minute
+  });
+  const {
+    data: orgSkillsData,
+    error: orgSkillsError,
+    mutate: mutateOrgSkills,
+    isLoading: isLoadingOrgSkills
+  } = useSWR__default.default(
+    client.hasOrgContext ? "agent-sdk-skills-org" : null,
+    () => client.listOrgSkills(),
+    {
+      revalidateOnFocus: false,
+      dedupingInterval: 6e4
+    }
+  );
+  const saveSkill = react.useCallback(
+    async (skill) => {
+      setIsSaving(true);
+      try {
+        await client.saveSkill(skill);
+        await mutateSkills();
+      } finally {
+        setIsSaving(false);
+      }
+    },
+    [client, mutateSkills]
+  );
+  const deleteSkill = react.useCallback(
+    async (name) => {
+      await client.deleteSkill(name);
+      await mutateSkills();
+    },
+    [client, mutateSkills]
+  );
+  const refresh = react.useCallback(async () => {
+    await mutateSkills();
+  }, [mutateSkills]);
+  const saveOrgSkill = react.useCallback(
+    async (skill) => {
+      setIsSaving(true);
+      try {
+        await client.saveOrgSkill(skill);
+        await mutateOrgSkills();
+      } finally {
+        setIsSaving(false);
+      }
+    },
+    [client, mutateOrgSkills]
+  );
+  const deleteOrgSkill = react.useCallback(
+    async (name) => {
+      await client.deleteOrgSkill(name);
+      await mutateOrgSkills();
+    },
+    [client, mutateOrgSkills]
+  );
+  const refreshOrg = react.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
+  };
+}
+function useJadeSession(options = {}) {
+  const {
+    skipSkillContext = true,
+    processingOptions,
+    ...agentOptions
+  } = options;
+  const session = useAgentSession(agentOptions);
+  const processedConversation = react.useMemo(
+    () => processConversation(session.conversation, {
+      skipSkillContext,
+      pairToolResults: true,
+      extractMedia: true,
+      ...processingOptions
+    }),
+    [session.conversation, skipSkillContext, processingOptions]
+  );
+  const media = react.useMemo(
+    () => extractMedia(session.conversation),
+    [session.conversation]
+  );
+  return {
+    ...session,
+    processedConversation,
+    media
+  };
+}
+function useMedia(conversation) {
+  return react.useMemo(() => extractMedia(conversation), [conversation]);
+}
+
+// src/jade/react/JadeProvider.tsx
+var JadeProvider = AgentProvider;
 
 exports.AgentClient = AgentClient;
 exports.AgentClientError = AgentClientError;
 exports.AgentEventEmitter = AgentEventEmitter;
+exports.AgentProvider = AgentProvider;
 exports.AuthenticationError = AuthenticationError;
+exports.JadeClient = AgentClient;
+exports.JadeProvider = JadeProvider;
 exports.RequestError = RequestError;
 exports.SessionNotFoundError = SessionNotFoundError;
 exports.SkillNotFoundError = SkillNotFoundError;
@@ -1694,3 +2616,8 @@ exports.hasSuggestions = hasSuggestions;
 exports.parseSuggestions = parseSuggestions;
 exports.parseToolResultContent = parseToolResultContent;
 exports.processConversation = processConversation;
+exports.useAgentClient = useAgentClient;
+exports.useAgentSession = useAgentSession;
+exports.useJadeSession = useJadeSession;
+exports.useMedia = useMedia;
+exports.useSkills = useSkills;