@promptbook/node 0.110.0-4 → 0.110.0-7

package/esm/index.es.js

@@ -17,6 +17,7 @@ import { Subject, BehaviorSubject } from 'rxjs';
 import moment from 'moment';
 import { lookup, extension } from 'mime-types';
 import { parse, unparse } from 'papaparse';
+import { Agent as Agent$1, setDefaultOpenAIClient, setDefaultOpenAIKey, fileSearchTool, tool, run } from '@openai/agents';
 import Bottleneck from 'bottleneck';
 import OpenAI from 'openai';
 
@@ -34,7 +35,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.110.0-4';
+const PROMPTBOOK_ENGINE_VERSION = '0.110.0-7';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -22358,16 +22359,11 @@ class OpenAiCompatibleExecutionTools {
             const openAiOptions = { ...this.options };
             delete openAiOptions.isVerbose;
             delete openAiOptions.userId;
-            // Enhanced configuration for better ECONNRESET handling
+            // Enhanced configuration with retries and timeouts.
             const enhancedOptions = {
                 ...openAiOptions,
                 timeout: API_REQUEST_TIMEOUT,
                 maxRetries: CONNECTION_RETRIES_LIMIT,
-                defaultHeaders: {
-                    Connection: 'keep-alive',
-                    'Keep-Alive': 'timeout=30, max=100',
-                    ...openAiOptions.defaultHeaders,
-                },
             };
             this.client = new OpenAI(enhancedOptions);
         }
