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

package/dist/index.d.ts

@@ -1,6 +1,339 @@
-export * from '@gr33n-ai/jade-sdk-client';
-export { ConversationEntry, MediaInfo, ProcessedEntry, ProcessingOptions, SessionMetadata, SkillMetadata, StreamingToolCall } from '@gr33n-ai/jade-sdk-client';
-export { R as AgentClient, R as RNAgentClient, RNAgentProvider, RNAgentProviderProps, STORAGE_KEYS, StorageAdapter, UseJadeSessionOptions, UseJadeSessionReturn, UseRNAgentSessionOptions, UseRNAgentSessionReturn, createAsyncStorageAdapter, createMMKVAdapter, createMemoryStorageAdapter, useAppState, useJadeSession, useRNAgentClient, useRNAgentSession, useStorage } from './react-native/index.js';
-import 'react/jsx-runtime';
-import 'react';
-import 'react-native';
+import { AgentClientConfig, MessagesRequest, AgentEventEmitter, SessionListResponse, SessionConversationResponse, SessionContentResponse, SessionStatusResponse, UpdateSessionRequest, SuccessResponse, CancelResponse, SkillListResponse, SaveSkillRequest, PluginManifestResponse, PluginBundleResponse, ConversationEntry, StreamingToolCall, ProcessingOptions, ProcessedEntry, MediaInfo } from '@gr33n-ai/jade-sdk-client';
+export { AgentClientConfig, AgentEventEmitter, CancelResponse, ConversationEntry, MediaInfo, MessagesRequest, ParsedSuggestion, ParsedToolInput, ParsedToolResult, PluginBundleResponse, PluginManifestResponse, ProcessedEntry, ProcessingOptions, SaveSkillRequest, SessionContentResponse, SessionConversationResponse, SessionListResponse, SessionMetadata, SessionStatusResponse, SkillListResponse, SkillMetadata, StreamingToolCall, SuccessResponse, TOOL_REGISTRY, TextSegment, ToolDefinition, UpdateSessionRequest, extractMedia, getToolDefinition, processConversation } from '@gr33n-ai/jade-sdk-client';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+import { AppStateStatus } from 'react-native';
+
+/**
+ * JadeClient - React Native client for the Jade SDK API.
+ * Uses react-native-sse for streaming instead of @microsoft/fetch-event-source.
+ */
+
+declare class JadeClient {
+    private config;
+    private baseClient;
+    private activeStreams;
+    constructor(config: AgentClientConfig);
+    /** Whether org context is configured (orgId is set) */
+    get hasOrgContext(): boolean;
+    private get baseUrl();
+    private getHeaders;
+    /**
+     * Send a message and stream responses using React Native SSE.
+     * @returns Object with event emitter and abort function
+     */
+    stream(request: MessagesRequest): {
+        emitter: AgentEventEmitter;
+        abort: () => void;
+    };
+    /**
+     * Reconnect to an active streaming session using React Native SSE.
+     * @returns Object with event emitter and abort function
+     */
+    reconnect(sessionId: string, lastEventId?: number): {
+        emitter: AgentEventEmitter;
+        abort: () => void;
+    };
+    /**
+     * List all sessions for the authenticated user.
+     */
+    listSessions(): Promise<SessionListResponse>;
+    /**
+     * Get session content in display format.
+     */
+    getSession(sessionId: string): Promise<SessionConversationResponse>;
+    /**
+     * Get session content as raw JSONL.
+     */
+    getSessionRaw(sessionId: string): Promise<SessionContentResponse>;
+    /**
+     * Check if a session is actively streaming.
+     */
+    getSessionStatus(sessionId: string): Promise<SessionStatusResponse>;
+    /**
+     * Update session metadata (name).
+     */
+    updateSession(sessionId: string, updates: UpdateSessionRequest): Promise<SuccessResponse>;
+    /**
+     * Delete a session.
+     */
+    deleteSession(sessionId: string): Promise<SuccessResponse>;
+    /**
+     * Cancel an active session query.
+     */
+    cancelSession(sessionId: string): Promise<CancelResponse>;
+    /**
+     * List personal skills.
+     */
+    listSkills(): Promise<SkillListResponse>;
+    /**
+     * Get personal skill content.
+     */
+    getSkill(name: string): Promise<Uint8Array>;
+    /**
+     * Create or update a personal skill.
+     */
+    saveSkill(skill: SaveSkillRequest): Promise<SuccessResponse>;
+    /**
+     * Delete a personal skill.
+     */
+    deleteSkill(name: string): Promise<SuccessResponse>;
+    /**
+     * List organization skills.
+     */
+    listOrgSkills(): Promise<SkillListResponse>;
+    /**
+     * Get organization skill content.
+     */
+    getOrgSkill(name: string): Promise<Uint8Array>;
+    /**
+     * Create or update an organization skill.
+     */
+    saveOrgSkill(skill: SaveSkillRequest): Promise<SuccessResponse>;
+    /**
+     * Delete an organization skill.
+     */
+    deleteOrgSkill(name: string): Promise<SuccessResponse>;
+    /**
+     * Get plugin manifest for client sync.
+     */
+    getPluginManifest(): Promise<PluginManifestResponse>;
+    /**
+     * Download plugin bundle.
+     */
+    getPluginBundle(skills?: string[]): Promise<PluginBundleResponse>;
+}
+
+/**
+ * Storage adapter for React Native.
+ * Provides AsyncStorage and MMKV implementations.
+ */
+interface StorageAdapter {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+/**
+ * Create a storage adapter using @react-native-async-storage/async-storage.
+ * AsyncStorage must be passed in to avoid requiring it as a direct dependency.
+ *
+ * @example
+ * ```typescript
+ * import AsyncStorage from '@react-native-async-storage/async-storage';
+ * const storage = createAsyncStorageAdapter(AsyncStorage);
+ * ```
+ */
+declare function createAsyncStorageAdapter(asyncStorage: {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+}): StorageAdapter;
+/**
+ * Create a storage adapter using react-native-mmkv.
+ * MMKV instance must be passed in to avoid requiring it as a direct dependency.
+ *
+ * @example
+ * ```typescript
+ * import { MMKV } from 'react-native-mmkv';
+ * const mmkv = new MMKV();
+ * const storage = createMMKVAdapter(mmkv);
+ * ```
+ */
+declare function createMMKVAdapter(mmkv: {
+    getString: (key: string) => string | undefined;
+    set: (key: string, value: string) => void;
+    delete: (key: string) => void;
+}): StorageAdapter;
+/**
+ * Create an in-memory storage adapter for testing.
+ */
+declare function createMemoryStorageAdapter(): StorageAdapter;
+/**
+ * Standard storage keys used by the Jade SDK.
+ */
+declare const STORAGE_KEYS: {
+    readonly AUTH_TOKEN: "@gr33n-ai/auth-token";
+    readonly ENDPOINT: "@gr33n-ai/endpoint";
+    readonly ORG_ID: "@gr33n-ai/org-id";
+    readonly LAST_SESSION_ID: "@gr33n-ai/last-session-id";
+    readonly USER_PREFERENCES: "@gr33n-ai/user-preferences";
+};
+
+interface JadeProviderProps {
+    children: React.ReactNode;
+    /** Client configuration */
+    config: AgentClientConfig;
+    /** Optional storage adapter for persisting auth tokens, etc. */
+    storage?: StorageAdapter;
+    /** Pause streaming when app goes to background (default: true) */
+    pauseOnBackground?: boolean;
+}
+/**
+ * Provider component for the React Native Jade SDK client.
+ * Wrap your app with this to use the Jade hooks.
+ *
+ * Features:
+ * - AppState-aware (tracks foreground/background)
+ * - Optional storage adapter for persistence
+ *
+ * @example
+ * ```tsx
+ * import AsyncStorage from '@react-native-async-storage/async-storage';
+ * import { createAsyncStorageAdapter } from '@gr33n-ai/jade-sdk-rn-client';
+ *
+ * const storage = createAsyncStorageAdapter(AsyncStorage);
+ *
+ * <JadeProvider
+ *   config={{
+ *     endpoint: 'https://api.example.com',
+ *     getAuthToken: async () => storage.getItem('@gr33n-ai/auth-token'),
+ *   }}
+ *   storage={storage}
+ * >
+ *   <App />
+ * </JadeProvider>
+ * ```
+ */
+declare function JadeProvider({ children, config, storage, pauseOnBackground, }: JadeProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Get the Jade SDK client instance.
+ * Must be used within a JadeProvider.
+ *
+ * @example
+ * ```tsx
+ * const client = useJadeClient();
+ * const sessions = await client.listSessions();
+ * ```
+ */
+declare function useJadeClient(): JadeClient;
+/**
+ * Get the storage adapter instance.
+ * Must be used within a JadeProvider.
+ *
+ * @example
+ * ```tsx
+ * const storage = useStorage();
+ * if (storage) {
+ *   await storage.setItem('@gr33n-ai/last-session', sessionId);
+ * }
+ * ```
+ */
+declare function useStorage(): StorageAdapter | undefined;
+/**
+ * Get the current app state (active, background, inactive).
+ * Useful for pausing/resuming operations based on app visibility.
+ *
+ * @example
+ * ```tsx
+ * const appState = useAppState();
+ * useEffect(() => {
+ *   if (appState === 'active') {
+ *     // Resume operations
+ *   }
+ * }, [appState]);
+ * ```
+ */
+declare function useAppState(): AppStateStatus;
+
+/**
+ * useJadeSessionCore hook for React Native.
+ * Manages Jade sessions with streaming support using the JadeClient.
+ */
+
+interface UseJadeSessionCoreOptions {
+    /** Initial session ID */
+    initialSessionId?: string;
+    /** Initial conversation entries */
+    initialConversation?: ConversationEntry[];
+    /** Callback when media is generated (image/video/audio) */
+    onMediaGenerated?: (urls: string[], type: 'image' | 'video' | 'audio') => void;
+    /** Pause streaming when app goes to background (default: true) */
+    pauseOnBackground?: boolean;
+}
+interface UseJadeSessionCoreReturn {
+    sessionId: string | undefined;
+    conversation: ConversationEntry[];
+    isStreaming: boolean;
+    streamingText: string | undefined;
+    streamingToolCall: StreamingToolCall | undefined;
+    showTinkering: boolean;
+    sendMessage: (prompt: string, skills?: string[]) => Promise<void>;
+    cancel: () => Promise<void>;
+    clear: () => void;
+    reconnect: (sessionId: string, freshConversation?: ConversationEntry[], streamingPrompt?: string) => Promise<void>;
+    setSessionId: (id: string | undefined) => void;
+    setConversation: (entries: ConversationEntry[], sessionId?: string) => void;
+    loadSession: (sessionId: string) => Promise<ConversationEntry[]>;
+}
+/**
+ * Hook for managing Jade sessions with streaming support in React Native.
+ *
+ * Features:
+ * - Streaming with RN-specific SSE implementation
+ * - AppState-aware (can pause on background)
+ * - Same API as useAgentSession from agent-sdk-client
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   conversation,
+ *   isStreaming,
+ *   streamingText,
+ *   sendMessage,
+ *   cancel,
+ * } = useJadeSessionCore();
+ *
+ * await sendMessage('Hello!');
+ * ```
+ */
+declare function useJadeSessionCore(options?: UseJadeSessionCoreOptions): UseJadeSessionCoreReturn;
+
+/**
+ * useJadeSession hook for React Native.
+ * Extends useJadeSessionCore with processed conversation and media extraction.
+ */
+
+interface UseJadeSessionOptions extends UseJadeSessionCoreOptions {
+    /** Skip Skill context injection entries (default: true) */
+    skipSkillContext?: boolean;
+    /** Processing options */
+    processingOptions?: ProcessingOptions;
+}
+interface UseJadeSessionReturn extends UseJadeSessionCoreReturn {
+    /** Processed conversation entries with tool pairing and parsing */
+    processedConversation: ProcessedEntry[];
+    /** All media extracted from conversation (deduplicated, sorted by timestamp) */
+    media: MediaInfo[];
+}
+/**
+ * Hook for managing Jade sessions with enhanced conversation processing.
+ * React Native version using JadeClient for streaming.
+ *
+ * Extends useJadeSessionCore with:
+ * - Processed conversation (tool call/result pairing, parsed inputs/results)
+ * - Media extraction from generated content
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   conversation,
+ *   processedConversation,
+ *   media,
+ *   isStreaming,
+ *   sendMessage,
+ * } = useJadeSession();
+ *
+ * // Render processed entries
+ * {processedConversation.map((entry, i) => (
+ *   <MessageRenderer key={i} entry={entry} />
+ * ))}
+ *
+ * // Show media gallery
+ * {media.map((item) => (
+ *   <MediaThumbnail key={item.url} {...item} />
+ * ))}
+ * ```
+ */
+declare function useJadeSession(options?: UseJadeSessionOptions): UseJadeSessionReturn;
+
+export { JadeClient, JadeProvider, type JadeProviderProps, STORAGE_KEYS, type StorageAdapter, type UseJadeSessionCoreOptions, type UseJadeSessionCoreReturn, type UseJadeSessionOptions, type UseJadeSessionReturn, createAsyncStorageAdapter, createMMKVAdapter, createMemoryStorageAdapter, useAppState, useJadeClient, useJadeSession, useJadeSessionCore, useStorage };

package/dist/index.js

@@ -1,8 +1,8 @@
 'use strict';
 
 var react = require('react');
-var reactNative = require('react-native');
 var jsxRuntime = require('react/jsx-runtime');
+var reactNative = require('react-native');
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -322,8 +322,6 @@ var require_react_native_sse = __commonJS({
     module.exports = EventSource3;
   }
 });
-
-// ../ts-client/dist/index.js
 async function getBytes(stream, onChunk) {
   const reader = stream.getReader();
   let result;
@@ -1573,14 +1571,6 @@ var TOOL_REGISTRY = {
 function getToolDefinition(toolName) {
   return TOOL_REGISTRY[toolName];
 }
-function getToolIconName(toolName, toolInput) {
-  const def = getToolDefinition(toolName);
-  if (!def) return "Wrench";
-  if (def.iconVariant && toolInput) {
-    return def.iconVariant(toolInput);
-  }
-  return def.iconName;
-}
 var SUGGESTION_REGEX = /<gr3\.suggestion>([\s\S]*?)<\/gr3\.suggestion>/g;
 function parseSuggestions(text) {
   const suggestions = [];
@@ -1980,6 +1970,7 @@ function extractMedia(conversation) {
   mediaArray.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
   return mediaArray;
 }
+react.createContext(null);
 
 // src/react-native/sse-adapter.ts
 var import_react_native_sse = __toESM(require_react_native_sse());
@@ -2047,7 +2038,7 @@ async function createRNSSEStream(options) {
       ];
       for (const eventType of eventTypes) {
         es.addEventListener(eventType, (event) => {
-          console.log(`[RN-SSE] Received ${eventType} event:`, event.data?.substring?.(0, 100) || event.data);
+          console.log(`[Jade-SSE] Received ${eventType} event:`, event.data?.substring?.(0, 100) || event.data);
           const eventData = {
             data: event.data,
             lastEventId: event.lastEventId ?? void 0
@@ -2056,7 +2047,7 @@ async function createRNSSEStream(options) {
         });
       }
       es.addEventListener("message", (event) => {
-        console.log("[RN-SSE] Received message event:", event.data?.substring?.(0, 100) || event.data);
+        console.log("[Jade-SSE] Received message event:", event.data?.substring?.(0, 100) || event.data);
         const eventData = {
           data: event.data,
           lastEventId: event.lastEventId ?? void 0
@@ -2064,7 +2055,7 @@ async function createRNSSEStream(options) {
         handleSSEEvent("message", eventData, emitter, processedIds);
       });
       es.addEventListener("error", (event) => {
-        console.log("[RN-SSE] Error event:", JSON.stringify(event));
+        console.log("[Jade-SSE] Error event:", JSON.stringify(event));
         if (signal?.aborted || isClosed) {
           cleanup();
           return;
@@ -2073,7 +2064,7 @@ async function createRNSSEStream(options) {
         const status = event.xhrStatus;
         if (status === 401 || status === 403 || errorMessage.includes("401") || errorMessage.includes("403") || errorMessage.includes("Authentication")) {
           const authError = `Authentication failed (${status || "unknown"}): ${errorMessage}`;
-          console.log("[RN-SSE] Auth error detected:", authError);
+          console.log("[Jade-SSE] Auth error detected:", authError);
           emitter.emit("error", { error: authError });
           cleanup();
           reject(new Error(authError));
@@ -2103,7 +2094,7 @@ async function createRNSSEStream(options) {
           INITIAL_RETRY_DELAY2 * Math.pow(2, retryCount - 1),
           MAX_RETRY_DELAY2
         );
-        console.log(`[RN-SSE] Retry ${retryCount}/${MAX_RETRIES2} in ${delay}ms`);
+        console.log(`[Jade-SSE] Retry ${retryCount}/${MAX_RETRIES2} in ${delay}ms`);
         es?.close();
         setTimeout(connect, delay);
       });
@@ -2164,7 +2155,7 @@ function handleSSEEvent(eventType, event, emitter, processedIds) {
         break;
     }
   } catch (e) {
-    console.error("[RN-SSE] Failed to parse event:", event.data, e);
+    console.error("[Jade-SSE] Failed to parse event:", event.data, e);
   }
 }
 function handleStreamEvent2(data, emitter) {
@@ -2184,7 +2175,7 @@ function handleStreamEvent2(data, emitter) {
 }
 
 // src/react-native/client.ts
-var RNAgentClient = class {
+var JadeClient = class {
   config;
   baseClient;
   activeStreams = /* @__PURE__ */ new Map();
@@ -2399,8 +2390,8 @@ var RNAgentClient = class {
     return this.baseClient.getPluginBundle(skills);
   }
 };
-var RNAgentContext = react.createContext(null);
-function RNAgentProvider({
+var JadeContext = react.createContext(null);
+function JadeProvider({
   children,
   config,
   storage,
@@ -2415,7 +2406,7 @@ function RNAgentProvider({
     return () => subscription.remove();
   }, [pauseOnBackground]);
   const client = react.useMemo(
-    () => new RNAgentClient(config),
+    () => new JadeClient(config),
     // Only recreate client if endpoint changes
     [config.endpoint, config.apiVersion, config.timeout]
   );
@@ -2423,31 +2414,31 @@ function RNAgentProvider({
     () => ({ client, storage, appState }),
     [client, storage, appState]
   );
-  return /* @__PURE__ */ jsxRuntime.jsx(RNAgentContext.Provider, { value, children });
+  return /* @__PURE__ */ jsxRuntime.jsx(JadeContext.Provider, { value, children });
 }
-function useRNAgentClient() {
-  const context = react.useContext(RNAgentContext);
+function useJadeClient() {
+  const context = react.useContext(JadeContext);
   if (!context) {
-    throw new Error("useRNAgentClient must be used within an RNAgentProvider");
+    throw new Error("useJadeClient must be used within a JadeProvider");
   }
   return context.client;
 }
 function useStorage() {
-  const context = react.useContext(RNAgentContext);
+  const context = react.useContext(JadeContext);
   if (!context) {
-    throw new Error("useStorage must be used within an RNAgentProvider");
+    throw new Error("useStorage must be used within a JadeProvider");
   }
   return context.storage;
 }
 function useAppState() {
-  const context = react.useContext(RNAgentContext);
+  const context = react.useContext(JadeContext);
   if (!context) {
-    throw new Error("useAppState must be used within an RNAgentProvider");
+    throw new Error("useAppState must be used within a JadeProvider");
   }
   return context.appState;
 }
-function useRNAgentSession(options = {}) {
-  const client = useRNAgentClient();
+function useJadeSessionCore(options = {}) {
+  const client = useJadeClient();
   const appState = useAppState();
   const {
     initialSessionId,
@@ -2465,7 +2456,7 @@ function useRNAgentSession(options = {}) {
   const accumulatedTextRef = react.useRef({});
   react.useEffect(() => {
     if (pauseOnBackground && appState !== "active" && session.isStreaming) {
-      console.log("[RNAgentSession] App went to background while streaming");
+      console.log("[JadeSession] App went to background while streaming");
     }
   }, [appState, pauseOnBackground, session.isStreaming]);
   const setupEventHandlers = react.useCallback(
@@ -2610,10 +2601,10 @@ function useRNAgentSession(options = {}) {
         try {
           await client.cancelSession(session.sessionId);
         } catch (error) {
-          console.error("[RNAgentSession] Server-side cancel failed:", error);
+          console.error("[JadeSession] Server-side cancel failed:", error);
         }
       } else {
-        console.warn("[RNAgentSession] No sessionId available for server-side cancel");
+        console.warn("[JadeSession] No sessionId available for server-side cancel");
       }
       if (abortRef.current) {
         abortRef.current();
@@ -2737,7 +2728,7 @@ function useJadeSession(options = {}) {
     processingOptions,
     ...agentOptions
   } = options;
-  const session = useRNAgentSession(agentOptions);
+  const session = useJadeSessionCore(agentOptions);
   const processedConversation = react.useMemo(() => {
     return processConversation(session.conversation, {
       skipSkillContext,
@@ -2791,34 +2782,18 @@ var STORAGE_KEYS = {
   USER_PREFERENCES: "@gr33n-ai/user-preferences"
 };
 
-exports.AgentClient = RNAgentClient;
-exports.AgentClientError = AgentClientError;
-exports.AgentEventEmitter = AgentEventEmitter;
-exports.AuthenticationError = AuthenticationError;
-exports.RNAgentClient = RNAgentClient;
-exports.RNAgentProvider = RNAgentProvider;
-exports.RequestError = RequestError;
+exports.JadeClient = JadeClient;
+exports.JadeProvider = JadeProvider;
 exports.STORAGE_KEYS = STORAGE_KEYS;
-exports.SessionNotFoundError = SessionNotFoundError;
-exports.SkillNotFoundError = SkillNotFoundError;
 exports.TOOL_REGISTRY = TOOL_REGISTRY;
 exports.createAsyncStorageAdapter = createAsyncStorageAdapter;
 exports.createMMKVAdapter = createMMKVAdapter;
-exports.createMediaParseResult = createMediaParseResult;
 exports.createMemoryStorageAdapter = createMemoryStorageAdapter;
 exports.extractMedia = extractMedia;
-exports.extractMediaInfo = extractMediaInfo;
-exports.extractMediaInfoFromToolResult = extractMediaInfoFromToolResult;
-exports.getMediaTypeFromExtension = getMediaTypeFromExtension;
-exports.getMediaTypeFromUrl = getMediaTypeFromUrl;
 exports.getToolDefinition = getToolDefinition;
-exports.getToolIconName = getToolIconName;
-exports.hasSuggestions = hasSuggestions;
-exports.parseSuggestions = parseSuggestions;
-exports.parseToolResultContent = parseToolResultContent;
 exports.processConversation = processConversation;
 exports.useAppState = useAppState;
+exports.useJadeClient = useJadeClient;
 exports.useJadeSession = useJadeSession;
-exports.useRNAgentClient = useRNAgentClient;
-exports.useRNAgentSession = useRNAgentSession;
+exports.useJadeSessionCore = useJadeSessionCore;
 exports.useStorage = useStorage;