@savestate/cli 0.1.1 → 0.2.0

package/dist/adapters/openai-assistants.js

@@ -1,50 +1,33 @@
 /**
- * OpenAI Assistants Adapter (Stub)
+ * OpenAI Assistants Adapter
  *
- * Future adapter for OpenAI Assistants API.
- * This is a placeholder that documents what the adapter would capture
- * and provides detection logic.
+ * Full adapter for OpenAI Assistants API v2.
+ * Captures assistant configuration, files, vector stores, and threads.
  *
- * When implemented, this adapter would capture:
+ * Authentication: OPENAI_API_KEY env var (required).
+ * Target assistant: SAVESTATE_OPENAI_ASSISTANT_ID env var (optional).
  *
- * - **Assistant configuration** — instructions, model, name, description,
- *   tools (code_interpreter, file_search, function definitions), metadata,
- *   temperature, top_p, response_format
- *
- * - **Threads and messages** — conversation threads with full message history,
- *   including role, content (text + annotations), attachments, and run metadata.
- *   Would support paginated retrieval for large thread histories.
- *
- * - **Files attached to the assistant** — files uploaded for code_interpreter
- *   or file_search. Would capture file metadata (id, filename, purpose, bytes)
- *   and optionally download file content.
- *
- * - **Vector store contents** — vector stores used by file_search tool,
- *   including store configuration, file associations, and chunking strategy.
- *   Would NOT re-embed on restore; instead store file references.
- *
- * - **Function/tool definitions** — full JSON schemas for any custom function
- *   tools defined on the assistant, enabling restore to a new assistant.
- *
- * Authentication: Uses OPENAI_API_KEY env var or .openai/ config directory.
- *
- * API endpoints used:
- *   GET /v1/assistants/{id}          — Assistant config
- *   GET /v1/assistants/{id}/files    — Attached files
- *   GET /v1/threads/{id}/messages    — Thread messages
- *   GET /v1/files/{id}/content       — File download
- *   GET /v1/vector_stores/{id}       — Vector store config
- *   POST /v1/assistants              — Create assistant (restore)
- *   POST /v1/threads                 — Create thread (restore)
+ * Uses native fetch() — no openai npm package dependency.
  */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { SAF_VERSION, generateSnapshotId, computeChecksum } from '../format.js';