@@ -23256,18 +23252,6 @@ class OpenAiExecutionTools extends OpenAiCompatibleExecutionTools {
     get profile() {
         return OPENAI_PROVIDER_PROFILE;
     }
-    /*
-    Note: Commenting this out to avoid circular dependency
-    /**
-     * Create (sub)tools for calling OpenAI API Assistants
-     *
-     * @param assistantId Which assistant to use
-     * @returns Tools for calling OpenAI API Assistants with same token
-     * /
-    public createAssistantSubtools(assistantId: string_token): OpenAiAssistantExecutionTools {
-        return new OpenAiAssistantExecutionTools({ ...this.options, assistantId });
-    }
-    */
     /**
      * List all available models (non dynamically)
      *
@@ -23295,213 +23279,1180 @@ class OpenAiExecutionTools extends OpenAiCompatibleExecutionTools {
         return this.getDefaultModel('text-embedding-3-large');
     }
     /**
-     * Default model for image generation variant.
+     * Default model for image generation variant.
+     */
+    getDefaultImageGenerationModel() {
+        return this.getDefaultModel('dall-e-3');
+    }
+}
+
+const DEFAULT_KNOWLEDGE_SOURCE_DOWNLOAD_TIMEOUT_MS = 30000;
+const DEFAULT_KNOWLEDGE_SOURCE_UPLOAD_TIMEOUT_MS = 900000;
+const VECTOR_STORE_PROGRESS_LOG_INTERVAL_MIN_MS = 15000;
+const VECTOR_STORE_STALL_LOG_THRESHOLD_MS = 30000;
+/**
+ * Base class for OpenAI execution tools that need hosted vector stores.
+ *
+ * @public exported from `@promptbook/openai`
+ */
+class OpenAiVectorStoreHandler extends OpenAiExecutionTools {
+    /**
+     * Returns the per-knowledge-source download timeout in milliseconds.
+     */
+    getKnowledgeSourceDownloadTimeoutMs() {
+        var _a;
+        return (_a = this.vectorStoreOptions.knowledgeSourceDownloadTimeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_KNOWLEDGE_SOURCE_DOWNLOAD_TIMEOUT_MS;
+    }
+    /**
+     * Returns the max concurrency for knowledge source uploads.
+     */
+    getKnowledgeSourceUploadMaxConcurrency() {
+        var _a;
+        return (_a = this.vectorStoreOptions.knowledgeSourceUploadMaxConcurrency) !== null && _a !== void 0 ? _a : 5;
+    }
+    /**
+     * Returns the polling interval in milliseconds for vector store uploads.
+     */
+    getKnowledgeSourceUploadPollIntervalMs() {
+        var _a;
+        return (_a = this.vectorStoreOptions.knowledgeSourceUploadPollIntervalMs) !== null && _a !== void 0 ? _a : 5000;
+    }
+    /**
+     * Returns the overall upload timeout in milliseconds for vector store uploads.
+     */
+    getKnowledgeSourceUploadTimeoutMs() {
+        var _a;
+        return (_a = this.vectorStoreOptions.knowledgeSourceUploadTimeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_KNOWLEDGE_SOURCE_UPLOAD_TIMEOUT_MS;
+    }
+    /**
+     * Returns true if we should continue even if vector store ingestion stalls.
+     */
+    shouldContinueOnVectorStoreStall() {
+        var _a;
+        return (_a = this.vectorStoreOptions.shouldContinueOnVectorStoreStall) !== null && _a !== void 0 ? _a : true;
+    }
+    /**
+     * Returns vector-store-specific options with extended settings.
+     */
+    get vectorStoreOptions() {
+        return this.options;
+    }
+    /**
+     * Returns the OpenAI vector stores API surface, supporting stable and beta SDKs.
+     */
+    getVectorStoresApi(client) {
+        var _a, _b;
+        const vectorStores = (_a = client.vectorStores) !== null && _a !== void 0 ? _a : (_b = client.beta) === null || _b === void 0 ? void 0 : _b.vectorStores;
+        if (!vectorStores) {
+            throw new Error('OpenAI client does not support vector stores. Please ensure you are using a compatible version of the OpenAI SDK with vector store support.');
+        }
+        return vectorStores;
+    }
+    /**
+     * Downloads a knowledge source URL into a File for vector store upload.
+     */
+    async downloadKnowledgeSourceFile(options) {
+        var _a;
+        const { source, timeoutMs, logLabel } = options;
+        const startedAtMs = Date.now();
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Downloading knowledge source', {
+                source,
+                timeoutMs,
+                logLabel,
+            });
+        }
+        try {
+            const response = await fetch(source, { signal: controller.signal });
+            const contentType = (_a = response.headers.get('content-type')) !== null && _a !== void 0 ? _a : undefined;
+            if (!response.ok) {
+                console.error('[🤰]', 'Failed to download knowledge source', {
+                    source,
+                    status: response.status,
+                    statusText: response.statusText,
+                    contentType,
+                    elapsedMs: Date.now() - startedAtMs,
+                    logLabel,
+                });
+                return null;
+            }
+            const buffer = await response.arrayBuffer();
+            let filename = source.split('/').pop() || 'downloaded-file';
+            try {
+                const url = new URL(source);
+                filename = url.pathname.split('/').pop() || filename;
+            }
+            catch (error) {
+                // Keep default filename
+            }
+            const file = new File([buffer], filename, contentType ? { type: contentType } : undefined);
+            const elapsedMs = Date.now() - startedAtMs;
+            const sizeBytes = buffer.byteLength;
+            if (this.options.isVerbose) {
+                console.info('[🤰]', 'Downloaded knowledge source', {
+                    source,
+                    filename,
+                    sizeBytes,
+                    contentType,
+                    elapsedMs,
+                    logLabel,
+                });
+            }
+            return { file, sizeBytes, filename, elapsedMs };
+        }
+        catch (error) {
+            assertsError(error);
+            console.error('[🤰]', 'Error downloading knowledge source', {
+                source,
+                elapsedMs: Date.now() - startedAtMs,
+                logLabel,
+                error: serializeError(error),
+            });
+            return null;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Logs vector store file batch diagnostics to help trace ingestion stalls or failures.
+     */
+    async logVectorStoreFileBatchDiagnostics(options) {
+        var _a, _b, _c, _d, _e;
+        const { client, vectorStoreId, batchId, uploadedFiles, logLabel, reason } = options;
+        if (reason === 'stalled' && !this.options.isVerbose) {
+            return;
+        }
+        if (!batchId.startsWith('vsfb_')) {
+            console.error('[🤰]', 'Vector store file batch diagnostics skipped (invalid batch id)', {
+                vectorStoreId,
+                batchId,
+                reason,
+                logLabel,
+            });
+            return;
+        }
+        const fileIdToMetadata = new Map();
+        for (const file of uploadedFiles) {
+            fileIdToMetadata.set(file.fileId, file);
+        }
+        try {
+            const vectorStores = this.getVectorStoresApi(client);
+            const limit = Math.min(100, Math.max(10, uploadedFiles.length));
+            const batchFilesPage = await vectorStores.fileBatches.listFiles(batchId, {
+                vector_store_id: vectorStoreId,
+                limit,
+            });
+            const batchFiles = (_a = batchFilesPage.data) !== null && _a !== void 0 ? _a : [];
+            const statusCounts = {
+                in_progress: 0,
+                completed: 0,
+                failed: 0,
+                cancelled: 0,
+            };
+            const errorSamples = [];
+            const inProgressSamples = [];
+            const batchFileIds = new Set();
+            for (const file of batchFiles) {
+                const status = (_b = file.status) !== null && _b !== void 0 ? _b : 'unknown';
+                statusCounts[status] = ((_c = statusCounts[status]) !== null && _c !== void 0 ? _c : 0) + 1;
+                const vectorStoreFileId = file.id;
+                const uploadedFileId = (_d = file.file_id) !== null && _d !== void 0 ? _d : file.fileId;
+                const fileId = uploadedFileId !== null && uploadedFileId !== void 0 ? uploadedFileId : vectorStoreFileId;
+                batchFileIds.add(fileId);
+                const metadata = fileIdToMetadata.get(fileId);
+                if (status === 'failed') {
+                    errorSamples.push({
+                        fileId,
+                        status,
+                        error: (_e = file.last_error) === null || _e === void 0 ? void 0 : _e.message,
+                        filename: metadata === null || metadata === void 0 ? void 0 : metadata.filename,
+                        vectorStoreFileId: uploadedFileId ? vectorStoreFileId : undefined,
+                    });
+                }
+                if (status === 'in_progress') {
+                    inProgressSamples.push({
+                        fileId,
+                        filename: metadata === null || metadata === void 0 ? void 0 : metadata.filename,
+                        vectorStoreFileId: uploadedFileId ? vectorStoreFileId : undefined,
+                    });
+                }
+            }
+            const missingSamples = uploadedFiles
+                .filter((file) => !batchFileIds.has(file.fileId))
+                .slice(0, 5)
+                .map((file) => ({
+                fileId: file.fileId,
+                filename: file.filename,
+                sizeBytes: file.sizeBytes,
+            }));
+            const vectorStore = await vectorStores.retrieve(vectorStoreId);
+            const logPayload = {
+                vectorStoreId,
+                batchId,
+                reason,
+                vectorStoreStatus: vectorStore.status,
+                vectorStoreFileCounts: vectorStore.file_counts,
+                vectorStoreUsageBytes: vectorStore.usage_bytes,
+                batchFileCount: batchFiles.length,
+                statusCounts,
+                errorSamples: errorSamples.slice(0, 5),
+                inProgressSamples,
+                missingFileCount: uploadedFiles.length - batchFileIds.size,
+                missingSamples,
+                logLabel,
+            };
+            const logFunction = reason === 'stalled' ? console.info : console.error;
+            logFunction('[🤰]', 'Vector store file batch diagnostics', logPayload);
+        }
+        catch (error) {
+            assertsError(error);
+            console.error('[🤰]', 'Vector store file batch diagnostics failed', {
+                vectorStoreId,
+                batchId,
+                reason,
+                logLabel,
+                error: serializeError(error),
+            });
+        }
+    }
+    /**
+     * Uploads knowledge source files to the vector store and polls until processing completes.
+     */
+    async uploadKnowledgeSourceFilesToVectorStore(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const { client, vectorStoreId, files, totalBytes, logLabel } = options;
+        const vectorStores = this.getVectorStoresApi(client);
+        const uploadStartedAtMs = Date.now();
+        const maxConcurrency = Math.max(1, this.getKnowledgeSourceUploadMaxConcurrency());
+        const pollIntervalMs = Math.max(1000, this.getKnowledgeSourceUploadPollIntervalMs());
+        const uploadTimeoutMs = Math.max(1000, this.getKnowledgeSourceUploadTimeoutMs());
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Uploading knowledge source files to OpenAI', {
+                vectorStoreId,
+                fileCount: files.length,
+                totalBytes,
+                maxConcurrency,
+                pollIntervalMs,
+                uploadTimeoutMs,
+                logLabel,
+            });
+        }
+        const fileTypeSummary = {};
+        for (const file of files) {
+            const filename = (_a = file.name) !== null && _a !== void 0 ? _a : '';
+            const extension = filename.includes('.')
+                ? (_c = (_b = filename.split('.').pop()) === null || _b === void 0 ? void 0 : _b.toLowerCase()) !== null && _c !== void 0 ? _c : 'unknown'
+                : 'unknown';
+            const sizeBytes = typeof file.size === 'number' ? file.size : 0;
+            const summary = (_d = fileTypeSummary[extension]) !== null && _d !== void 0 ? _d : { count: 0, totalBytes: 0 };
+            summary.count += 1;
+            summary.totalBytes += sizeBytes;
+            fileTypeSummary[extension] = summary;
+        }
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Knowledge source file summary', {
+                vectorStoreId,
+                fileCount: files.length,
+                totalBytes,
+                fileTypeSummary,
+                logLabel,
+            });
+        }
+        const fileEntries = files.map((file, index) => ({ file, index }));
+        const fileIterator = fileEntries.values();
+        const fileIds = [];
+        const uploadedFiles = [];
+        const failedUploads = [];
+        let uploadedCount = 0;
+        const processFiles = async (iterator) => {
+            var _a, _b;
+            for (const { file, index } of iterator) {
+                const uploadIndex = index + 1;
+                const filename = file.name || `knowledge-source-${uploadIndex}`;
+                const extension = filename.includes('.')
+                    ? (_b = (_a = filename.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : 'unknown'
+                    : 'unknown';
+                const sizeBytes = typeof file.size === 'number' ? file.size : undefined;
+                const fileUploadStartedAtMs = Date.now();
+                if (this.options.isVerbose) {
+                    console.info('[🤰]', 'Uploading knowledge source file', {
+                        index: uploadIndex,
+                        total: files.length,
+                        filename,
+                        extension,
+                        sizeBytes,
+                        logLabel,
+                    });
+                }
+                try {
+                    const uploaded = await client.files.create({ file, purpose: 'assistants' });
+                    fileIds.push(uploaded.id);
+                    uploadedFiles.push({ fileId: uploaded.id, filename, sizeBytes });
+                    uploadedCount += 1;
+                    if (this.options.isVerbose) {
+                        console.info('[🤰]', 'Uploaded knowledge source file', {
+                            index: uploadIndex,
+                            total: files.length,
+                            filename,
+                            sizeBytes,
+                            fileId: uploaded.id,
+                            elapsedMs: Date.now() - fileUploadStartedAtMs,
+                            logLabel,
+                        });
+                    }
+                }
+                catch (error) {
+                    assertsError(error);
+                    const serializedError = serializeError(error);
+                    failedUploads.push({ index: uploadIndex, filename, error: serializedError });
+                    console.error('[🤰]', 'Failed to upload knowledge source file', {
+                        index: uploadIndex,
+                        total: files.length,
+                        filename,
+                        sizeBytes,
+                        elapsedMs: Date.now() - fileUploadStartedAtMs,
+                        logLabel,
+                        error: serializedError,
+                    });
+                }
+            }
+        };
+        const workerCount = Math.min(maxConcurrency, files.length);
+        const workers = Array.from({ length: workerCount }, () => processFiles(fileIterator));
+        await Promise.all(workers);
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Finished uploading knowledge source files', {
+                vectorStoreId,
+                fileCount: files.length,
+                uploadedCount,
+                failedCount: failedUploads.length,
+                elapsedMs: Date.now() - uploadStartedAtMs,
+                failedSamples: failedUploads.slice(0, 3),
+                logLabel,
+            });
+        }
+        if (fileIds.length === 0) {
+            console.error('[🤰]', 'No knowledge source files were uploaded', {
+                vectorStoreId,
+                fileCount: files.length,
+                failedCount: failedUploads.length,
+                logLabel,
+            });
+            return null;
+        }
+        const batch = await vectorStores.fileBatches.create(vectorStoreId, {
+            file_ids: fileIds,
+        });
+        const expectedBatchId = batch.id;
+        const expectedBatchIdValid = expectedBatchId.startsWith('vsfb_');
+        if (!expectedBatchIdValid) {
+            console.error('[🤰]', 'Vector store file batch id looks invalid', {
+                vectorStoreId,
+                batchId: expectedBatchId,
+                batchVectorStoreId: batch.vector_store_id,
+                logLabel,
+            });
+        }
+        else if (batch.vector_store_id !== vectorStoreId) {
+            console.error('[🤰]', 'Vector store file batch vector store id mismatch', {
+                vectorStoreId,
+                batchId: expectedBatchId,
+                batchVectorStoreId: batch.vector_store_id,
+                logLabel,
+            });
+        }
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Created vector store file batch', {
+                vectorStoreId,
+                batchId: expectedBatchId,
+                fileCount: fileIds.length,
+                logLabel,
+            });
+        }
+        const pollStartedAtMs = Date.now();
+        const progressLogIntervalMs = Math.max(VECTOR_STORE_PROGRESS_LOG_INTERVAL_MIN_MS, pollIntervalMs);
+        const diagnosticsIntervalMs = Math.max(60000, pollIntervalMs * 5);
+        // let lastStatus: string | undefined;
+        let lastCountsKey = '';
+        let lastProgressKey = '';
+        let lastLogAtMs = 0;
+        let lastProgressAtMs = pollStartedAtMs;
+        let lastDiagnosticsAtMs = pollStartedAtMs;
+        let latestBatch = batch;
+        let loggedBatchIdMismatch = false;
+        let loggedBatchIdFallback = false;
+        let loggedBatchIdInvalid = false;
+        let shouldPoll = true;
+        while (shouldPoll) {
+            const nowMs = Date.now();
+            // [🤰] Note: Sometimes OpenAI returns Vector Store object instead of Batch object, or IDs get swapped.
+            const rawBatchId = typeof latestBatch.id === 'string' ? latestBatch.id : '';
+            const rawVectorStoreId = latestBatch.vector_store_id;
+            let returnedBatchId = rawBatchId;
+            let returnedBatchIdValid = typeof returnedBatchId === 'string' && returnedBatchId.startsWith('vsfb_');
+            if (!returnedBatchIdValid && expectedBatchIdValid) {
+                if (!loggedBatchIdFallback) {
+                    console.error('[🤰]', 'Vector store file batch id missing from response; falling back to expected', {
+                        vectorStoreId,
+                        expectedBatchId,
+                        returnedBatchId,
+                        rawVectorStoreId,
+                        logLabel,
+                    });
+                    loggedBatchIdFallback = true;
+                }
+                returnedBatchId = expectedBatchId;
+                returnedBatchIdValid = true;
+            }
+            if (!returnedBatchIdValid && !loggedBatchIdInvalid) {
+                console.error('[🤰]', 'Vector store file batch id is invalid; stopping polling', {
+                    vectorStoreId,
+                    expectedBatchId,
+                    returnedBatchId,
+                    rawVectorStoreId,
+                    logLabel,
+                });
+                loggedBatchIdInvalid = true;
+            }
+            const batchIdMismatch = expectedBatchIdValid && returnedBatchIdValid && returnedBatchId !== expectedBatchId;
+            if (batchIdMismatch && !loggedBatchIdMismatch) {
+                console.error('[🤰]', 'Vector store file batch id mismatch', {
+                    vectorStoreId,
+                    expectedBatchId,
+                    returnedBatchId,
+                    logLabel,
+                });
+                loggedBatchIdMismatch = true;
+            }
+            if (returnedBatchIdValid) {
+                latestBatch = await vectorStores.fileBatches.retrieve(returnedBatchId, {
+                    vector_store_id: vectorStoreId,
+                });
+            }
+            else {
+                shouldPoll = false;
+                continue;
+            }
+            const status = (_e = latestBatch.status) !== null && _e !== void 0 ? _e : 'unknown';
+            const fileCounts = (_f = latestBatch.file_counts) !== null && _f !== void 0 ? _f : {};
+            const progressKey = JSON.stringify(fileCounts);
+            const statusCountsKey = `${status}-${progressKey}`;
+            const isProgressing = progressKey !== lastProgressKey;
+            if (isProgressing) {
+                lastProgressAtMs = nowMs;
+                lastProgressKey = progressKey;
+            }
+            if (this.options.isVerbose &&
+                (statusCountsKey !== lastCountsKey || nowMs - lastLogAtMs >= progressLogIntervalMs)) {
+                console.info('[🤰]', 'Vector store file batch status', {
+                    vectorStoreId,
+                    batchId: returnedBatchId,
+                    status,
+                    fileCounts,
+                    elapsedMs: nowMs - pollStartedAtMs,
+                    logLabel,
+                });
+                lastCountsKey = statusCountsKey;
+                lastLogAtMs = nowMs;
+            }
+            if (status === 'in_progress' &&
+                nowMs - lastProgressAtMs >= VECTOR_STORE_STALL_LOG_THRESHOLD_MS &&
+                nowMs - lastDiagnosticsAtMs >= diagnosticsIntervalMs) {
+                lastDiagnosticsAtMs = nowMs;
+                await this.logVectorStoreFileBatchDiagnostics({
+                    client,
+                    vectorStoreId,
+                    batchId: returnedBatchId,
+                    uploadedFiles,
+                    logLabel,
+                    reason: 'stalled',
+                });
+            }
+            if (status === 'completed') {
+                if (this.options.isVerbose) {
+                    console.info('[🤰]', 'Vector store file batch completed', {
+                        vectorStoreId,
+                        batchId: returnedBatchId,
+                        fileCounts,
+                        elapsedMs: nowMs - pollStartedAtMs,
+                        logLabel,
+                    });
+                }
+                shouldPoll = false;
+                continue;
+            }
+            if (status === 'failed') {
+                console.error('[🤰]', 'Vector store file batch completed with failures', {
+                    vectorStoreId,
+                    batchId: returnedBatchId,
+                    fileCounts,
+                    elapsedMs: nowMs - pollStartedAtMs,
+                    logLabel,
+                });
+                await this.logVectorStoreFileBatchDiagnostics({
+                    client,
+                    vectorStoreId,
+                    batchId: returnedBatchId,
+                    uploadedFiles,
+                    logLabel,
+                    reason: 'failed',
+                });
+                shouldPoll = false;
+                continue;
+            }
+            if (status === 'cancelled') {
+                console.error('[🤰]', 'Vector store file batch did not complete', {
+                    vectorStoreId,
+                    batchId: returnedBatchId,
+                    status,
+                    fileCounts,
+                    elapsedMs: nowMs - pollStartedAtMs,
+                    logLabel,
+                });
+                await this.logVectorStoreFileBatchDiagnostics({
+                    client,
+                    vectorStoreId,
+                    batchId: returnedBatchId,
+                    uploadedFiles,
+                    logLabel,
+                    reason: 'failed',
+                });
+                shouldPoll = false;
+                continue;
+            }
+            if (nowMs - pollStartedAtMs >= uploadTimeoutMs) {
+                console.error('[🤰]', 'Timed out waiting for vector store file batch', {
+                    vectorStoreId,
+                    batchId: returnedBatchId,
+                    fileCounts,
+                    elapsedMs: nowMs - pollStartedAtMs,
+                    uploadTimeoutMs,
+                    logLabel,
+                });
+                await this.logVectorStoreFileBatchDiagnostics({
+                    client,
+                    vectorStoreId,
+                    batchId: returnedBatchId,
+                    uploadedFiles,
+                    logLabel,
+                    reason: 'timeout',
+                });
+                if (this.shouldContinueOnVectorStoreStall()) {
+                    console.warn('[🤰]', 'Continuing despite vector store timeout as requested', {
+                        vectorStoreId,
+                        logLabel,
+                    });
+                    shouldPoll = false;
+                    continue;
+                }
+                try {
+                    const cancelBatchId = batchIdMismatch && returnedBatchId.startsWith('vsfb_') ? returnedBatchId : expectedBatchId;
+                    if (!cancelBatchId.startsWith('vsfb_')) {
+                        console.error('[🤰]', 'Skipping vector store file batch cancel (invalid batch id)', {
+                            vectorStoreId,
+                            batchId: cancelBatchId,
+                            logLabel,
+                        });
+                    }
+                    else {
+                        await vectorStores.fileBatches.cancel(cancelBatchId, {
+                            vector_store_id: vectorStoreId,
+                        });
+                    }
+                    if (this.options.isVerbose) {
+                        console.info('[🤰]', 'Cancelled vector store file batch after timeout', {
+                            vectorStoreId,
+                            batchId: batchIdMismatch && returnedBatchId.startsWith('vsfb_')
+                                ? returnedBatchId
+                                : expectedBatchId,
+                            ...(batchIdMismatch ? { returnedBatchId } : {}),
+                            logLabel,
+                        });
+                    }
+                }
+                catch (error) {
+                    assertsError(error);
+                    console.error('[🤰]', 'Failed to cancel vector store file batch after timeout', {
+                        vectorStoreId,
+                        batchId: expectedBatchId,
+                        ...(batchIdMismatch ? { returnedBatchId } : {}),
+                        logLabel,
+                        error: serializeError(error),
+                    });
+                }
+                shouldPoll = false;
+                continue;
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        }
+        return latestBatch;
+    }
+    /**
+     * Creates a vector store and uploads knowledge sources, returning its ID.
+     */
+    async createVectorStoreWithKnowledgeSources(options) {
+        const { client, name, knowledgeSources, logLabel } = options;
+        const vectorStores = this.getVectorStoresApi(client);
+        const knowledgeSourcesCount = knowledgeSources.length;
+        const downloadTimeoutMs = this.getKnowledgeSourceDownloadTimeoutMs();
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Creating vector store with knowledge sources', {
+                name,
+                knowledgeSourcesCount,
+                downloadTimeoutMs,
+                logLabel,
+            });
+        }
+        const vectorStore = await vectorStores.create({
+            name: `${name} Knowledge Base`,
+        });
+        const vectorStoreId = vectorStore.id;
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Vector store created', {
+                vectorStoreId,
+                logLabel,
+            });
+        }
+        const fileStreams = [];
+        const skippedSources = [];
+        let totalBytes = 0;
+        const processingStartedAtMs = Date.now();
+        for (const [index, source] of knowledgeSources.entries()) {
+            try {
+                const sourceType = source.startsWith('http') || source.startsWith('https') ? 'url' : 'file';
+                if (this.options.isVerbose) {
+                    console.info('[🤰]', 'Processing knowledge source', {
+                        index: index + 1,
+                        total: knowledgeSourcesCount,
+                        source,
+                        sourceType,
+                        logLabel,
+                    });
+                }
+                // Check if it's a URL
+                if (source.startsWith('http://') || source.startsWith('https://')) {
+                    const downloadResult = await this.downloadKnowledgeSourceFile({
+                        source,
+                        timeoutMs: downloadTimeoutMs,
+                        logLabel,
+                    });
+                    if (downloadResult) {
+                        fileStreams.push(downloadResult.file);
+                        totalBytes += downloadResult.sizeBytes;
+                    }
+                    else {
+                        skippedSources.push({ source, reason: 'download_failed' });
+                    }
+                }
+                else {
+                    skippedSources.push({ source, reason: 'unsupported_source_type' });
+                    if (this.options.isVerbose) {
+                        console.info('[🤰]', 'Skipping knowledge source (unsupported type)', {
+                            source,
+                            sourceType,
+                            logLabel,
+                        });
+                    }
+                    /*
+                    TODO: [🤰] Resolve problem with browser environment
+                    // Assume it's a local file path
+                    // Note: This will work in Node.js environment
+                    // For browser environments, this would need different handling
+                    const fs = await import('fs');
+                    const fileStream = fs.createReadStream(source);
+                    fileStreams.push(fileStream);
+                    */
+                }
+            }
+            catch (error) {
+                assertsError(error);
+                skippedSources.push({ source, reason: 'processing_error' });
+                console.error('[🤰]', 'Error processing knowledge source', {
+                    source,
+                    logLabel,
+                    error: serializeError(error),
+                });
+            }
+        }
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Finished processing knowledge sources', {
+                total: knowledgeSourcesCount,
+                downloadedCount: fileStreams.length,
+                skippedCount: skippedSources.length,
+                totalBytes,
+                elapsedMs: Date.now() - processingStartedAtMs,
+                skippedSamples: skippedSources.slice(0, 3),
+                logLabel,
+            });
+        }
+        if (fileStreams.length > 0) {
+            if (this.options.isVerbose) {
+                console.info('[🤰]', 'Uploading files to vector store', {
+                    vectorStoreId,
+                    fileCount: fileStreams.length,
+                    totalBytes,
+                    maxConcurrency: this.getKnowledgeSourceUploadMaxConcurrency(),
+                    pollIntervalMs: this.getKnowledgeSourceUploadPollIntervalMs(),
+                    uploadTimeoutMs: this.getKnowledgeSourceUploadTimeoutMs(),
+                    logLabel,
+                });
+            }
+            try {
+                await this.uploadKnowledgeSourceFilesToVectorStore({
+                    client,
+                    vectorStoreId,
+                    files: fileStreams,
+                    totalBytes,
+                    logLabel,
+                });
+            }
+            catch (error) {
+                assertsError(error);
+                console.error('[🤰]', 'Error uploading files to vector store', {
+                    vectorStoreId,
+                    logLabel,
+                    error: serializeError(error),
+                });
+            }
+        }
+        else if (this.options.isVerbose) {
+            console.info('[🤰]', 'No knowledge source files to upload', {
+                vectorStoreId,
+                skippedCount: skippedSources.length,
+                logLabel,
+            });
+        }
+        return {
+            vectorStoreId,
+            uploadedFileCount: fileStreams.length,
+            skippedCount: skippedSources.length,
+            totalBytes,
+        };
+    }
+}
+
+const DEFAULT_AGENT_KIT_MODEL_NAME = 'gpt-5.2';
+/**
+ * Execution tools for OpenAI AgentKit (Agents SDK).
+ *
+ * @public exported from `@promptbook/openai`
+ */
+class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandler {
+    /**
+     * Creates OpenAI AgentKit execution tools.
+     */
+    constructor(options) {
+        var _a;
+        if (options.isProxied) {
+            throw new NotYetImplementedError(`Proxy mode is not yet implemented for OpenAI AgentKit`);
+        }
+        super(options);
+        this.preparedAgentKitAgent = null;
+        this.agentKitModelName = (_a = options.agentKitModelName) !== null && _a !== void 0 ? _a : DEFAULT_AGENT_KIT_MODEL_NAME;
+    }
+    get title() {
+        return 'OpenAI AgentKit';
+    }
+    get description() {
+        return 'Use OpenAI AgentKit for agent-style chat with tools and knowledge';
+    }
+    /**
+     * Calls OpenAI AgentKit with a chat prompt (non-streaming).
+     */
+    async callChatModel(prompt) {
+        return this.callChatModelStream(prompt, () => { });
+    }
+    /**
+     * Calls OpenAI AgentKit with a chat prompt (streaming).
+     */
+    async callChatModelStream(prompt, onProgress) {
+        const { content, parameters, modelRequirements } = prompt;
+        if (modelRequirements.modelVariant !== 'CHAT') {
+            throw new PipelineExecutionError('Use callChatModel only for CHAT variant');
+        }
+        for (const key of ['maxTokens', 'modelName', 'seed', 'temperature']) {
+            if (modelRequirements[key] !== undefined) {
+                throw new NotYetImplementedError(`In \`OpenAiAgentKitExecutionTools\` you cannot specify \`${key}\``);
+            }
+        }
+        const rawPromptContent = templateParameters(content, {
+            ...parameters,
+            modelName: this.agentKitModelName,
+        });
+        const preparedAgentKitAgent = await this.prepareAgentKitAgent({
+            name: (prompt.title || 'Agent'),
+            instructions: modelRequirements.systemMessage || '',
+            knowledgeSources: modelRequirements.knowledgeSources,
+            tools: 'tools' in prompt && Array.isArray(prompt.tools) ? prompt.tools : modelRequirements.tools,
+        });
+        return this.callChatModelStreamWithPreparedAgent({
+            openAiAgentKitAgent: preparedAgentKitAgent.agent,
+            prompt,
+            rawPromptContent,
+            onProgress,
+        });
+    }
+    /**
+     * Returns a prepared AgentKit agent when the server wants to manage caching externally.
+     */
+    getPreparedAgentKitAgent() {
+        return this.preparedAgentKitAgent;
+    }
+    /**
+     * Stores a prepared AgentKit agent for later reuse by external cache managers.
+     */
+    setPreparedAgentKitAgent(preparedAgent) {
+        this.preparedAgentKitAgent = preparedAgent;
+    }
+    /**
+     * Creates a new tools instance bound to a prepared AgentKit agent.
+     */
+    getPreparedAgentTools(preparedAgent) {
+        const tools = new OpenAiAgentKitExecutionTools(this.agentKitOptions);
+        tools.setPreparedAgentKitAgent(preparedAgent);
+        return tools;
+    }
+    /**
+     * Prepares an AgentKit agent with optional knowledge sources and tool definitions.
+     */
+    async prepareAgentKitAgent(options) {
+        var _a, _b;
+        const { name, instructions, knowledgeSources, tools, vectorStoreId: cachedVectorStoreId, storeAsPrepared, } = options;
+        await this.ensureAgentKitDefaults();
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'Preparing OpenAI AgentKit agent', {
+                name,
+                instructionsLength: instructions.length,
+                knowledgeSourcesCount: (_a = knowledgeSources === null || knowledgeSources === void 0 ? void 0 : knowledgeSources.length) !== null && _a !== void 0 ? _a : 0,
+                toolsCount: (_b = tools === null || tools === void 0 ? void 0 : tools.length) !== null && _b !== void 0 ? _b : 0,
+            });
+        }
+        let vectorStoreId = cachedVectorStoreId;
+        if (!vectorStoreId && knowledgeSources && knowledgeSources.length > 0) {
+            const vectorStoreResult = await this.createVectorStoreWithKnowledgeSources({
+                client: await this.getClient(),
+                name,
+                knowledgeSources,
+                logLabel: 'agentkit preparation',
+            });
+            vectorStoreId = vectorStoreResult.vectorStoreId;
+        }
+        else if (vectorStoreId && this.options.isVerbose) {
+            console.info('[🤰]', 'Using cached vector store for AgentKit agent', {
+                name,
+                vectorStoreId,
+            });
+        }
+        const agentKitTools = this.buildAgentKitTools({ tools, vectorStoreId });
+        const openAiAgentKitAgent = new Agent$1({
+            name,
+            model: this.agentKitModelName,
+            instructions: instructions || 'You are a helpful assistant.',
+            tools: agentKitTools,
+        });
+        const preparedAgent = {
+            agent: openAiAgentKitAgent,
+            vectorStoreId,
+        };
+        if (storeAsPrepared) {
+            this.setPreparedAgentKitAgent(preparedAgent);
+        }
+        if (this.options.isVerbose) {
+            console.info('[🤰]', 'OpenAI AgentKit agent ready', {
+                name,
+                model: this.agentKitModelName,
+                toolCount: agentKitTools.length,
+                hasVectorStore: Boolean(vectorStoreId),
+            });
+        }
+        return preparedAgent;
+    }
+    /**
+     * Ensures the AgentKit SDK is wired to the OpenAI client and API key.
+     */
+    async ensureAgentKitDefaults() {
+        const client = await this.getClient();
+        setDefaultOpenAIClient(client);
+        const apiKey = this.agentKitOptions.apiKey;
+        if (apiKey && typeof apiKey === 'string') {
+            setDefaultOpenAIKey(apiKey);
+        }
+    }
+    /**
+     * Builds the tool list for AgentKit, including hosted file search when applicable.
+     */
+    buildAgentKitTools(options) {
+        var _a;
+        const { tools, vectorStoreId } = options;
+        const agentKitTools = [];
+        if (vectorStoreId) {
+            agentKitTools.push(fileSearchTool(vectorStoreId));
+        }
+        if (tools && tools.length > 0) {
+            const scriptTools = this.resolveScriptTools();
+            for (const toolDefinition of tools) {
+                agentKitTools.push(tool({
+                    name: toolDefinition.name,
+                    description: toolDefinition.description,
+                    parameters: toolDefinition.parameters
+                        ? {
+                            ...toolDefinition.parameters,
+                            additionalProperties: false,
+                            required: (_a = toolDefinition.parameters.required) !== null && _a !== void 0 ? _a : [],
+                        }
+                        : undefined,
+                    strict: false,
+                    execute: async (input, runContext, details) => {
+                        var _a, _b, _c;
+                        const scriptTool = scriptTools[0];
+                        const functionName = toolDefinition.name;
+                        const calledAt = $getCurrentDate();
+                        const callId = (_a = details === null || details === void 0 ? void 0 : details.toolCall) === null || _a === void 0 ? void 0 : _a.callId;
+                        const functionArgs = input !== null && input !== void 0 ? input : {};
+                        if (this.options.isVerbose) {
+                            console.info('[🤰]', 'Executing AgentKit tool', {
+                                functionName,
+                                callId,
+                                calledAt,
+                            });
+                        }
+                        try {
+                            return await scriptTool.execute({
+                                scriptLanguage: 'javascript',
+                                script: `
+                                        const args = ${JSON.stringify(functionArgs)};
+                                        return await ${functionName}(args);
+                                    `,
+                                parameters: (_c = (_b = runContext === null || runContext === void 0 ? void 0 : runContext.context) === null || _b === void 0 ? void 0 : _b.parameters) !== null && _c !== void 0 ? _c : {},
+                            });
+                        }
+                        catch (error) {
+                            assertsError(error);
+                            const serializedError = serializeError(error);
+                            const errorMessage = spaceTrim$2((block) => `
+
+                                        The invoked tool \`${functionName}\` failed with error:
+
+                                        \`\`\`json
+                                        ${block(JSON.stringify(serializedError, null, 4))}
+                                        \`\`\`
+
+                                    `);
+                            console.error('[🤰]', 'AgentKit tool execution failed', {
+                                functionName,
+                                callId,
+                                error: serializedError,
+                            });
+                            return errorMessage;
+                        }
+                    },
+                }));
+            }
+        }
+        return agentKitTools;
+    }
+    /**
+     * Resolves the configured script tools for tool execution.
      */
