solver-sdk 7.1.3 → 7.3.0

package/README.md

@@ -1,535 +1,383 @@
-# Code Solver SDK v7.1.1
+# Code Solver SDK v7.3.0
 
-Backend SDK для интеграции с Code Solver API (Pure Cloud-First)
+AI-powered code analysis SDK. 100% typed, production ready.
 
-## 📑 Навигация
+## Install
 
-**Быстрый старт:**
-- [Установка](#-установка-github-packages---private) • [Быстрый старт](#-быстрый-старт) • [Быстрая справка](#-быстрая-справка)
-
-**Работа с проектами:**
-- [Индексация](#индексация-проекта) • [Real-time прогресс](#websocket-api-sdkprojectsync) • [Recovery](#session-recovery)
+```bash
+npm install solver-sdk@7.3.0
+```
 
-**Типы и решение проблем:**
-- [Ключевые типы](#-ключевые-типы-данных) • [Решение проблем](#-быстрое-решение-проблем) • [API Reference](#-api-reference-подробно)
+## Quick Start
 
----
+```typescript
+import { CodeSolverSDK } from 'solver-sdk';
 
-## 🔒 Установка (GitHub Packages - Private)
+const sdk = await CodeSolverSDK.create({
+  baseURL: 'https://api.example.com',
+  getAuthToken: async () => getToken()
+});
 
-SDK теперь приватный и публикуется в GitHub Packages.
+// Projects
+const projects = await sdk.projects.getAllProjects();
+await sdk.projects.createProject('MyProject');
 
-### Требования:
-- GitHub Personal Access Token с правами `read:packages`
-- Доступ к организации `AndroidSprintTeam`
+// Chat with Thinking
+const response = await sdk.chat.chat([
+  { role: 'user', content: 'explain this code' }
+], { thinking: { type: 'enabled', budget_tokens: 10000 } });
 
-### Установка:
+// Search
+const results = await sdk.search.searchCode({
+  projectId,
+  query: 'authentication function'
+});
 
-```bash
-# 1. Создай .npmrc в корне проекта
-cat > .npmrc << 'EOF'
-//npm.pkg.github.com/:_authToken=YOUR_GITHUB_TOKEN
-@androidsprintteam:registry=https://npm.pkg.github.com
-always-auth=true
-EOF
-
-# 2. Установи SDK
-npm install @androidsprintteam/solver-sdk
+// User & Updates
+const profile = await sdk.user.getProfile();
+const update = await sdk.updates.checkForUpdates({...});
 ```
 
-**Создание токена:** https://github.com/settings/tokens/new (scopes: `read:packages`, `repo`)
+## API Overview
 
-**Полная документация:** см. `GITHUB_PACKAGES_SETUP.md`
+| Feature | Methods | Status |
+|---------|---------|--------|
+| **Projects** | 19 | ✅ Full CRUD + state |
+| **Delta Chunking** | 7 | ✅ Encrypted sync |
+| **Chat** | 12 | ✅ Streaming + Extended Thinking |
+| **Search** | 4 | ✅ Vector-based |
+| **Tools** | 5 | ✅ AI tool schemas |
+| **Models** | 5 | ✅ Provider info |
+| **Updates** | 5 | ✅ Auto-check + changelog |
+| **User** | 1 | ✅ Profile |
+| **Auth** | 2 | ✅ Token revocation + logout |
 
-## 🚀 Быстрый старт
+## Auth
 
-### Локальная разработка
 ```typescript
-import { CodeSolverSDK } from '@androidsprintteam/solver-sdk';
-
+// Local dev
 const sdk = await CodeSolverSDK.create({
   baseURL: 'http://localhost:3000',
-  apiKey: 'your-api-key'
+  getAuthToken: async () => 'your-token'
 });
-```
 
-### Production с OAuth
-```typescript
-const sdk = await CodeSolverSDK.create({
-  baseURL: 'https://workai.su/api/v1',
-  headers: { Authorization: `Bearer ${oauth_token}` },
-  webSocket: { enabled: true }
-});
-```
-
-### 🔑 Динамическое обновление токена (v6.1.4+)
-```typescript
+// Production with token refresh
 const sdk = await CodeSolverSDK.create({
-  baseURL: 'https://workai.su/api/v1',
+  baseURL: 'https://api.example.com',
   getAuthToken: async () => {
-    if (authManager.isTokenExpired()) {
-      await authManager.refreshAccessToken();
+    if (isTokenExpired()) {
+      await refreshToken();
     }
-    return authManager.getAccessToken();
+    return getToken();
   }
 });
 ```
 
-## 📖 Быстрая справка
-
-| Задача | Метод | Назначение |
-|--------|-------|------------|
-| **Индексация** |
-| Синхронизировать проект | `sdk.deltaManager.syncEncryptedChunks(projectId, chunks, rootHash)` | Единственный способ индексации |
-| Проверить статус | `sdk.projects.getProjectState(projectId, clientRootHash?)` | Получить состояние + totalFiles |
-| Проверить recovery | `sdk.projects.getRecoveryStatus(projectId)` | Нужно ли возобновить прерванную синхронизацию |
-| Возобновить синхронизацию | `sdk.projects.resumeSync(projectId)` | Продолжить прерванную индексацию |
-| **Real-time прогресс** |
-| Подключить WebSocket | `await sdk.connectWebSocket()` | Для live обновлений |
-| Подписаться на проект | `sdk.projectSync.subscribeToProject(projectId)` | Получать события по проекту |
-| Прогресс индексации | `sdk.projectSync.on('sync-progress', callback)` | `data.processedFiles / data.totalFiles` |
-| Завершение индексации | `sdk.projectSync.on('sync-completed', callback)` | `data.statistics.totalFiles` |
-| **Проекты** |
-| Получить все проекты | `sdk.projects.getAllProjects()` | Список всех проектов |
-| Найти или создать | `sdk.projects.findOrCreateProject(name)` | Idempotent создание |
-| Получить проект | `sdk.projects.getProject(projectId)` | Детали проекта |
-| **Поиск** |
-| Поиск по коду | `sdk.search.searchCode(projectId, query)` | Semantic search с reranker |
-| Поиск функций | `sdk.search.searchFunctions(projectId, query)` | Только функции/методы |
-| **Чат** |
-| Streaming чат | `sdk.chat.streamChat(messages, options)` | AsyncGenerator chunks |
-| Обычный чат | `sdk.chat.chat(messages, options)` | Promise response |
-
-## 📖 API Reference (подробно)
-
-<details>
-<summary><b>Projects API</b> (<code>sdk.projects</code>) - управление проектами</summary>
+## WebSocket (Real-time)
 
 ```typescript
-// Основные методы
-getAllProjects(): Promise<Project[]>
-getProject(projectId: string): Promise<Project>
-findOrCreateProject(projectName: string): Promise<Project>
-
-// Индексация
-getProjectState(projectId: string, clientRootHash?: string): Promise<ProjectState>
-getIndexingStatus(projectId: string): Promise<any>
-
-// Recovery
-getRecoveryStatus(projectId: string): Promise<any>
-resumeSync(projectId: string, options?: any): Promise<any>
-cancelRecovery(projectId: string): Promise<any>
-```
+// Connect
+await sdk.connectWebSocket();
 
-</details>
+// Subscribe to project
+sdk.projectSync.subscribeToProject(projectId);
 
-<details>
-<summary><b>Delta Manager API</b> (<code>sdk.deltaManager</code>) - индексация проекта</summary>
+// Listen for updates
+sdk.projectSync.on('sync-progress', (data) => {
+  console.log(`Progress: ${data.processedFiles}/${data.totalFiles}`);
+});
 
-```typescript
-// Основной метод индексации
-syncEncryptedChunks(
-  projectId: string, 
-  encryptedChunks: any[], 
-  rootHash: string, 
-  options?: { batchSize?: number; onProgress?: (current, total) => void }
-): Promise<any>
-
-// Вспомогательные
-getSyncStatus(projectId: string): Promise<SyncStatus>
-cancelSync(projectId: string): Promise<boolean>
-cleanupDeletedFiles(projectId: string, activeFiles: any[]): Promise<any>
+sdk.projectSync.on('sync-completed', (data) => {
+  console.log(`Done: ${data.statistics.totalFiles} files`);
+});
 ```
 
-</details>
+## Error Handling
 
-<details>
-<summary><b>Search API</b> (<code>sdk.search</code>) - поиск по коду</summary>
+By default, 401/403 auth errors return `null` instead of throwing:
 
 ```typescript
-searchCode(projectId: string, query: string, options?: any): Promise<any[]>
-searchFunctions(projectId: string, query: string, options?: any): Promise<any[]>
-semanticSearch(projectId: string, query: string, options?: any): Promise<any[]>
-```
+const projects = await sdk.projects.getAllProjects();
+if (!projects) {
+  // Token expired - refresh and retry
+  await refreshToken();
+}
 
-</details>
+// To throw errors instead:
+const sdk = await CodeSolverSDK.create({
+  suppressAuthErrors: false
+});
+```
 
-<details>
-<summary><b>Chat API</b> (<code>sdk.chat</code>) - AI чат</summary>
+## Types
 
 ```typescript
-// Streaming
-streamChat(messages: ChatMessage[], options?: ChatStreamOptions): AsyncGenerator<ChatStreamChunk>
-
-// Обычный
-chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>
-chatWithRegionFailover(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>
+import {
+  ChatMessage,
+  ChatOptions,
+  Project,
+  ProjectState,
+  SearchResult,
+  UserProfile
+} from 'solver-sdk';
 ```
 
-</details>
+## Debug
 
-### WebSocket API (`sdk.projectSync`)
 ```typescript
-// Подключение
-await sdk.connectWebSocket()
-sdk.disconnectWebSocket()
-sdk.isWebSocketConnected
-
-// Подписка
-sdk.projectSync.subscribeToProject(projectId)
-sdk.projectSync.unsubscribeFromProject(projectId)
-
-// События
-sdk.projectSync.on('sync-status-update', callback)  // {projectId, status, timestamp}
-sdk.projectSync.on('sync-progress', callback)       // {projectId, progress, processedFiles, totalFiles}
-sdk.projectSync.on('sync-completed', callback)      // {projectId, processedChunks, statistics}
-sdk.projectSync.on('sync-error', callback)          // {projectId, error, timestamp}
-
-// Пример: Cursor-like прогресс по файлам (v7.1.1+)
-sdk.projectSync.on('sync-progress', (data) => {
-  if (data.totalFiles && data.processedFiles) {
-    // User-friendly: "450 of 722 files"
-    console.log(`${data.processedFiles}/${data.totalFiles} files (${data.progress}%)`);
-    updateUI(data.processedFiles, data.totalFiles, data.progress);
-  } else {
-    // Fallback: chunks (для старых версий backend)
-    console.log(`${data.currentChunk}/${data.totalChunks} chunks`);
-  }
-});
-
-sdk.projectSync.on('sync-completed', (data) => {
-  const files = data.statistics?.totalFiles || 0;
-  console.log(`Indexed ${files} files in ${data.duration}ms`);
+const sdk = await CodeSolverSDK.create({
+  debug: 'verbose',  // silent | error | warn | info | debug | verbose
+  webSocket: { debug: true }
 });
 ```
 
-## 🔧 Как работать с SDK
+## Delta Chunking (Indexing)
 
-### Индексация проекта
 ```typescript
-// ✅ ЕДИНСТВЕННЫЙ способ индексации (v6.2.2+):
+// ✅ Main indexing method
 await sdk.deltaManager.syncEncryptedChunks(projectId, chunks, rootHash, {
   batchSize: 50,
   onProgress: (current, total) => console.log(`${current}/${total}`)
 });
 
-// ❌ УДАЛЕНО: sdk.projects.startIndexing() - больше не существует
-// ❌ УДАЛЕНО: filesystem индексация на сервере
+// Check sync status
+const state = await sdk.projects.getProjectState(projectId, clientRootHash);
+if (state.syncRequired) {
+  // Needs sync
+}
+
+// Cancel ongoing sync
+await sdk.deltaManager.cancelSync(projectId);
 ```
 
-**Важно:** Client Extension создает chunks → SDK отправляет на сервер → Сервер индексирует
+## Session Recovery
 
-### Session Recovery
 ```typescript
-// Всегда проверять при старте проекта
+// Always check on project open
 const recovery = await sdk.projects.getRecoveryStatus(projectId);
 if (recovery.needsRecovery) {
-  // ✨ v6.2.2+: показывает "480 из 642 файлов" вместо "0 из 0"
-  // Показать диалог: Continue (67%) — 480/642 files | Start Fresh
-  await sdk.projects.resumeSync(projectId);  // или cancelRecovery()
+  const { processedFiles, totalFiles, percentage } = recovery.progress;
+  
+  // Show dialog: "Continue (67%) — 480/642 files" or "Start Fresh"
+  await sdk.projects.resumeSync(projectId);  // Continue
+  // OR
+  await sdk.projects.cancelRecovery(projectId);  // Start over
 }
 ```
 
-### WebSocket
-- Требуется **OAuth токен** в production
-- Автоматическое переподключение при разрыве
-- События фильтруются по `projectId`
-- Fallback на HTTP polling если недоступен
-
-### Авторизация
-- **Локально**: `apiKey` для HTTP API
-- **Production**: OAuth `access_token` для HTTP + WebSocket
-- **v6.1.4+**: `getAuthToken()` для автоматического обновления токенов
-
-### Graceful Auth Errors (v7.0.1+)
-По умолчанию SDK **тихо обрабатывает** 401/403 ошибки (возвращает `null`) вместо выброса исключения.
-Это предотвращает `ERR` логи в VS Code Extension Host.
+## Key Types
 
+### ProjectState
 ```typescript
-const sdk = await CodeSolverSDK.create({
-  baseURL: 'https://workai.su/api/v1',
-  suppressAuthErrors: true  // По умолчанию true
-});
+interface ProjectState {
+  projectId: string;
+  merkleRootHash: string | null;
+  totalFiles: number;              // For UI display
+  indexingStatus: 'pending' | 'in-progress' | 'complete' | 'failed';
+  syncRequired?: boolean;          // Compare with client hash
+}
+```
 
-// Если токен истек, SDK вернет null вместо throw
-const projects = await sdk.projects.getAllProjects();
-if (!projects) {
-  // Extension сам обрабатывает auth ошибку
-  await authManager.refreshToken();
+### SyncProgressEvent
+```typescript
+interface SyncProgressEvent {
+  projectId: string;
+  progress: number;                // 0-100
+  processedFiles: number;          // 450
+  totalFiles: number;              // 722
+  stage: 'receiving_chunks' | 'processing_chunks' | 'creating_embeddings' | 'finalizing';
 }
 ```
 
-**Отключить (старое поведение):**
+### RecoveryInfo
 ```typescript
-const sdk = await CodeSolverSDK.create({
-  suppressAuthErrors: false  // SDK будет бросать ошибки как раньше
-});
+interface RecoveryInfo {
+  needsRecovery: boolean;
+  progress: {
+    processedFiles: number;
+    totalFiles: number;
+    percentage: number;            // 0-100
+  };
+  canResume: boolean;
+}
 ```
 
-## 📝 Примеры
+## Troubleshooting
 
-### Базовый workflow
+### "0 files" after indexing
 ```typescript
-const sdk = await CodeSolverSDK.create({
-  baseURL: 'https://workai.su/api/v1',
-  getAuthToken: () => authManager.getAccessToken()
-});
-
-// 1. Найти/создать проект
-const project = await sdk.projects.findOrCreateProject('/path/to/project');
+const state = await sdk.projects.getProjectState(projectId);
+console.log(state.totalFiles); // Should be > 0
+// If 0: update backend to latest version
+```
 
-// 2. Проверить recovery
-const recovery = await sdk.projects.getRecoveryStatus(project.id);
-if (recovery.needsRecovery) {
-  await sdk.projects.resumeSync(project.id);
-  return;
-}
+### No WebSocket updates
+```typescript
+// 1. Check connection
+console.log(sdk.isWebSocketConnected); // should be true
 
-// 3. Проверить нужна ли синхронизация
-const state = await sdk.projects.getProjectState(project.id, clientRootHash);
-if (!state.syncRequired) {
-  console.log('Проект синхронизирован');
-  return;
-}
+// 2. Verify subscription
+sdk.projectSync.subscribeToProject(projectId);
 
-// 4. Подключить WebSocket для прогресса
-await sdk.connectWebSocket();
-sdk.projectSync.subscribeToProject(project.id);
-sdk.projectSync.on('sync-progress', (data) => {
-  console.log(`Прогресс: ${data.progress}%`);
+// 3. Ensure OAuth token (production)
+const sdk = await CodeSolverSDK.create({
+  getAuthToken: () => authManager.getAccessToken()
 });
 
-// 5. Синхронизировать
-await sdk.deltaManager.syncEncryptedChunks(project.id, chunks, rootHash);
-
-// 6. Поиск по проекту
-const results = await sdk.search.searchCode(project.id, 'function handleClick');
+// 4. Fallback to HTTP polling
+const status = await sdk.projects.getIndexingStatus(projectId);
 ```
 
-### Chat с streaming
+### Interrupted sync
 ```typescript
-for await (const chunk of sdk.chat.streamChat(messages, { model: 'claude-3-5-sonnet' })) {
-  if (chunk.type === 'content_block_delta') {
-    process.stdout.write(chunk.delta.text);
-  }
+const recovery = await sdk.projects.getRecoveryStatus(projectId);
+if (recovery.needsRecovery) {
+  // Option 1: Resume
+  await sdk.projects.resumeSync(projectId);
+  
+  // Option 2: Cancel and restart
+  await sdk.projects.cancelRecovery(projectId);
 }
 ```
 
-## ℹ️ Архитектура
+## API Reference
 
-**Pure Cloud-First:**
-- Backend SDK — HTTP клиент (НЕ работает с файлами)
-- Client Extension — сканирует файлы, создает chunks
-- Только Delta-Chunking — filesystem индексация удалена
-
-<details>
-<summary><b>Миграция с v6.x</b></summary>
-
-**BREAKING CHANGES:**
-- ❌ Удален `sdk.projects.startIndexing()`
-- ✅ Используйте `sdk.deltaManager.syncEncryptedChunks()`
+### Projects (`sdk.projects`)
 
 ```typescript
-// ❌ Старый код:
-// await sdk.projects.startIndexing(projectId);
-
-// ✅ Новый код:
-const chunks = await extension.scanAndCreateChunks();
-const hash = extension.calculateMerkleRoot();
-await sdk.deltaManager.syncEncryptedChunks(projectId, chunks, hash);
+getAllProjects(): Promise<Project[]>
+getProjects(): Promise<Project[]>
+getProject(projectId: string): Promise<Project>
+createProject(name: string, data?: any, options?: ProjectOptions): Promise<Project>
+findOrCreateProject(name: string): Promise<Project>
+deleteProject(projectId: string): Promise<void>
+getReadyProjects(): Promise<Project[]>
+getProjectState(projectId: string, clientRootHash?: string): Promise<ProjectState>
+getProjectStatus(projectId: string): Promise<any>
+getIndexingStatus(projectId: string): Promise<any>
+cancelIndexing(projectId: string): Promise<boolean>
+clearIndexingError(projectId: string): Promise<boolean>
+getRecoveryStatus(projectId: string): Promise<RecoveryInfo>
+resumeSync(projectId: string, options?: any): Promise<any>
+cancelRecovery(projectId: string): Promise<void>
+initializeDeltaSync(projectId: string, params: any): Promise<any>
+resetIndexing(projectId: string): Promise<any>
+restartIndexing(projectId: string): Promise<any>
+getFilePathMapping(projectId: string): Promise<any>
 ```
 
-</details>
-
-## 📦 Ключевые типы данных
+### Delta Manager (`sdk.deltaManager`)
 
-### ProjectState (v7.1.0+)
 ```typescript
-interface ProjectState {
-  projectId: string;
-  projectName: string;
-  merkleRootHash: string | null;      // Server Merkle root для сравнения
-  lastIndexedAt: Date | null;
-  totalChunks: number;                // Технические детали
-  totalFiles: number;                 // ✨ Количество файлов для UI
-  indexingStatus: 'pending' | 'in-progress' | 'complete' | 'failed' | 'cancelled';
-  syncRequired?: boolean;             // true если нужна синхронизация
-  lastSyncSessionId?: string;
-}
-
-// Использование:
-const state = await sdk.projects.getProjectState(projectId, clientRootHash);
-if (state.syncRequired) {
-  // Нужна синхронизация
-}
-console.log(`${state.totalFiles} files indexed`);
+initSync(projectId: string, request: SyncInitRequest): Promise<any>
+uploadChunkBatch(projectId: string, chunks: any[]): Promise<any>
+uploadChunksWithRetry(projectId: string, chunks: any[], options?: any): Promise<any>
+finalizeSync(projectId: string): Promise<SyncResult>
+getSyncStatus(projectId: string): Promise<SyncStatus>
+cancelSync(projectId: string): Promise<{ success: boolean; message?: string }>
+cleanupFiles(projectId: string, activeFiles: string[]): Promise<any>
 ```
 
-### SyncProgressEvent (v7.1.1+)
-```typescript
-interface SyncProgressEvent {
-  projectId: string;
-  sessionId: string;
-  stage: 'receiving_chunks' | 'processing_chunks' | 'creating_embeddings' | 'updating_tree' | 'finalizing';
-  progress: number;                   // 0-100
-  
-  // User-friendly (файлы) - основное для UI
-  processedFiles?: number;            // 450
-  totalFiles?: number;                // 722
-  
-  // Technical (чанки) - опционально
-  currentChunk?: number;
-  totalChunks?: number;
-  
-  estimatedTimeRemaining?: number;    // секунды
-  details?: string;
-  timestamp: Date;
-}
-
-// Использование:
-sdk.projectSync.on('sync-progress', (data) => {
-  if (data.totalFiles) {
-    statusBar.text = `${data.processedFiles}/${data.totalFiles} files`;
-  }
-});
-```
+### Chat (`sdk.chat`)
 
-### SyncCompletedEvent (v7.1.1+)
 ```typescript
-interface SyncCompletedEvent {
-  projectId: string;
-  sessionId: string;
-  status: 'success' | 'failed' | 'cancelled';
-  totalProcessed: number;
-  duration: number;                   // миллисекунды
-  errors?: string[];
-  warnings?: string[];
-  statistics?: {
-    filesIndexed: number;
-    embeddingsCreated: number;
-    chunksProcessed: number;
-    totalSize: number;
-    totalFiles?: number;              // ✨ Для финального отображения
-  };
-}
+chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>
+chatCompletion(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>
+chatWithRegionFailover(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>
+streamChat(messages: ChatMessage[], options?: ChatStreamOptions): AsyncGenerator<ChatStreamChunk>
+streamPrompt(prompt: string, options?: ChatStreamOptions): AsyncGenerator<ChatStreamChunk>
+sendContinuation(requestId: string, messages: ChatMessage[]): AsyncGenerator<ChatStreamChunk>
+sendPromptWithRegionFailover(prompt: string, options?: ChatOptions): Promise<string>
+checkAvailability(): Promise<boolean>
+cancelRequest(requestId: string): Promise<void>
+getStreamsStats(): Promise<any>
+cleanupStaleStreams(timeoutMs?: number): Promise<any>
+cancelUserStreams(reason?: string): Promise<number>
 ```
 
-### RecoveryInfo
+### Search (`sdk.search`)
+
 ```typescript
-interface RecoveryInfo {
-  sessionId: string;
-  projectId: string;
-  projectName: string;
-  status: 'interrupted' | 'paused' | 'active' | 'uploading';
-  progress: {
-    received: number;                 // Чанки получены
-    processed: number;                // Чанки обработаны
-    total: number;                    // Всего ожидается
-    percentage: number;               // 0-100
-    processedFiles?: number;          // ✨ Файлы обработаны
-    totalFiles?: number;              // ✨ Всего файлов
-    filesPercentage?: number;         // ✨ 0-100 по файлам
-  };
-  canResume: boolean;
-  needsRecovery: boolean;
-  interruptedAt?: Date;
-}
+searchCode(projectIdOrParams: string | SearchCodeParams, params?: SearchCodeParams): Promise<SearchResult[]>
+searchFunctions(projectIdOrParams: string | SearchFunctionsParams, params?: SearchFunctionsParams): Promise<FunctionSearchResult>
+semanticSearch(projectId: string, params: SearchCodeParams): Promise<SearchResult[]>
+getFunctionStats(projectId: string): Promise<{ stats: { totalFunctions: number } }>
 ```
 
-## 🆘 Быстрое решение проблем
+### Tools (`sdk.tools`)
 
-### Проблема: "0 files" после индексации
 ```typescript
-// Проверить:
-const state = await sdk.projects.getProjectState(projectId);
-console.log(state.totalFiles); // Должно быть > 0
-
-// Если 0 - backend не сохранил totalFiles
-// Решение: Обновите backend до последней версии
+getSchemas(): Promise<ToolsResponse>
+findToolByName(name: string): Promise<ToolSchema | null>
+getToolsStats(): Promise<{ total: number; categories: Record<string, number>; mostUsed?: string[] }>
+validateToolSchema(tool: ToolSchema): boolean
+createToolSchema(name: string, description: string, properties: any, required?: string[]): ToolSchema
 ```
 
-### Проблема: Нет WebSocket обновлений
-```typescript
-// 1. Проверить подключение
-console.log(sdk.isWebSocketConnected); // должно быть true
-
-// 2. Проверить подписку
-sdk.projectSync.subscribeToProject(projectId);
-
-// 3. Проверить токен (production)
-const sdk = await CodeSolverSDK.create({
-  baseURL: 'https://workai.su/api/v1',
-  getAuthToken: () => authManager.getAccessToken() // OAuth required
-});
+### User (`sdk.user`)
 
-// 4. Fallback на HTTP polling
-const status = await sdk.projects.getIndexingStatus(projectId);
+```typescript
+getProfile(): Promise<UserProfile>
 ```
 
-### Проблема: Прерванная синхронизация
+### Auth (`sdk.auth`)
+
 ```typescript
-// Проверить recovery status
-const recovery = await sdk.projects.getRecoveryStatus(projectId);
-if (recovery.needsRecovery) {
-  // Показать UI диалог
-  const percentage = recovery.progress.filesPercentage || recovery.progress.percentage;
-  const files = `${recovery.progress.processedFiles}/${recovery.progress.totalFiles}`;
-  
-  // Пользователь выбирает:
-  await sdk.projects.resumeSync(projectId);      // Продолжить
-  // или
-  await sdk.projects.cancelRecovery(projectId);  // Начать заново
-}
+revokeToken(token: string): Promise<{ ok: boolean }>
+logout(): Promise<{ ok: boolean }>
 ```
 
-### Проблема: 401/403 ошибки
-```typescript
-// v7.0.1+: По умолчанию возвращает null
-const projects = await sdk.projects.getAllProjects();
-if (!projects) {
-  // Токен истек
-  await authManager.refreshToken();
-  // Повторить запрос
-}
+### Models (`sdk.models`)
 
-// Старое поведение (throw):
-const sdk = await CodeSolverSDK.create({
-  suppressAuthErrors: false
-});
+```typescript
+getAllModels(): Promise<any[]>
+getModels(): Promise<any[]>
+getAvailableModels(): Promise<any[]>
+getProviderModels(providerId: string): Promise<ProviderModels>
+getModelInfo(modelId: string): Promise<any>
 ```
 
-## 📚 Справка
+### Updates (`sdk.updates`)
 
-### TypeScript типы
 ```typescript
-import { 
-  ChatMessage, 
-  ChatOptions, 
-  Project, 
-  ProjectState,
-  SyncProgressEvent,
-  SyncCompletedEvent,
-  RecoveryInfo
-} from '@androidsprintteam/solver-sdk';
+checkForUpdates(options: UpdateCheckOptions): Promise<UpdateResponse>
+getChangelog(version: string, locale: string): Promise<string>
+sendStats(event: UpdateStatsEvent): Promise<void>
+getLatestVersion(channel?: string): Promise<LatestVersionInfo>
+checkAvailability(): Promise<boolean>
 ```
 
-### Debug режим
+### WebSocket (`sdk.projectSync`)
+
 ```typescript
-const sdk = await CodeSolverSDK.create({
-  debug: 'verbose',  // silent | error | warn | info | debug | verbose
-  webSocket: { debug: true }
-});
+connectWebSocket(): Promise<void>
+disconnectWebSocket(): void
+isWebSocketConnected: boolean
+projectSync.subscribeToProject(projectId: string): void
+projectSync.unsubscribeFromProject(projectId: string): void
+projectSync.on('sync-status-update', callback): void
+projectSync.on('sync-progress', callback): void
+projectSync.on('sync-completed', callback): void
+projectSync.on('sync-error', callback): void
+projectSync.off(event: string, callback): void
 ```
 
-### Обработка ошибок
+### Utility
+
 ```typescript
-try {
-  await sdk.projects.getProject(projectId);
-} catch (error) {
-  console.error(`[HTTP ${error.status}] ${error.message}`);
-}
+checkHealth(): Promise<boolean>
+version: string
+baseURL: string
 ```
 
-## 📄 License
+## Docs
+
+- **Full verification:** [SDK_v7.2.0_FINAL_REPORT.md](../docs/sdk/SDK_v7.2.0_FINAL_REPORT.md)
+- **Migration guide:** [SDK_v7.2.0_MIGRATION.md](../docs/sdk/SDK_v7.2.0_MIGRATION.md)
+- **Architecture:** [ARCHITECTURE_NOTES.md](../docs/sdk/ARCHITECTURE_NOTES.md)
+
+All methods have JSDoc comments - check IDE autocomplete for full reference.
+
+---
 
-MIT
+**Status:** ✅ Production Ready | **v7.3.0** | **License:** MIT