Client

import { AgentClient } from '@gr33n-ai/jade-sdk-client';

const client = new AgentClient({
  endpoint: 'https://api.gr33n.ai',
  getAuthToken: () => 'your-api-key',
  organizationId: 'org_123', // Optional
});

stream(request: MessagesRequest): {
  emitter: AgentEventEmitter;
  abort: () => void;
}

const { emitter, abort } = client.stream({
  prompt: 'Generate an image of a sunset',
});

emitter.on('text_delta', (text) => {
  console.log('Text:', text);
});

emitter.on('tool_call', (toolCall) => {
  console.log('Tool:', toolCall.tool_name);
});

emitter.on('complete', (conversation) => {
  console.log('Done:', conversation);
});

emitter.on('error', (error) => {
  console.error('Error:', error);
});

reconnect(
  sessionId: string,
  lastEventId?: number
): {
  emitter: AgentEventEmitter;
  abort: () => void;
}

listSessions(): Promise<SessionListResponse>

interface SessionListResponse {
  sessions: SessionSummary[];
}

interface SessionSummary {
  id: string;
  title?: string;
  created_at: string;
  updated_at: string;
  pinned: boolean;
}

getSession(sessionId: string): Promise<SessionConversationResponse>

interface SessionConversationResponse {
  conversation: ConversationEntry[];
}

getSessionRaw(sessionId: string): Promise<SessionContentResponse>

getSessionStatus(sessionId: string): Promise<SessionStatusResponse>

interface SessionStatusResponse {
  status: 'idle' | 'streaming';
  streaming: boolean;
}

updateSession(
  sessionId: string,
  updates: UpdateSessionRequest
): Promise<SuccessResponse>

interface UpdateSessionRequest {
  title?: string;
  pinned?: boolean;
}

deleteSession(sessionId: string): Promise<SuccessResponse>

cancelSession(sessionId: string): Promise<CancelResponse>

import { JadeClient } from '@gr33n-ai/jade-sdk-rn-client';

const client = new JadeClient({
  endpoint: 'https://api.gr33n.ai',
  getAuthToken: async () => await AsyncStorage.getItem('@gr33n-ai/api-key'),
});

// Personal skills
listSkills(): Promise<SkillListResponse>
getSkill(name: string): Promise<Uint8Array>
saveSkill(skill: SaveSkillRequest): Promise<SuccessResponse>
deleteSkill(name: string): Promise<SuccessResponse>

// Organization skills
listOrgSkills(): Promise<SkillListResponse>
getOrgSkill(name: string): Promise<Uint8Array>
saveOrgSkill(skill: SaveSkillRequest): Promise<SuccessResponse>
deleteOrgSkill(name: string): Promise<SuccessResponse>

getPluginManifest(): Promise<PluginManifestResponse>
getPluginBundle(skills?: string[]): Promise<PluginBundleResponse>

get hasOrgContext(): boolean  // Whether organization ID is set

interface AgentEventEmitter {
  on(event: 'text_delta', handler: (text: string) => void): void;
  on(event: 'tool_call', handler: (toolCall: StreamingToolCall) => void): void;
  on(event: 'tool_input_delta', handler: (delta: string) => void): void;
  on(event: 'tool_result', handler: (result: ToolResult) => void): void;
  on(event: 'complete', handler: (conversation: ConversationEntry[]) => void): void;
  on(event: 'error', handler: (error: Error) => void): void;
  on(event: 'session_id', handler: (sessionId: string) => void): void;
}

try {
  await client.getSession('invalid-id');
} catch (error) {
  if (error.status === 404) {
    console.log('Session not found');
  } else if (error.status === 401) {
    console.log('Authentication failed');
  }
}

// Recommended
const { sendMessage, conversation } = useJadeSession();

// Direct client access when needed
const client = useAgentClient(); // Web
const client = useJadeClient(); // React Native