-    getDefaultImageGenerationModel() {
-        return this.getDefaultModel('dall-e-3');
-    }
-}
-
-/**
- * Execution Tools for calling OpenAI API using the Responses API (Agents)
- *
- * @public exported from `@promptbook/openai`
- */
-class OpenAiAgentExecutionTools extends OpenAiExecutionTools {
-    constructor(options) {
-        super(options);
-        this.vectorStoreId = options.vectorStoreId;
-    }
-    get title() {
-        return 'OpenAI Agent';
-    }
-    get description() {
-        return 'Use OpenAI Responses API (Agentic)';
+    resolveScriptTools() {
+        const executionTools = this.options.executionTools;
+        if (!executionTools || !executionTools.script) {
+            throw new PipelineExecutionError(`Model requested tools but no executionTools.script were provided in OpenAiAgentKitExecutionTools options`);
+        }
+        return Array.isArray(executionTools.script) ? executionTools.script : [executionTools.script];
     }
     /**
-     * Calls OpenAI API to use a chat model with streaming.
+     * Runs a prepared AgentKit agent and streams results back to the caller.
      */
-    async callChatModelStream(prompt, onProgress) {
-        if (this.options.isVerbose) {
-            console.info('💬 OpenAI Agent callChatModel call', { prompt });
-        }
-        const { content, parameters, modelRequirements } = prompt;
-        const client = await this.getClient();
-        if (modelRequirements.modelVariant !== 'CHAT') {
-            throw new PipelineExecutionError('Use callChatModel only for CHAT variant');
-        }
-        const rawPromptContent = templateParameters(content, {
-            ...parameters,
-            modelName: 'agent',
-        });
-        // Build input items
-        const input = []; // TODO: Type properly when OpenAI types are updated
-        // Add previous messages from thread (if any)
-        if ('thread' in prompt && Array.isArray(prompt.thread)) {
-            const previousMessages = prompt.thread.map((msg) => ({
-                role: msg.sender === 'assistant' ? 'assistant' : 'user',
-                content: msg.content,
-            }));
-            input.push(...previousMessages);
-        }
-        // Add current user message
-        input.push({
-            role: 'user',
-            content: rawPromptContent,
+    async callChatModelStreamWithPreparedAgent(options) {
+        var _a, _b, _c, _d;
+        const { openAiAgentKitAgent, prompt, onProgress } = options;
+        const rawPromptContent = (_a = options.rawPromptContent) !== null && _a !== void 0 ? _a : templateParameters(prompt.content, {
+            ...prompt.parameters,
+            modelName: this.agentKitModelName,
         });
-        // Prepare tools
-        const tools = modelRequirements.tools ? mapToolsToOpenAi(modelRequirements.tools) : undefined;
-        // Add file_search if vector store is present
-        const agentTools = tools ? [...tools] : [];
-        let toolResources = undefined;
-        if (this.vectorStoreId) {
-            agentTools.push({ type: 'file_search' });
-            toolResources = {
-                file_search: {
-                    vector_store_ids: [this.vectorStoreId],
-                },
-            };
-        }
-        // Add file_search also if knowledgeSources are present in the prompt (passed via AgentLlmExecutionTools)
-        if (modelRequirements.knowledgeSources &&
-            modelRequirements.knowledgeSources.length > 0 &&
-            !this.vectorStoreId) {
-            // Note: Vector store should have been created by AgentLlmExecutionTools and passed via options.
-            // If we are here, it means we have knowledge sources but no vector store ID.
-            // We can't easily create one here without persisting it.
-            console.warn('Knowledge sources provided but no vector store ID. Creating temporary vector store is not implemented in callChatModelStream.');
-        }
         const start = $getCurrentDate();
-        // Construct the request
+        let latestContent = '';
+        const toolCalls = [];
+        const toolCallIndexById = new Map();
+        const inputItems = await this.buildAgentKitInputItems(prompt, rawPromptContent);
         const rawRequest = {
-            // TODO: Type properly as OpenAI.Responses.CreateResponseParams
-            model: modelRequirements.modelName || 'gpt-4o',
-            input,
-            instructions: modelRequirements.systemMessage,
-            tools: agentTools.length > 0 ? agentTools : undefined,
-            tool_resources: toolResources,
-            store: false, // Stateless by default as we pass full history
+            agentName: openAiAgentKitAgent.name,
+            input: inputItems,
         };
-        if (this.options.isVerbose) {
-            console.info(colors.bgWhite('rawRequest (Responses API)'), JSON.stringify(rawRequest, null, 4));
-        }
-        // Call Responses API
-        // Note: Using any cast because types might not be updated yet
-        const response = await client.responses.create(rawRequest);
-        if (this.options.isVerbose) {
-            console.info(colors.bgWhite('rawResponse'), JSON.stringify(response, null, 4));
-        }
-        const complete = $getCurrentDate();
-        let resultContent = '';
-        const toolCalls = [];
-        // Parse output items
-        if (response.output) {
-            for (const item of response.output) {
-                if (item.type === 'message' && item.role === 'assistant') {
-                    for (const contentPart of item.content) {
-                        if (contentPart.type === 'output_text') {
-                            // "output_text" based on migration guide, or "text"? Guide says "output_text" in example.
-                            resultContent += contentPart.text;
-                        }
-                        else if (contentPart.type === 'text') {
-                            resultContent += contentPart.text.value || contentPart.text;
-                        }
+        const streamResult = await run(openAiAgentKitAgent, inputItems, {
+            stream: true,
+            context: { parameters: prompt.parameters },
+        });
+        for await (const event of streamResult) {
+            if (event.type === 'raw_model_stream_event' && ((_b = event.data) === null || _b === void 0 ? void 0 : _b.type) === 'output_text_delta') {
+                latestContent += event.data.delta;
+                onProgress({
+                    content: latestContent,
+                    modelName: this.agentKitModelName,
+                    timing: { start, complete: $getCurrentDate() },
+                    usage: UNCERTAIN_USAGE,
+                    rawPromptContent: rawPromptContent,
+                    rawRequest: null,
+                    rawResponse: {},
+                });
+                continue;
+            }
+            if (event.type === 'run_item_stream_event') {
+                const rawItem = (_c = event.item) === null || _c === void 0 ? void 0 : _c.rawItem;
+                if (event.name === 'tool_called' && (rawItem === null || rawItem === void 0 ? void 0 : rawItem.type) === 'function_call') {
+                    const toolCall = {
+                        name: rawItem.name,
+                        arguments: rawItem.arguments,
+                        rawToolCall: rawItem,
+                        createdAt: $getCurrentDate(),
+                    };
+                    toolCallIndexById.set(rawItem.callId, toolCalls.length);
+                    toolCalls.push(toolCall);
+                    onProgress({
+                        content: latestContent,
+                        modelName: this.agentKitModelName,
+                        timing: { start, complete: $getCurrentDate() },
+                        usage: UNCERTAIN_USAGE,
+                        rawPromptContent: rawPromptContent,
+                        rawRequest: null,
+                        rawResponse: {},
+                        toolCalls: [toolCall],
+                    });
+                }
+                if (event.name === 'tool_output' && (rawItem === null || rawItem === void 0 ? void 0 : rawItem.type) === 'function_call_result') {
+                    const index = toolCallIndexById.get(rawItem.callId);
+                    const result = this.formatAgentKitToolOutput(rawItem.output);
+                    if (index !== undefined) {
+                        const existingToolCall = toolCalls[index];
+                        const completedToolCall = {
+                            ...existingToolCall,
+                            result,
+                            rawToolCall: rawItem,
+                        };
+                        toolCalls[index] = completedToolCall;
+                        onProgress({
+                            content: latestContent,
+                            modelName: this.agentKitModelName,
+                            timing: { start, complete: $getCurrentDate() },
+                            usage: UNCERTAIN_USAGE,
+                            rawPromptContent: rawPromptContent,
+                            rawRequest: null,
+                            rawResponse: {},
+                            toolCalls: [completedToolCall],
+                        });
                     }
                 }
-                else if (item.type === 'function_call') ;
             }
         }
-        // Use output_text helper if available (mentioned in guide)
-        if (response.output_text) {
-            resultContent = response.output_text;
-        }
-        // TODO: Handle tool calls properly (Requires clearer docs or experimentation)
-        onProgress({
-            content: resultContent,
-            modelName: response.model || 'agent',
+        await streamResult.completed;
+        const complete = $getCurrentDate();
+        const finalContent = ((_d = streamResult.finalOutput) !== null && _d !== void 0 ? _d : latestContent);
+        const finalResult = {
+            content: finalContent,
+            modelName: this.agentKitModelName,
             timing: { start, complete },
             usage: UNCERTAIN_USAGE,
-            rawPromptContent,
+            rawPromptContent: rawPromptContent,
             rawRequest,
-            rawResponse: response,
-        });
-        return exportJson({
-            name: 'promptResult',
-            message: `Result of \`OpenAiAgentExecutionTools.callChatModelStream\``,
-            order: [],
-            value: {
-                content: resultContent,
-                modelName: response.model || 'agent',
-                timing: { start, complete },
-                usage: UNCERTAIN_USAGE,
-                rawPromptContent,
-                rawRequest,
-                rawResponse: response,
-                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-            },
-        });
+            rawResponse: { runResult: streamResult },
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        };
+        onProgress(finalResult);
+        return finalResult;
     }
     /**
-     * Creates a vector store from knowledge sources
+     * Builds AgentKit input items from the prompt and optional thread.
      */
-    static async createVectorStore(client, name, knowledgeSources) {
-        // Create a vector store
-        const vectorStore = await client.beta.vectorStores.create({
-            name: `${name} Knowledge Base`,
-        });
-        const vectorStoreId = vectorStore.id;
-        // Upload files from knowledge sources to the vector store
-        const fileStreams = [];
-        for (const source of knowledgeSources) {
-            try {
-                // Check if it's a URL
-                if (source.startsWith('http://') || source.startsWith('https://')) {
-                    // Download the file
-                    const response = await fetch(source);
-                    if (!response.ok) {
-                        console.error(`Failed to download ${source}: ${response.statusText}`);
-                        continue;
-                    }
-                    const buffer = await response.arrayBuffer();
-                    const filename = source.split('/').pop() || 'downloaded-file';
-                    const blob = new Blob([buffer]);
-                    const file = new File([blob], filename);
-                    fileStreams.push(file);
+    async buildAgentKitInputItems(prompt, rawPromptContent) {
+        var _a;
+        const inputItems = [];
+        if ('thread' in prompt && Array.isArray(prompt.thread)) {
+            for (const message of prompt.thread) {
+                const sender = message.sender;
+                const content = (_a = message.content) !== null && _a !== void 0 ? _a : '';
+                if (sender === 'assistant' || sender === 'agent') {
+                    inputItems.push({
+                        role: 'assistant',
+                        status: 'completed',
+                        content: [{ type: 'output_text', text: content }],
+                    });
                 }
                 else {
-                    // Local files not supported in browser env easily, same as before
+                    inputItems.push({
+                        role: 'user',
+                        content,
+                    });
                 }
             }
-            catch (error) {
-                console.error(`Error processing knowledge source ${source}:`, error);
-            }
         }
-        // Batch upload files to the vector store
-        if (fileStreams.length > 0) {
-            try {
-                await client.beta.vectorStores.fileBatches.uploadAndPoll(vectorStoreId, {
-                    files: fileStreams,
-                });
-            }
-            catch (error) {
-                console.error('Error uploading files to vector store:', error);
+        const userContent = await this.buildAgentKitUserContent(prompt, rawPromptContent);
+        inputItems.push({
+            role: 'user',
+            content: userContent,
+        });
+        return inputItems;
+    }
+    /**
+     * Builds the user message content for AgentKit runs, including file inputs when provided.
+     */
+    async buildAgentKitUserContent(prompt, rawPromptContent) {
+        if ('files' in prompt && Array.isArray(prompt.files) && prompt.files.length > 0) {
+            const fileItems = await Promise.all(prompt.files.map(async (file) => {
+                const arrayBuffer = await file.arrayBuffer();
+                const base64 = Buffer.from(arrayBuffer).toString('base64');
+                return {
+                    type: 'input_image',
+                    image: `data:${file.type};base64,${base64}`,
+                };
+            }));
+            return [{ type: 'input_text', text: rawPromptContent }, ...fileItems];
+        }
+        return rawPromptContent;
+    }
+    /**
+     * Normalizes AgentKit tool outputs into a string for Promptbook tool call results.
+     */
+    formatAgentKitToolOutput(output) {
+        if (typeof output === 'string') {
+            return output;
+        }
+        if (output && typeof output === 'object') {
+            const textOutput = output;
+            if (textOutput.type === 'text' && typeof textOutput.text === 'string') {
+                return textOutput.text;
             }
         }
-        return vectorStoreId;
+        return JSON.stringify(output !== null && output !== void 0 ? output : null);
     }
     /**
-     * Discriminant for type guards
+     * Returns AgentKit-specific options.
+     */
+    get agentKitOptions() {
+        return this.options;
+    }
+    /**
+     * Discriminant for type guards.
      */
     get discriminant() {
-        return 'OPEN_AI_AGENT';
+        return DISCRIMINANT$1;
     }
     /**
-     * Type guard to check if given `LlmExecutionTools` are instanceof `OpenAiAgentExecutionTools`
+     * Type guard to check if given `LlmExecutionTools` are instanceof `OpenAiAgentKitExecutionTools`.
      */
-    static isOpenAiAgentExecutionTools(llmExecutionTools) {
-        return llmExecutionTools.discriminant === 'OPEN_AI_AGENT';
+    static isOpenAiAgentKitExecutionTools(llmExecutionTools) {
+        return llmExecutionTools.discriminant === DISCRIMINANT$1;
     }
 }
+/**
+ * Discriminant for type guards.
+ *
+ * @private const of `OpenAiAgentKitExecutionTools`
+ */
+const DISCRIMINANT$1 = 'OPEN_AI_AGENT_KIT_V1';
 
 /**
  * Uploads files to OpenAI and returns their IDs
@@ -23536,10 +24487,10 @@ async function uploadFilesToOpenAi(client, files) {
  * - `OpenAiAssistantExecutionTools` - which is a specific implementation of `LlmExecutionTools` for OpenAI models with assistant capabilities, recommended for usage in `Agent` or `AgentLlmExecutionTools`
  * - `RemoteAgent` - which is an `Agent` that connects to a Promptbook Agents Server
  *
+ * @deprecated Use `OpenAiAgentKitExecutionTools` instead.
  * @public exported from `@promptbook/openai`
- * @deprecated Use `OpenAiAgentExecutionTools` instead which uses the new OpenAI Responses API
  */
-class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
+class OpenAiAssistantExecutionTools extends OpenAiVectorStoreHandler {
     /**
      * Creates OpenAI Execution Tools.
      *
@@ -23668,8 +24619,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
                 console.info(colors.bgWhite('rawRequest (non-streaming with tools)'), JSON.stringify(rawRequest, null, 4));
             }
             // Create thread and run
-            const threadAndRun = await client.beta.threads.createAndRun(rawRequest);
-            let run = threadAndRun;
+            let run = (await client.beta.threads.createAndRun(rawRequest));
             const completedToolCalls = [];
             const toolCallStartedAt = new Map();
             // Poll until run completes or requires action
@@ -23764,14 +24714,14 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
                         }
                     }
                     // Submit tool outputs
-                    run = await client.beta.threads.runs.submitToolOutputs(run.thread_id, run.id, {
+                    run = (await client.beta.threads.runs.submitToolOutputs(run.thread_id, run.id, {
                         tool_outputs: toolOutputs,
-                    });
+                    }));
                 }
                 else {
                     // Wait a bit before polling again
                     await new Promise((resolve) => setTimeout(resolve, 500));
-                    run = await client.beta.threads.runs.retrieve(run.thread_id, run.id);
+                    run = (await client.beta.threads.runs.retrieve(run.thread_id, run.id));
                 }
             }
             if (run.status !== 'completed') {
@@ -23996,88 +24946,13 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         let vectorStoreId;
         // If knowledge sources are provided, create a vector store with them
         if (knowledgeSources && knowledgeSources.length > 0) {
-            if (this.options.isVerbose) {
-                console.info('[🤰]', 'Creating vector store with knowledge sources', {
-                    name,
-                    knowledgeSourcesCount,
-                });
-            }
-            // Create a vector store
-            const vectorStore = await client.beta.vectorStores.create({
-                name: `${name} Knowledge Base`,
+            const vectorStoreResult = await this.createVectorStoreWithKnowledgeSources({
+                client,
+                name,
+                knowledgeSources,
+                logLabel: 'assistant creation',
             });
-            vectorStoreId = vectorStore.id;
-            if (this.options.isVerbose) {
-                console.info('[🤰]', 'Vector store created', {
-                    vectorStoreId,
-                });
-            }
-            // Upload files from knowledge sources to the vector store
-            const fileStreams = [];
-            for (const [index, source] of knowledgeSources.entries()) {
-                try {
-                    if (this.options.isVerbose) {
-                        console.info('[🤰]', 'Processing knowledge source', {
-                            index: index + 1,
-                            total: knowledgeSources.length,
-                            source,
-                            sourceType: source.startsWith('http') || source.startsWith('https') ? 'url' : 'file',
-                        });
-                    }
-                    // Check if it's a URL
-                    if (source.startsWith('http://') || source.startsWith('https://')) {
-                        // Download the file
-                        const response = await fetch(source);
-                        if (!response.ok) {
-                            console.error(`Failed to download ${source}: ${response.statusText}`);
-                            continue;
-                        }
-                        const buffer = await response.arrayBuffer();
-                        let filename = source.split('/').pop() || 'downloaded-file';
-                        try {
-                            const url = new URL(source);
-                            filename = url.pathname.split('/').pop() || filename;
-                        }
-                        catch (error) {
-                            // Keep default filename
-                        }
-                        const blob = new Blob([buffer]);
-                        const file = new File([blob], filename);
-                        fileStreams.push(file);
-                    }
-                    else {
-                        /*
-                        TODO: [🐱‍🚀] Resolve problem with browser environment
-                        // Assume it's a local file path
-                        // Note: This will work in Node.js environment
-                        // For browser environments, this would need different handling
-                        const fs = await import('fs');
-                        const fileStream = fs.createReadStream(source);
-                        fileStreams.push(fileStream);
-                        */
-                    }
-                }
-                catch (error) {
-                    console.error(`Error processing knowledge source ${source}:`, error);
-                }
-            }
-            // Batch upload files to the vector store
-            if (fileStreams.length > 0) {
-                try {
-                    await client.beta.vectorStores.fileBatches.uploadAndPoll(vectorStoreId, {
-                        files: fileStreams,
-                    });
-                    if (this.options.isVerbose) {
-                        console.info('[🤰]', 'Uploaded files to vector store', {
-                            vectorStoreId,
-                            fileCount: fileStreams.length,
-                        });
-                    }
-                }
-                catch (error) {
-                    console.error('Error uploading files to vector store:', error);
-                }
-            }
+            vectorStoreId = vectorStoreResult.vectorStoreId;
         }
         // Create assistant with vector store attached
         const assistantConfig = {
@@ -24144,91 +25019,14 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         const client = await this.getClient();
         let vectorStoreId;
         // If knowledge sources are provided, create a vector store with them
-        // TODO: [🧠] Reuse vector store creation logic from createNewAssistant
         if (knowledgeSources && knowledgeSources.length > 0) {
-            if (this.options.isVerbose) {
-                console.info('[🤰]', 'Creating vector store for assistant update', {
-                    assistantId,
-                    name,
-                    knowledgeSourcesCount,
-                });
-            }
-            // Create a vector store
-            const vectorStore = await client.beta.vectorStores.create({
-                name: `${name} Knowledge Base`,
+            const vectorStoreResult = await this.createVectorStoreWithKnowledgeSources({
+                client,
+                name: name !== null && name !== void 0 ? name : assistantId,
+                knowledgeSources,
+                logLabel: 'assistant update',
             });
-            vectorStoreId = vectorStore.id;
-            if (this.options.isVerbose) {
-                console.info('[🤰]', 'Vector store created for assistant update', {
-                    vectorStoreId,
-                });
-            }
-            // Upload files from knowledge sources to the vector store
-            const fileStreams = [];
-            for (const [index, source] of knowledgeSources.entries()) {
-                try {
-                    if (this.options.isVerbose) {
-                        console.info('[🤰]', 'Processing knowledge source for update', {
-                            index: index + 1,
-                            total: knowledgeSources.length,
-                            source,
-                            sourceType: source.startsWith('http') || source.startsWith('https') ? 'url' : 'file',
-                        });
-                    }
-                    // Check if it's a URL
-                    if (source.startsWith('http://') || source.startsWith('https://')) {
-                        // Download the file
-                        const response = await fetch(source);
-                        if (!response.ok) {
-                            console.error(`Failed to download ${source}: ${response.statusText}`);
-                            continue;
-                        }
-                        const buffer = await response.arrayBuffer();
-                        let filename = source.split('/').pop() || 'downloaded-file';
-                        try {
-                            const url = new URL(source);
-                            filename = url.pathname.split('/').pop() || filename;
-                        }
-                        catch (error) {
-                            // Keep default filename
-                        }
-                        const blob = new Blob([buffer]);
-                        const file = new File([blob], filename);
-                        fileStreams.push(file);
-                    }
-                    else {
-                        /*
-                        TODO: [🐱‍🚀] Resolve problem with browser environment
-                        // Assume it's a local file path
-                        // Note: This will work in Node.js environment
-                        // For browser environments, this would need different handling
-                        const fs = await import('fs');
-                        const fileStream = fs.createReadStream(source);
-                        fileStreams.push(fileStream);
-                        */
-                    }
-                }
-                catch (error) {
-                    console.error(`Error processing knowledge source ${source}:`, error);
-                }
-            }
-            // Batch upload files to the vector store
-            if (fileStreams.length > 0) {
-                try {
-                    await client.beta.vectorStores.fileBatches.uploadAndPoll(vectorStoreId, {
-                        files: fileStreams,
-                    });
-                    if (this.options.isVerbose) {
-                        console.info('[🤰]', 'Uploaded files to vector store for update', {
-                            vectorStoreId,
-                            fileCount: fileStreams.length,
-                        });
-                    }
-                }
-                catch (error) {
-                    console.error('Error uploading files to vector store:', error);
-                }
-            }
+            vectorStoreId = vectorStoreResult.vectorStoreId;
         }
         const assistantUpdate = {
             name,
@@ -24332,8 +25130,8 @@ function emitAssistantPreparationProgress(options) {
  * - `Agent` - which represents an AI Agent with its source, memories, actions, etc. Agent is a higher-level abstraction which is internally using:
  * - `LlmExecutionTools` - which wraps one or more LLM models and provides an interface to execute them
  * - `AgentLlmExecutionTools` - which is a specific implementation of `LlmExecutionTools` that wraps another LlmExecutionTools and applies agent-specific system prompts and requirements
- * - `OpenAiAgentExecutionTools` - which is a specific implementation of `LlmExecutionTools` for OpenAI models with agent capabilities (using Responses API), recommended for usage in `Agent` or `AgentLlmExecutionTools`
  * - `OpenAiAssistantExecutionTools` - (Deprecated) which is a specific implementation of `LlmExecutionTools` for OpenAI models with assistant capabilities
+ * - `OpenAiAgentKitExecutionTools` - which is a specific implementation of `LlmExecutionTools` backed by OpenAI AgentKit
  * - `RemoteAgent` - which is an `Agent` that connects to a Promptbook Agents Server
  *
  * @public exported from `@promptbook/core`
@@ -24468,6 +25266,7 @@ class AgentLlmExecutionTools {
      * Calls the chat model with agent-specific system prompt and requirements with streaming
      */
     async callChatModelStream(prompt, onProgress) {
+        var _a, _b;
         // Ensure we're working with a chat prompt
         if (prompt.modelRequirements.modelVariant !== 'CHAT') {
             throw new Error('AgentLlmExecutionTools only supports chat prompts');
@@ -24495,63 +25294,73 @@ class AgentLlmExecutionTools {
             }, // Cast to avoid readonly mismatch from spread
         };
         console.log('!!!! promptWithAgentModelRequirements:', promptWithAgentModelRequirements);
-        if (OpenAiAgentExecutionTools.isOpenAiAgentExecutionTools(this.options.llmTools)) {
+        if (OpenAiAgentKitExecutionTools.isOpenAiAgentKitExecutionTools(this.options.llmTools)) {
             const requirementsHash = SHA256(JSON.stringify(modelRequirements)).toString();
-            const cached = AgentLlmExecutionTools.vectorStoreCache.get(this.title);
-            let agentTools;
-            if (cached && cached.requirementsHash === requirementsHash) {
+            const vectorStoreHash = SHA256(JSON.stringify((_a = modelRequirements.knowledgeSources) !== null && _a !== void 0 ? _a : [])).toString();
+            const cachedVectorStore = AgentLlmExecutionTools.vectorStoreCache.get(this.title);
+            const cachedAgentKit = AgentLlmExecutionTools.agentKitAgentCache.get(this.title);
+            let preparedAgentKit = this.options.assistantPreparationMode === 'external'
+                ? this.options.llmTools.getPreparedAgentKitAgent()
+                : null;
+            const vectorStoreId = (preparedAgentKit === null || preparedAgentKit === void 0 ? void 0 : preparedAgentKit.vectorStoreId) ||
+                (cachedVectorStore && cachedVectorStore.requirementsHash === vectorStoreHash
+                    ? cachedVectorStore.vectorStoreId
+                    : undefined);
+            if (!preparedAgentKit && cachedAgentKit && cachedAgentKit.requirementsHash === requirementsHash) {
                 if (this.options.isVerbose) {
-                    console.log(`1️⃣ Using cached OpenAI Agent Vector Store for agent ${this.title}...`);
+                    console.info('[🤰]', 'Using cached OpenAI AgentKit agent', {
+                        agent: this.title,
+                    });
                 }
-                // Create new instance with cached vectorStoreId
-                // We need to access options from the original tool.
-                // We assume isOpenAiAgentExecutionTools implies it has options we can clone.
-                // But protected options are not accessible.
-                // We can cast to access options if they were public, or use a method to clone.
-                // OpenAiAgentExecutionTools doesn't have a clone method.
-                // However, we can just assume the passed tool *might* not have the vector store yet, or we are replacing it.
-                // Actually, if the passed tool IS OpenAiAgentExecutionTools, we should use it as a base.
-                // TODO: [🧠] This is a bit hacky, accessing protected options or recreating tools.
-                // Ideally OpenAiAgentExecutionTools should have a method `withVectorStoreId`.
-                agentTools = new OpenAiAgentExecutionTools({
-                    ...this.options.llmTools.options,
-                    vectorStoreId: cached.vectorStoreId,
-                });
+                preparedAgentKit = {
+                    agent: cachedAgentKit.agent,
+                    vectorStoreId: cachedAgentKit.vectorStoreId,
+                };
             }
-            else {
+            if (!preparedAgentKit) {
                 if (this.options.isVerbose) {
-                    console.log(`1️⃣ Creating/Updating OpenAI Agent Vector Store for agent ${this.title}...`);
-                }
-                let vectorStoreId;
-                if (modelRequirements.knowledgeSources && modelRequirements.knowledgeSources.length > 0) {
-                    const client = await this.options.llmTools.getClient();
-                    vectorStoreId = await OpenAiAgentExecutionTools.createVectorStore(client, this.title, modelRequirements.knowledgeSources);
+                    console.info('[🤰]', 'Preparing OpenAI AgentKit agent', {
+                        agent: this.title,
+                    });
                 }
-                if (vectorStoreId) {
-                    AgentLlmExecutionTools.vectorStoreCache.set(this.title, {
-                        vectorStoreId,
-                        requirementsHash,
+                if (!vectorStoreId && ((_b = modelRequirements.knowledgeSources) === null || _b === void 0 ? void 0 : _b.length)) {
+                    emitAssistantPreparationProgress({
+                        onProgress,
+                        prompt,
+                        modelName: this.modelName,
+                        phase: 'Creating knowledge base',
                     });
                 }
-                agentTools = new OpenAiAgentExecutionTools({
-                    ...this.options.llmTools.options,
+                emitAssistantPreparationProgress({
+                    onProgress,
+                    prompt,
+                    modelName: this.modelName,
+                    phase: 'Preparing AgentKit agent',
+                });
+                preparedAgentKit = await this.options.llmTools.prepareAgentKitAgent({
+                    name: this.title,
+                    instructions: modelRequirements.systemMessage || '',
+                    knowledgeSources: modelRequirements.knowledgeSources,
+                    tools: modelRequirements.tools ? [...modelRequirements.tools] : undefined,
                     vectorStoreId,
                 });
             }
-            // Create modified chat prompt with agent system message specific to OpenAI Agent
-            // Note: Unlike Assistants API, Responses API expects instructions (system message) to be passed in the call.
-            // So we use promptWithAgentModelRequirements which has the system message prepended.
-            // But we need to make sure we pass knowledgeSources in modelRequirements so OpenAiAgentExecutionTools can fallback to warning if vectorStoreId is missing (though we just handled it).
-            const promptForAgent = {
-                ...promptWithAgentModelRequirements,
-                modelRequirements: {
-                    ...promptWithAgentModelRequirements.modelRequirements,
-                    knowledgeSources: modelRequirements.knowledgeSources
-                        ? [...modelRequirements.knowledgeSources]
-                        : undefined, // Pass knowledge sources explicitly
-                },
-            };
-            underlyingLlmResult = await agentTools.callChatModelStream(promptForAgent, onProgress);
+            if (preparedAgentKit.vectorStoreId) {
+                AgentLlmExecutionTools.vectorStoreCache.set(this.title, {
+                    vectorStoreId: preparedAgentKit.vectorStoreId,
+                    requirementsHash: vectorStoreHash,
+                });
+            }
+            AgentLlmExecutionTools.agentKitAgentCache.set(this.title, {
+                agent: preparedAgentKit.agent,
+                requirementsHash,
+                vectorStoreId: preparedAgentKit.vectorStoreId,
+            });
+            underlyingLlmResult = await this.options.llmTools.callChatModelStreamWithPreparedAgent({
+                openAiAgentKitAgent: preparedAgentKit.agent,
+                prompt: promptWithAgentModelRequirements,
+                onProgress,
+            });
         }
         else if (OpenAiAssistantExecutionTools.isOpenAiAssistantExecutionTools(this.options.llmTools)) {
             // ... deprecated path ...
@@ -24678,6 +25487,10 @@ class AgentLlmExecutionTools {
         return agentResult;
     }
 }
+/**
+ * Cached AgentKit agents to avoid rebuilding identical instances.
+ */
+AgentLlmExecutionTools.agentKitAgentCache = new Map();
 /**
  * Cache of OpenAI assistants to avoid creating duplicates
  */
@@ -24758,8 +25571,8 @@ function buildTeacherSummary(commitments, used) {
  * - `Agent` - which represents an AI Agent with its source, memories, actions, etc. Agent is a higher-level abstraction which is internally using:
  * - `LlmExecutionTools` - which wraps one or more LLM models and provides an interface to execute them
  * - `AgentLlmExecutionTools` - which is a specific implementation of `LlmExecutionTools` that wraps another LlmExecutionTools and applies agent-specific system prompts and requirements
- * - `OpenAiAgentExecutionTools` - which is a specific implementation of `LlmExecutionTools` for OpenAI models with agent capabilities (using Responses API), recommended for usage in `Agent` or `AgentLlmExecutionTools`
  * - `OpenAiAssistantExecutionTools` - (Deprecated) which is a specific implementation of `LlmExecutionTools` for OpenAI models with assistant capabilities
+ * - `OpenAiAgentKitExecutionTools` - which is a specific implementation of `LlmExecutionTools` backed by OpenAI AgentKit
  * - `RemoteAgent` - which is an `Agent` that connects to a Promptbook Agents Server
  *
  * @public exported from `@promptbook/core`
@@ -25130,7 +25943,8 @@ function buildRemoteAgentSource(profile, meta) {
  * - `Agent` - which represents an AI Agent with its source, memories, actions, etc. Agent is a higher-level abstraction which is internally using:
  * - `LlmExecutionTools` - which wraps one or more LLM models and provides an interface to execute them
  * - `AgentLlmExecutionTools` - which is a specific implementation of `LlmExecutionTools` that wraps another LlmExecutionTools and applies agent-specific system prompts and requirements
- * - `OpenAiAssistantExecutionTools` - which is a specific implementation of `LlmExecutionTools` for OpenAI models with assistant capabilities, recommended for usage in `Agent` or `AgentLlmExecutionTools`
+ * - `OpenAiAssistantExecutionTools` - (Deprecated) which is a specific implementation of `LlmExecutionTools` for OpenAI models with assistant capabilities
+ * - `OpenAiAgentKitExecutionTools` - which is a specific implementation of `LlmExecutionTools` backed by OpenAI AgentKit
  * - `RemoteAgent` - which is an `Agent` that connects to a Promptbook Agents Server
  *
  * @public exported from `@promptbook/core`