Types & Events

interface ConversationEntry {
  role: 'user' | 'assistant';
  text?: string;
  tool_use_id?: string;
  tool_name?: string;
  tool_input?: unknown;
  tool_result?: string;
  timestamp?: string;
}

interface ProcessedEntry {
  entry: ConversationEntry;
  originalType: 'tool_call' | 'tool_result' | 'assistant_text' | 'user_text' | 'compact' | 'error';
  displayType: string;
  iconName: string;
  iconData?: unknown;
  title?: string;
  timestamp: string;
  data: Record<string, unknown>;

  // Tool-specific
  toolDefinition?: ToolDefinition;
  parsedInput?: ParsedToolInput;
  parsedResult?: ParsedToolResult;
  consumedResult?: ConversationEntry;

  // Media
  mediaUrls?: string[];

  // Suggestions
  suggestions?: ParsedSuggestion[];
  textSegments?: TextSegment[];
}

interface MediaInfo {
  url: string;
  type: 'image' | 'video' | 'audio';
  timestamp: string;
  toolName?: string;
  toolUseId?: string;
  prompt?: string;
  model?: string;
  aspectRatio?: string;
  inputMediaUrls?: string[];
}

interface AgentClientConfig {
  endpoint: string;
  getAuthToken: () => string | null | Promise<string | null>;
  organizationId?: string;
  fetchOptions?: RequestInit;
}

type JadeClientConfig = AgentClientConfig;

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

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

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

interface MessagesRequest {
  prompt: string;
  session_id?: string;
  skills?: string[];
}

interface SessionListResponse {
  sessions: SessionSummary[];
}

interface SessionConversationResponse {
  conversation: ConversationEntry[];
}

interface SuccessResponse {
  success: boolean;
}

interface ToolDefinition {
  name: string;
  displayName: string;
  iconName: string;
  iconVariant?: (input: unknown) => string;
  category: 'generation' | 'processing' | 'utility' | 'system';
  consumesResult: boolean;
  consumeExtra?: number;
  parseInput: (toolInput: unknown) => ParsedToolInput | null;
  parseResult?: (content: string) => ParsedToolResult | null;
}

interface ParsedToolInput {
  type: string;
  data: Record<string, unknown>;
}

interface ParsedToolResult {
  type: string;
  data: Record<string, unknown>;
}

interface StreamingToolCall {
  tool_name: string;
  tool_use_id: string;
  block_index: number;
  accumulated_input: string;
}

interface ToolResult {
  tool_use_id: string;
  content: string;
}

interface ProcessingOptions {
  skipSkillContext?: boolean;  // Default: true
  pairToolResults?: boolean;   // Default: true
  extractMedia?: boolean;      // Default: true
}

type TextSegment =
  | { type: 'text'; content: string }
  | { type: 'suggestion'; content: string };

interface ParsedSuggestion {
  text: string;
  startIndex: number;
  endIndex: number;
}

interface SuggestionParseResult {
  cleanText: string;
  suggestions: ParsedSuggestion[];
  segments: TextSegment[];
}

interface UseJadeSessionOptions {
  initialSessionId?: string;
  initialConversation?: ConversationEntry[];
  onMediaGenerated?: (urls: string[], type: 'image' | 'video' | 'audio') => void;
  skipSkillContext?: boolean;
  processingOptions?: ProcessingOptions;
}

interface UseJadeSessionReturn {
  // Session
  sessionId: string | undefined;
  conversation: ConversationEntry[];
  processedConversation: ProcessedEntry[];
  media: MediaInfo[];

  // Streaming state
  isStreaming: boolean;
  streamingText?: string;
  streamingToolCall?: StreamingToolCall;
  showTinkering: boolean;
  isExecutingTool: boolean;      // React Native only
  executingToolName?: string;    // React Native only

  // Actions
  sendMessage: (prompt: string, skills?: string[]) => Promise<void>;
  cancel: () => Promise<void>;
  clear: () => void;
  reconnect: (sessionId: string, conversation?: ConversationEntry[], streamingPrompt?: string) => Promise<void>;
  loadSession: (sessionId: string) => Promise<ConversationEntry[]>;

  // State setters
  setSessionId: (id: string | undefined) => void;
  setConversation: (entries: ConversationEntry[], sessionId?: string) => void;
}

interface StorageAdapter {
  getItem(key: string): Promise<string | null>;
  setItem(key: string, value: string): Promise<void>;
  removeItem(key: string): Promise<void>;
}

const STORAGE_KEYS = {
  AUTH_TOKEN: '@gr33n-ai/auth-token',
  ENDPOINT: '@gr33n-ai/endpoint',
  ORG_ID: '@gr33n-ai/org-id',
  LAST_SESSION_ID: '@gr33n-ai/last-session-id',
  USER_PREFERENCES: '@gr33n-ai/user-preferences',
} as const;

┌─────────────────┐
│  session_id     │  Session assigned
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  message_start  │  AI response begins
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  text_delta     │  Text streaming (multiple)
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  tool_use_start │  Tool invocation
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ tool_input_delta│  Tool input (multiple)
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│   tool_result   │  Tool completed
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│message_complete │  Response complete
└─────────────────┘

emitter.on('session_id', (sessionId: string) => {
  console.log('Session:', sessionId);
  localStorage.setItem('session-id', sessionId);
});

emitter.on('text_delta', (text: string) => {
  setStreamingText(prev => (prev || '') + text);
});

emitter.on('tool_call', (toolCall: StreamingToolCall) => {
  console.log('Running:', toolCall.name);
  setCurrentTool(toolCall);
});

emitter.on('tool_input_delta', (delta: string) => {
  // Useful for showing "thinking" state
});

emitter.on('tool_result', (result: ToolResult) => {
  console.log('Result:', result);
  setCurrentTool(null);
});

{
  "url": "https://cdn.jade.gr33n.ai/...",
  "model": "flux-1.1-pro",
  "prompt": "A sunset over mountains"
}

emitter.on('complete', (conversation: ConversationEntry[]) => {
  setConversation(conversation);
  setIsStreaming(false);
});

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

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;
}

// Web
import type {
  ConversationEntry,
  ProcessedEntry,
  MediaInfo,
  JadeClientConfig,
} from '@gr33n-ai/jade-sdk-client';

// React Native
import type {
  ConversationEntry,
  ProcessedEntry,
  MediaInfo,
  StorageAdapter,
} from '@gr33n-ai/jade-sdk-rn-client';