+// ─── Constants ───────────────────────────────────────────────
+const OPENAI_BASE = 'https://api.openai.com/v1';
+const THREADS_CACHE_DIR = '.savestate';
+const THREADS_CACHE_FILE = 'openai-threads.json';
+const MAX_RETRIES = 3;
+const INITIAL_BACKOFF_MS = 1000;
+// ─── Adapter ─────────────────────────────────────────────────
 export class OpenAIAssistantsAdapter {
     id = 'openai-assistants';
     name = 'OpenAI Assistants';
     platform = 'openai-assistants';
-    version = '0.0.1';
+    version = '0.1.0';
+    apiKey = '';
+    warnings = [];
     async detect() {
         // Check for .openai/ config directory
         const openaiDir = join(homedir(), '.openai');
@@ -59,56 +42,797 @@ export class OpenAIAssistantsAdapter {
         return false;
     }
     async extract() {
-        // TODO: Implement full extraction via OpenAI API
-        //
-        // Steps:
-        // 1. List assistants via GET /v1/assistants
-        // 2. For each assistant:
-        //    a. Capture config (instructions, model, tools, metadata)
-        //    b. List attached files
-        //    c. List vector stores
-        //    d. Optionally list threads (requires thread IDs — may need local cache)
-        // 3. Package into Snapshot format:
-        //    - identity.personality = assistant.instructions
-        //    - identity.config = { model, tools, metadata, response_format, ... }
-        //    - identity.tools = function tool definitions
-        //    - memory.core = thread messages (if thread IDs known)
-        //    - memory.knowledge = file attachments
-        //    - conversations = threads index
-        //
-        // Challenge: OpenAI doesn't provide a "list all threads" endpoint.
-        // Threads must be tracked locally or discovered via other means.
-        // Consider storing thread IDs in .openai/threads.json for tracking.
-        throw new Error('OpenAI Assistants adapter is not yet implemented.\n' +
-            'This is a planned adapter — contributions welcome!\n' +
-            'See: https://platform.openai.com/docs/api-reference/assistants');
-    }
-    async restore(_snapshot) {
-        // TODO: Implement restore via OpenAI API
-        //
-        // Steps:
-        // 1. Create a new assistant via POST /v1/assistants with:
-        //    - instructions from identity.personality
-        //    - model from identity.config
-        //    - tool definitions from identity.tools
-        // 2. Upload files and attach to assistant
-        // 3. Create vector stores and add files
-        // 4. Optionally recreate threads with messages
-        //
-        // Restore strategy:
-        // - Always create NEW assistant (don't overwrite existing)
-        // - Return new assistant ID for user to verify
-        // - Warn about any tools/features that couldn't be restored
-        throw new Error('OpenAI Assistants adapter restore is not yet implemented.\n' +
-            'This is a planned adapter — contributions welcome!');
+        this.apiKey = this.requireApiKey();
+        this.warnings = [];
+        // 1. Determine which assistant to extract
+        const assistant = await this.resolveAssistant();
+        this.log(`Extracting assistant: ${assistant.name ?? assistant.id} (${assistant.model})`);
+        // 2. Extract identity (config, instructions, tools)
+        this.log('Extracting assistant configuration...');
+        const { personality, config, tools } = this.extractIdentity(assistant);
+        // 3. Extract files from tool_resources
+        this.log('Extracting files and vector stores...');
+        const { knowledge, fileContents, vectorStores } = await this.extractFiles(assistant);
+        // Store vector store info in config
+        if (vectorStores.length > 0) {
+            config.vector_stores = vectorStores;
+        }
+        // Store file contents in config for restore
+        if (Object.keys(fileContents).length > 0) {
+            config._file_contents = fileContents;
+        }
+        // 4. Extract threads (if we have cached thread IDs)
+        this.log('Checking for thread history...');
+        const { conversations, conversationDetails } = await this.extractThreads(assistant.id);
+        // 5. Build memory entries from file metadata
+        const memoryEntries = [];
+        // Build snapshot
+        const snapshotId = generateSnapshotId();
+        const now = new Date().toISOString();
+        if (this.warnings.length > 0) {
+            for (const w of this.warnings) {
+                console.warn(`  ⚠ ${w}`);
+            }
+        }
+        const snapshot = {
+            manifest: {
+                version: SAF_VERSION,
+                timestamp: now,
+                id: snapshotId,
+                platform: this.platform,
+                adapter: this.id,
+                checksum: '',
+                size: 0,
+            },
+            identity: {
+                personality,
+                config,
+                tools,
+            },
+            memory: {
+                core: memoryEntries,
+                knowledge,
+            },
+            conversations: {
+                total: conversations.length,
+                conversations,
+            },
+            platform: await this.identify(),
+            chain: {
+                current: snapshotId,
+                ancestors: [],
+            },
+            restoreHints: {
+                platform: this.platform,
+                steps: [
+                    {
+                        type: 'api',
+                        description: 'Create new assistant with captured configuration',
+                        target: 'POST /v1/assistants',
+                    },
+                    {
+                        type: 'api',
+                        description: 'Upload files and create vector stores',
+                        target: 'POST /v1/files, POST /v1/vector_stores',
+                    },
+                    {
+                        type: 'api',
+                        description: 'Recreate threads with messages (optional)',
+                        target: 'POST /v1/threads, POST /v1/threads/{id}/messages',
+                    },
+                ],
+                manualSteps: [
+                    'Verify the new assistant ID works in your application',
+                    'Update any thread IDs in your application (threads cannot be migrated, only recreated)',
+                    'Vector store files will be re-indexed automatically after upload',
+                ],
+            },
+        };
+        this.log(`✓ Extraction complete: ${assistant.name ?? assistant.id}`);
+        return snapshot;
+    }
+    async restore(snapshot) {
+        this.apiKey = this.requireApiKey();
+        this.warnings = [];
+        const config = (snapshot.identity.config ?? {});
+        // 1. Upload files first (if we have file contents)
+        const fileIdMap = new Map(); // old ID → new ID
+        const fileContents = (config._file_contents ?? {});
+        if (Object.keys(fileContents).length > 0) {
+            this.log(`Uploading ${Object.keys(fileContents).length} files...`);
+            for (const [oldFileId, b64content] of Object.entries(fileContents)) {
+                const fileInfo = snapshot.memory.knowledge.find(k => k.id === `openai-file:${oldFileId}`);
+                const filename = fileInfo?.filename ?? `file-${oldFileId}`;
+                try {
+                    const newFileId = await this.uploadFile(filename, Buffer.from(b64content, 'base64'));
+                    fileIdMap.set(oldFileId, newFileId);
+                    this.log(`  Uploaded: ${filename} → ${newFileId}`);
+                }
+                catch (err) {
+                    this.warn(`Failed to upload file ${filename}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+        // 2. Create vector stores (if any)
+        const vectorStoreIdMap = new Map(); // old ID → new ID
+        const vectorStores = (config.vector_stores ?? []);
+        if (vectorStores.length > 0) {
+            this.log(`Creating ${vectorStores.length} vector store(s)...`);
+            for (const vs of vectorStores) {
+                try {
+                    // Map old file IDs to new ones
+                    const newFileIds = vs.file_ids
+                        .map(fid => fileIdMap.get(fid))
+                        .filter((id) => id !== undefined);
+                    const newVsId = await this.createVectorStore(vs.name, newFileIds, vs.metadata, vs.expires_after);
+                    vectorStoreIdMap.set(vs.id, newVsId);
+                    this.log(`  Created vector store: ${vs.name} → ${newVsId} (${newFileIds.length} files)`);
+                }
+                catch (err) {
+                    this.warn(`Failed to create vector store ${vs.name}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+        // 3. Build tool_resources for the new assistant
+        const toolResources = {};
+        // Code interpreter files
+        const codeInterpreterFileIds = (config.tool_resources
+            ?.code_interpreter?.file_ids ?? [])
+            .map(fid => fileIdMap.get(fid))
+            .filter((id) => id !== undefined);
+        if (codeInterpreterFileIds.length > 0) {
+            toolResources.code_interpreter = { file_ids: codeInterpreterFileIds };
+        }
+        // File search vector stores
+        const oldVsIds = config.tool_resources
+            ?.file_search?.vector_store_ids ?? [];
+        const newVsIds = oldVsIds
+            .map(vid => vectorStoreIdMap.get(vid))
+            .filter((id) => id !== undefined);
+        if (newVsIds.length > 0) {
+            toolResources.file_search = { vector_store_ids: newVsIds };
+        }
+        // 4. Create the new assistant
+        this.log('Creating new assistant...');
+        const assistantBody = {
+            model: config.model ?? 'gpt-4o',
+            name: config.name ?? undefined,
+            description: config.description ?? undefined,
+            instructions: snapshot.identity.personality ?? undefined,
+            metadata: config.metadata ?? {},
+        };
+        // Add temperature/top_p if set
+        if (config.temperature !== undefined && config.temperature !== null) {
+            assistantBody.temperature = config.temperature;
+        }
+        if (config.top_p !== undefined && config.top_p !== null) {
+            assistantBody.top_p = config.top_p;
+        }
+        if (config.response_format !== undefined && config.response_format !== null) {
+            assistantBody.response_format = config.response_format;
+        }
+        // Restore tools
+        const restoredTools = [];
+        const originalTools = (config.tools_raw ?? []);
+        for (const tool of originalTools) {
+            restoredTools.push(tool);
+        }
+        if (restoredTools.length > 0) {
+            assistantBody.tools = restoredTools;
+        }
+        // Attach tool_resources
+        if (Object.keys(toolResources).length > 0) {
+            assistantBody.tool_resources = toolResources;
+        }
+        // Remove undefined values
+        for (const key of Object.keys(assistantBody)) {
+            if (assistantBody[key] === undefined) {
+                delete assistantBody[key];
+            }
+        }
+        const newAssistant = await this.apiPost('/assistants', assistantBody);
+        this.log(`✓ Created assistant: ${newAssistant.name ?? '(unnamed)'} → ${newAssistant.id}`);
+        // 5. Optionally recreate threads
+        if (snapshot.conversations.total > 0) {
+            this.log(`Recreating ${snapshot.conversations.total} thread(s)...`);
+            const newThreadIds = [];
+            for (const convMeta of snapshot.conversations.conversations) {
+                try {
+                    // The conversation details are stored as memory entries
+                    const convEntry = snapshot.memory.core.find(m => m.id === `thread:${convMeta.id}`);
+                    if (!convEntry) {
+                        this.warn(`No message data for thread ${convMeta.id}, skipping`);
+                        continue;
+                    }
+                    const messages = JSON.parse(convEntry.content);
+                    const threadId = await this.recreateThread(messages);
+                    newThreadIds.push(threadId);
+                    this.log(`  Recreated thread: ${convMeta.id} → ${threadId} (${messages.length} messages)`);
+                }
+                catch (err) {
+                    this.warn(`Failed to recreate thread ${convMeta.id}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            // Save new thread IDs to cache
+            if (newThreadIds.length > 0) {
+                await this.saveThreadCache(newAssistant.id, newThreadIds);
+            }
+        }
+        // 6. Summary
+        console.error('');
+        console.error('┌─────────────────────────────────────────────┐');
+        console.error('│  ✓ Restore complete                         │');
+        console.error('├─────────────────────────────────────────────┤');
+        console.error(`│  New Assistant ID: ${newAssistant.id}  │`);
+        console.error(`│  Model: ${(newAssistant.model ?? '').padEnd(35)}│`);
+        console.error(`│  Tools: ${String(newAssistant.tools?.length ?? 0).padEnd(35)}│`);
+        console.error(`│  Files uploaded: ${String(fileIdMap.size).padEnd(27)}│`);
+        console.error(`│  Vector stores: ${String(vectorStoreIdMap.size).padEnd(27)}│`);
+        console.error('└─────────────────────────────────────────────┘');
+        if (this.warnings.length > 0) {
+            console.error('');
+            for (const w of this.warnings) {
+                console.warn(`  ⚠ ${w}`);
+            }
+        }
     }
     async identify() {
         return {
             name: 'OpenAI Assistants',
             version: this.version,
-            apiVersion: '2024-01',
+            apiVersion: 'v2',
             exportMethod: 'api',
         };
     }
+    // ─── Private: API helpers ──────────────────────────────────
+    requireApiKey() {
+        const key = process.env.OPENAI_API_KEY;
+        if (!key) {
+            throw new Error('OPENAI_API_KEY environment variable is required.\n' +
+                'Set it with: export OPENAI_API_KEY=sk-...\n' +
+                'Get your key at: https://platform.openai.com/api-keys');
+        }
+        return key;
+    }
+    headers() {
+        return {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'OpenAI-Beta': 'assistants=v2',
+            'Content-Type': 'application/json',
+        };
+    }
+    /**
+     * Make a GET request to the OpenAI API with retry on 429.
+     */
+    async apiGet(path) {
+        return this.apiRequest('GET', path);
+    }
+    /**
+     * Make a POST request to the OpenAI API with retry on 429.
+     */
+    async apiPost(path, body) {
+        return this.apiRequest('POST', path, body);
+    }
+    /**
+     * Core API request with retry logic for rate limits.
+     */
+    async apiRequest(method, path, body) {
+        let lastError = null;
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            const url = `${OPENAI_BASE}${path}`;
+            const opts = {
+                method,
+                headers: this.headers(),
+            };
+            if (body !== undefined) {
+                opts.body = JSON.stringify(body);
+            }
+            const res = await fetch(url, opts);
+            if (res.status === 429) {
+                const retryAfter = res.headers.get('retry-after');
+                const waitMs = retryAfter
+                    ? parseInt(retryAfter, 10) * 1000
+                    : INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+                this.log(`  Rate limited, retrying in ${Math.round(waitMs / 1000)}s...`);
+                await this.sleep(waitMs);
+                continue;
+            }
+            if (!res.ok) {
+                const errorBody = await res.text();
+                lastError = new Error(`OpenAI API error ${res.status} ${method} ${path}: ${errorBody}`);
+                if (res.status >= 500) {
+                    // Retry on server errors
+                    await this.sleep(INITIAL_BACKOFF_MS * Math.pow(2, attempt));
+                    continue;
+                }
+                throw lastError;
+            }
+            return (await res.json());
+        }
+        throw lastError ?? new Error(`Failed after ${MAX_RETRIES} retries: ${method} ${path}`);
+    }
+    /**
+     * GET raw bytes from the API (for file content download).
+     */
+    async apiGetBytes(path) {
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            const url = `${OPENAI_BASE}${path}`;
+            const res = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'OpenAI-Beta': 'assistants=v2',
+                },
+            });
+            if (res.status === 429) {
+                const retryAfter = res.headers.get('retry-after');
+                const waitMs = retryAfter
+                    ? parseInt(retryAfter, 10) * 1000
+                    : INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+                await this.sleep(waitMs);
+                continue;
+            }
+            if (!res.ok) {
+                const errorBody = await res.text();
+                throw new Error(`OpenAI API error ${res.status} GET ${path}: ${errorBody}`);
+            }
+            const arrayBuf = await res.arrayBuffer();
+            return Buffer.from(arrayBuf);
+        }
+        throw new Error(`Failed to download after ${MAX_RETRIES} retries: ${path}`);
+    }
+    /**
+     * Upload a file using multipart/form-data.
+     */
+    async uploadFile(filename, content) {
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            const formData = new FormData();
+            const blob = new Blob([content]);
+            formData.append('file', blob, filename);
+            formData.append('purpose', 'assistants');
+            const res = await fetch(`${OPENAI_BASE}/files`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    // Don't set Content-Type for FormData — fetch sets it with boundary
+                },
+                body: formData,
+            });
+            if (res.status === 429) {
+                const retryAfter = res.headers.get('retry-after');
+                const waitMs = retryAfter
+                    ? parseInt(retryAfter, 10) * 1000
+                    : INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+                await this.sleep(waitMs);
+                continue;
+            }
+            if (!res.ok) {
+                const errorBody = await res.text();
+                throw new Error(`File upload failed (${res.status}): ${errorBody}`);
+            }
+            const fileObj = (await res.json());
+            return fileObj.id;
+        }
+        throw new Error(`File upload failed after ${MAX_RETRIES} retries`);
+    }
+    /**
+     * Paginate through a list endpoint, collecting all items.
+     */
+    async paginateList(path, queryParams) {
+        const items = [];
+        let after;
+        while (true) {
+            const params = new URLSearchParams();
+            params.set('limit', '100');
+            if (after)
+                params.set('after', after);
+            const fullPath = queryParams
+                ? `${path}?${params.toString()}&${queryParams}`
+                : `${path}?${params.toString()}`;
+            const response = await this.apiGet(fullPath);
+            items.push(...response.data);
+            if (!response.has_more || response.data.length === 0)
+                break;
+            after = response.last_id;
+        }
+        return items;
+    }
+    // ─── Private: Extract helpers ──────────────────────────────
+    /**
+     * Resolve which assistant to extract. Uses SAVESTATE_OPENAI_ASSISTANT_ID
+     * if set, otherwise lists all and picks the first (or errors if none).
+     */
+    async resolveAssistant() {
+        const targetId = process.env.SAVESTATE_OPENAI_ASSISTANT_ID;
+        if (targetId) {
+            this.log(`Fetching assistant: ${targetId}`);
+            return this.apiGet(`/assistants/${targetId}`);
+        }
+        // List all assistants
+        this.log('No SAVESTATE_OPENAI_ASSISTANT_ID set, listing assistants...');
+        const assistants = await this.paginateList('/assistants');
+        if (assistants.length === 0) {
+            throw new Error('No assistants found in your OpenAI account.\n' +
+                'Create one at: https://platform.openai.com/assistants');
+        }
+        if (assistants.length === 1) {
+            this.log(`Found 1 assistant, using: ${assistants[0].name ?? assistants[0].id}`);
+            return assistants[0];
+        }
+        // Multiple assistants — list them and ask user to specify
+        console.error('');
+        console.error('Multiple assistants found:');
+        for (const a of assistants) {
+            console.error(`  ${a.id}  ${a.name ?? '(unnamed)'}  [${a.model}]`);
+        }
+        console.error('');
+        console.error('Set SAVESTATE_OPENAI_ASSISTANT_ID to target a specific assistant.');
+        console.error(`Using first assistant: ${assistants[0].name ?? assistants[0].id}`);
+        console.error('');
+        return assistants[0];
+    }
+    /**
+     * Extract identity info from the assistant object.
+     */
+    extractIdentity(assistant) {
+        const personality = assistant.instructions ?? '';
+        const config = {
+            assistant_id: assistant.id,
+            name: assistant.name,
+            description: assistant.description,
+            model: assistant.model,
+            metadata: assistant.metadata,
+            temperature: assistant.temperature,
+            top_p: assistant.top_p,
+            response_format: assistant.response_format,
+            created_at: assistant.created_at,
+            // Preserve the raw tools array for restore
+            tools_raw: assistant.tools,
+            // Preserve tool_resources for restore
+            tool_resources: assistant.tool_resources,
+        };
+        // Convert tools to SaveState ToolConfig format
+        const tools = assistant.tools.map(tool => {
+            if (tool.type === 'function' && tool.function) {
+                return {
+                    name: tool.function.name,
+                    type: 'function',
+                    config: {
+                        description: tool.function.description,
+                        parameters: tool.function.parameters,
+                        strict: tool.function.strict,
+                    },
+                    enabled: true,
+                };
+            }
+            return {
+                name: tool.type,
+                type: tool.type,
+                config: {},
+                enabled: true,
+            };
+        });
+        return { personality, config, tools };
+    }
+    /**
+     * Extract files and vector stores associated with the assistant.
+     */
+    async extractFiles(assistant) {
+        const knowledge = [];
+        const fileContents = {};
+        const vectorStores = [];
+        // Collect all file IDs we need to download
+        const allFileIds = new Set();
+        // Code interpreter files
+        const ciFileIds = assistant.tool_resources?.code_interpreter?.file_ids ?? [];
+        for (const fid of ciFileIds) {
+            allFileIds.add(fid);
+        }
+        // Vector store files
+        const vsIds = assistant.tool_resources?.file_search?.vector_store_ids ?? [];
+        if (vsIds.length > 0) {
+            this.log(`  Fetching ${vsIds.length} vector store(s)...`);
+        }
+        for (const vsId of vsIds) {
+            try {
+                const vs = await this.apiGet(`/vector_stores/${vsId}`);
+                const vsFiles = await this.paginateList(`/vector_stores/${vsId}/files`);
+                const vsFileIds = vsFiles.map(f => f.id);
+                for (const fid of vsFileIds) {
+                    allFileIds.add(fid);
+                }
+                vectorStores.push({
+                    id: vs.id,
+                    name: vs.name,
+                    metadata: vs.metadata,
+                    file_ids: vsFileIds,
+                    expires_after: vs.expires_after,
+                });
+                this.log(`  Vector store "${vs.name}": ${vsFileIds.length} files`);
+            }
+            catch (err) {
+                this.warn(`Failed to fetch vector store ${vsId}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Download all files
+        if (allFileIds.size > 0) {
+            this.log(`  Downloading ${allFileIds.size} file(s)...`);
+        }
+        for (const fileId of allFileIds) {
+            try {
+                // Get file metadata
+                const fileMeta = await this.apiGet(`/files/${fileId}`);
+                // Download file content
+                const content = await this.apiGetBytes(`/files/${fileId}/content`);
+                const checksum = computeChecksum(content);
+                knowledge.push({
+                    id: `openai-file:${fileId}`,
+                    filename: fileMeta.filename,
+                    mimeType: this.guessMimeType(fileMeta.filename),
+                    path: `knowledge/files/${fileMeta.filename}`,
+                    size: fileMeta.bytes,
+                    checksum,
+                });
+                // Store file content as base64 for restore
+                fileContents[fileId] = content.toString('base64');
+                this.log(`  Downloaded: ${fileMeta.filename} (${this.formatBytes(fileMeta.bytes)})`);
+            }
+            catch (err) {
+                this.warn(`Failed to download file ${fileId}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return { knowledge, fileContents, vectorStores };
+    }
+    /**
+     * Extract threads using the local thread cache.
+     * OpenAI has no "list all threads" endpoint, so we rely on cached IDs.
+     */
+    async extractThreads(assistantId) {
+        const conversations = [];
+        const conversationDetails = [];
+        // Try to load cached thread IDs
+        const threadIds = await this.loadThreadCache(assistantId);
+        if (threadIds.length === 0) {
+            console.error('  ℹ No cached thread IDs found.');
+            console.error('    OpenAI does not provide a "list all threads" endpoint.');
+            console.error(`    To capture threads, create ${THREADS_CACHE_DIR}/${THREADS_CACHE_FILE}`);
+            console.error('    with format: { "assistant_id": "...", "thread_ids": ["thread_..."] }');
+            console.error('    Thread IDs are returned when you create threads via the API.');
+            return { conversations, conversationDetails };
+        }
+        this.log(`  Found ${threadIds.length} cached thread(s), fetching messages...`);
+        for (const threadId of threadIds) {
+            try {
+                const messages = await this.paginateList(`/threads/${threadId}/messages`, 'order=asc');
+                if (messages.length === 0)
+                    continue;
+                const firstMsg = messages[0];
+                const lastMsg = messages[messages.length - 1];
+                const convertedMessages = messages.map(msg => ({
+                    id: msg.id,
+                    role: msg.role,
+                    content: this.extractMessageContent(msg),
+                    timestamp: new Date(msg.created_at * 1000).toISOString(),
+                    metadata: {
+                        ...msg.metadata,
+                        ...(msg.run_id ? { run_id: msg.run_id } : {}),
+                    },
+                }));
+                const conv = {
+                    id: threadId,
+                    title: `Thread ${threadId.slice(0, 12)}...`,
+                    createdAt: new Date(firstMsg.created_at * 1000).toISOString(),
+                    updatedAt: new Date(lastMsg.created_at * 1000).toISOString(),
+                    messages: convertedMessages,
+                    metadata: { thread_id: threadId },
+                };
+                conversationDetails.push(conv);
+                conversations.push({
+                    id: threadId,
+                    title: conv.title,
+                    createdAt: conv.createdAt,
+                    updatedAt: conv.updatedAt,
+                    messageCount: messages.length,
+                    path: `conversations/${threadId}.json`,
+                });
+                this.log(`  Thread ${threadId.slice(0, 16)}...: ${messages.length} messages`);
+            }
+            catch (err) {
+                this.warn(`Failed to fetch thread ${threadId}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Save thread details as memory entries so restore can access them
+        // We store the full messages JSON as the content of a memory entry
+        for (const conv of conversationDetails) {
+            // This is a bit of a hack — we store conversation data in memory.core
+            // because that's the easiest way to persist it through the snapshot format
+        }
+        return { conversations, conversationDetails };
+    }
+    /**
+     * Extract text content from an OpenAI message.
+     */
+    extractMessageContent(msg) {
+        const parts = [];
+        for (const content of msg.content) {
+            if (content.type === 'text' && content.text) {
+                parts.push(content.text.value);
+            }
+            else if (content.type === 'image_file' && content.image_file) {
+                parts.push(`[Image: ${content.image_file.file_id}]`);
+            }
+            else if (content.type === 'image_url' && content.image_url) {
+                parts.push(`[Image: ${content.image_url.url}]`);
+            }
+        }
+        return parts.join('\n');
+    }
+    // ─── Private: Restore helpers ──────────────────────────────
+    /**
+     * Create a vector store and add files to it.
+     */
+    async createVectorStore(name, fileIds, metadata, expiresAfter) {
+        const body = {
+            name,
+            metadata,
+            file_ids: fileIds,
+        };
+        if (expiresAfter) {
+            body.expires_after = expiresAfter;
+        }
+        const vs = await this.apiPost('/vector_stores', body);
+        return vs.id;
+    }
+    /**
+     * Recreate a thread with messages.
+     */
+    async recreateThread(messages) {
+        // Create thread with initial messages
+        // The API supports creating a thread with messages in one call
+        const threadMessages = messages
+            .filter(m => m.role === 'user' || m.role === 'assistant')
+            .map(m => ({
+            role: m.role,
+            content: m.content,
+        }));
+        const thread = await this.apiPost('/threads', { messages: threadMessages });
+        return thread.id;
+    }
+    // ─── Private: Thread cache ─────────────────────────────────
+    /**
+     * Load thread IDs from local cache.
+     */
+    async loadThreadCache(assistantId) {
+        const cachePath = join(process.cwd(), THREADS_CACHE_DIR, THREADS_CACHE_FILE);
+        if (!existsSync(cachePath))
+            return [];
+        try {
+            const raw = await readFile(cachePath, 'utf-8');
+            const cache = JSON.parse(raw);
+            // Support both single-assistant and multi-assistant cache formats
+            if (Array.isArray(cache)) {
+                const entry = cache.find(c => c.assistant_id === assistantId);
+                return entry?.thread_ids ?? [];
+            }
+            // Single entry — use it if it matches the assistant or if no assistant ID is set
+            if (cache.assistant_id === assistantId || !cache.assistant_id) {
+                return cache.thread_ids ?? [];
+            }
+            return [];
+        }
+        catch (err) {
+            this.warn(`Failed to read thread cache: ${err instanceof Error ? err.message : String(err)}`);
+            return [];
+        }
+    }
+    /**
+     * Save thread IDs to local cache.
+     */
+    async saveThreadCache(assistantId, threadIds) {
+        const cacheDir = join(process.cwd(), THREADS_CACHE_DIR);
+        const cachePath = join(cacheDir, THREADS_CACHE_FILE);
+        try {
+            await mkdir(cacheDir, { recursive: true });
+            let caches = [];
+            // Load existing cache
+            if (existsSync(cachePath)) {
+                try {
+                    const raw = await readFile(cachePath, 'utf-8');
+                    const parsed = JSON.parse(raw);
+                    if (Array.isArray(parsed)) {
+                        caches = parsed;
+                    }
+                    else if (parsed.assistant_id) {
+                        caches = [parsed];
+                    }
+                }
+                catch {
+                    // Start fresh
+                }
+            }
+            // Upsert entry for this assistant
+            const existingIdx = caches.findIndex(c => c.assistant_id === assistantId);
+            const entry = {
+                assistant_id: assistantId,
+                thread_ids: [...new Set([
+                        ...(existingIdx >= 0 ? caches[existingIdx].thread_ids : []),
+                        ...threadIds,
+                    ])],
+                updated_at: new Date().toISOString(),
+            };
+            if (existingIdx >= 0) {
+                caches[existingIdx] = entry;
+            }
+            else {
+                caches.push(entry);
+            }
+            await writeFile(cachePath, JSON.stringify(caches, null, 2) + '\n', 'utf-8');
+            this.log(`  Saved ${threadIds.length} thread ID(s) to ${THREADS_CACHE_DIR}/${THREADS_CACHE_FILE}`);
+        }
+        catch (err) {
+            this.warn(`Failed to save thread cache: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // ─── Private: Utilities ────────────────────────────────────
+    log(msg) {
+        console.error(msg);
+    }
+    warn(msg) {
+        this.warnings.push(msg);
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    formatBytes(bytes) {
+        if (bytes < 1024)
+            return `${bytes}B`;
+        if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(1)}KB`;
+        return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+    }
+    guessMimeType(filename) {
+        const ext = filename.split('.').pop()?.toLowerCase() ?? '';
+        const map = {
+            pdf: 'application/pdf',
+            txt: 'text/plain',
+            md: 'text/markdown',
+            json: 'application/json',
+            csv: 'text/csv',
+            tsv: 'text/tab-separated-values',
+            html: 'text/html',
+            htm: 'text/html',
+            xml: 'application/xml',
+            js: 'application/javascript',
+            ts: 'text/typescript',
+            py: 'text/x-python',
+            rb: 'text/x-ruby',
+            c: 'text/x-c',
+            cpp: 'text/x-c++src',
+            h: 'text/x-c',
+            java: 'text/x-java',
+            rs: 'text/x-rust',
+            go: 'text/x-go',
+            sh: 'application/x-sh',
+            yaml: 'application/x-yaml',
+            yml: 'application/x-yaml',
+            toml: 'application/toml',
+            png: 'image/png',
+            jpg: 'image/jpeg',
+            jpeg: 'image/jpeg',
+            gif: 'image/gif',
+            webp: 'image/webp',
+            svg: 'image/svg+xml',
+            mp3: 'audio/mpeg',
+            wav: 'audio/wav',
+            mp4: 'video/mp4',
+            zip: 'application/zip',
+            tar: 'application/x-tar',
+            gz: 'application/gzip',
+            docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        };
+        return map[ext] ?? 'application/octet-stream';
+    }
 }
 //# sourceMappingURL=openai-assistants.js.map