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

package/README.md

@@ -20,17 +20,17 @@ cd ios && pod install
 
 ```tsx
 import {
-  RNAgentProvider,
+  JadeProvider,
   useJadeSession,
   createAsyncStorageAdapter,
-} from '@gr33n-ai/jade-sdk-rn-client/react-native';
+} from '@gr33n-ai/jade-sdk-rn-client';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 
 const storage = createAsyncStorageAdapter(AsyncStorage);
 
 function App() {
   return (
-    <RNAgentProvider
+    <JadeProvider
       config={{
         endpoint: 'https://api.jade.gr33n.ai',
         getAuthToken: async () => await AsyncStorage.getItem('@gr33n-ai/api-key'),
@@ -38,7 +38,7 @@ function App() {
       storage={storage}
     >
       <Chat />
-    </RNAgentProvider>
+    </JadeProvider>
   );
 }
 
@@ -85,12 +85,12 @@ Full documentation available at [docs.gr33n.ai](https://docs.gr33n.ai)
 
 ## API
 
-### RNAgentProvider
+### JadeProvider
 
-Wrap your app with `RNAgentProvider`:
+Wrap your app with `JadeProvider`:
 
 ```tsx
-<RNAgentProvider
+<JadeProvider
   config={{
     endpoint: 'https://api.jade.gr33n.ai',
     getAuthToken: async () => await getApiKey(),
@@ -99,7 +99,7 @@ Wrap your app with `RNAgentProvider`:
   pauseOnBackground={true}
 >
   <App />
-</RNAgentProvider>
+</JadeProvider>
 ```
 
 ### useJadeSession
@@ -127,7 +127,7 @@ import {
   createAsyncStorageAdapter,
   createMMKVAdapter,
   createMemoryStorageAdapter,
-} from '@gr33n-ai/jade-sdk-rn-client/react-native';
+} from '@gr33n-ai/jade-sdk-rn-client';
 
 // AsyncStorage (recommended)
 const storage = createAsyncStorageAdapter(AsyncStorage);
@@ -143,10 +143,10 @@ const storage = createMemoryStorageAdapter();
 
 ```tsx
 import {
-  useRNAgentClient,  // Access the client
-  useStorage,         // Access storage adapter
-  useAppState,        // Monitor app state
-} from '@gr33n-ai/jade-sdk-rn-client/react-native';
+  useJadeClient,  // Access the client
+  useStorage,     // Access storage adapter
+  useAppState,    // Monitor app state
+} from '@gr33n-ai/jade-sdk-rn-client';
 ```
 
 ## Requirements

package/dist/index.d.mts

@@ -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.mjs';
-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 };