@promptbook/documents 0.112.0-11 → 0.112.0-111

package/umd/src/llm-providers/openai/OpenAiAssistantExecutionToolsToolRunner.d.ts

@@ -0,0 +1,89 @@
+import OpenAI from 'openai';
+import type { ChatPromptResult } from '../../execution/PromptResult';
+import type { ScriptExecutionTools } from '../../execution/ScriptExecutionTools';
+import type { Prompt } from '../../types/Prompt';
+import type { string_date_iso8601, string_token } from '../../types/string_token';
+import { OpenAiAssistantExecutionToolsProgressReporter } from './OpenAiAssistantExecutionToolsProgressReporter';
+/**
+ * Shared context for one assistant chat call after prompt preparation finishes.
+ *
+ * @private helper of `OpenAiAssistantExecutionToolsToolRunner`
+ */
+type AssistantChatCallContext = {
+    readonly client: OpenAI;
+    readonly prompt: Prompt;
+    readonly rawPromptContent: string;
+    readonly threadMessages: ReadonlyArray<OpenAI.Beta.ThreadCreateAndRunParams.Thread.Message>;
+    readonly start: string_date_iso8601;
+    readonly onProgress: (chunk: ChatPromptResult) => void;
+};
+/**
+ * Runs assistant requests that require OpenAI Runs API tool execution.
+ *
+ * @private helper of `OpenAiAssistantExecutionTools`
+ */
+export declare class OpenAiAssistantExecutionToolsToolRunner {
+    private readonly options;
+    /**
+     * Creates one tool runner instance.
+     */
+    constructor(options: {
+        readonly assistantId: string_token;
+        readonly isVerbose: boolean;
+        readonly scriptExecutionTools?: ScriptExecutionTools | ReadonlyArray<ScriptExecutionTools>;
+        readonly progressReporter: OpenAiAssistantExecutionToolsProgressReporter;
+    });
+    /**
+     * Runs assistant calls with tools through the non-streaming Runs API.
+     */
+    callChatModelStreamWithTools(context: AssistantChatCallContext): Promise<ChatPromptResult>;
+    /**
+     * Builds the non-streaming assistant request payload used when tool calls are enabled.
+     */
+    private createAssistantToolRunRequest;
+    /**
+     * Starts the assistant run and keeps polling until the run completes or fails.
+     */
+    private executeAssistantToolRun;
+    /**
+     * Polls one assistant run, executing and submitting tool outputs when OpenAI requests them.
+     */
+    private waitForAssistantToolRun;
+    /**
+     * Executes all required assistant tool calls and submits their outputs back to OpenAI.
+     */
+    private submitAssistantRequiredToolOutputs;
+    /**
+     * Waits a bit and then fetches the latest assistant run status.
+     */
+    private retrieveAssistantRunAfterDelay;
+    /**
+     * Executes each function tool requested by the assistant and records progress snapshots.
+     */
+    private executeAssistantRequiredToolCalls;
+    /**
+     * Executes one function tool requested by the assistant.
+     */
+    private executeAssistantRequiredToolCall;
+    /**
+     * Creates the initial pending snapshot for one assistant tool call.
+     */
+    private createPendingAssistantToolCall;
+    /**
+     * Resolves the configured script tools for assistant tool execution.
+     */
+    private resolveAssistantScriptTools;
+    /**
+     * Executes the configured script tool for one assistant-requested function call.
+     */
+    private executeAssistantFunctionTool;
+    /**
+     * Finalizes one assistant tool-call snapshot after execution ends.
+     */
+    private createCompletedAssistantToolCall;
+    /**
+     * Extracts the latest assistant text response from a completed thread.
+     */
+    private extractCompletedAssistantTextContent;
+}
+export {};

package/umd/src/llm-providers/openai/OpenAiCompatibleExecutionTools.d.ts

@@ -1,10 +1,12 @@
-import OpenAI from 'openai';
+import type OpenAI from 'openai';
 import type { AvailableModel } from '../../execution/AvailableModel';
 import type { CallChatModelStreamOptions, LlmExecutionTools } from '../../execution/LlmExecutionTools';
 import type { ChatPromptResult, CompletionPromptResult, EmbeddingPromptResult, ImagePromptResult } from '../../execution/PromptResult';
 import type { Usage } from '../../execution/Usage';
 import type { Prompt } from '../../types/Prompt';
-import type { string_markdown, string_markdown_text, string_model_name, string_title } from '../../types/typeAliases';
+import type { string_markdown, string_markdown_text } from '../../types/string_markdown';
+import type { string_model_name } from '../../types/string_model_name';
+import type { string_title } from '../../types/string_title';
 import { computeOpenAiUsage } from './computeOpenAiUsage';
 import type { OpenAiCompatibleExecutionToolsNonProxiedOptions } from './OpenAiCompatibleExecutionToolsOptions';
 /**
@@ -15,13 +17,17 @@ import type { OpenAiCompatibleExecutionToolsNonProxiedOptions } from './OpenAiCo
 export declare abstract class OpenAiCompatibleExecutionTools implements LlmExecutionTools {
     protected readonly options: OpenAiCompatibleExecutionToolsNonProxiedOptions;
     /**
-     * OpenAI API client.
+     * OpenAI client lifecycle and shared request execution behavior.
      */
-    private client;
+    private readonly requestManager;
     /**
-     * Rate limiter instance
+     * Live/hardcoded model lookup shared by all provider variants.
      */
-    private limiter;
+    private readonly modelCatalog;
+    /**
+     * Completion, embedding, and image-generation prompt execution.
+     */
+    private readonly nonChatPromptCaller;
     /**
      * Creates OpenAI compatible Execution Tools.
      *
@@ -39,9 +45,6 @@ export declare abstract class OpenAiCompatibleExecutionTools implements LlmExecu
      * List all available OpenAI compatible models that can be used
      */
     listModels(): Promise<ReadonlyArray<AvailableModel>>;
-    /**
-     * Calls OpenAI compatible API to use a chat model.
-     */
     /**
      * Calls OpenAI compatible API to use a chat model.
      */
@@ -49,35 +52,23 @@ export declare abstract class OpenAiCompatibleExecutionTools implements LlmExecu
     /**
      * Calls OpenAI compatible API to use a chat model with streaming.
      */
-    callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void, options?: CallChatModelStreamOptions): Promise<ChatPromptResult>;
+    callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void, _options?: CallChatModelStreamOptions): Promise<ChatPromptResult>;
     /**
-     * Internal method that handles parameter retry for chat model calls
+     * Executes one OpenAI request under the shared rate limiter and network retry policy.
      */
-    private callChatModelWithRetry;
+    private executeRateLimitedRequest;
     /**
      * Calls OpenAI API to use a complete model.
      */
     callCompletionModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements'>): Promise<CompletionPromptResult>;
-    /**
-     * Internal method that handles parameter retry for completion model calls
-     */
-    private callCompletionModelWithRetry;
     /**
      * Calls OpenAI compatible API to use a embedding model
      */
     callEmbeddingModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements'>): Promise<EmbeddingPromptResult>;
-    /**
-     * Internal method that handles parameter retry for embedding model calls
-     */
-    private callEmbeddingModelWithRetry;
     /**
      * Calls OpenAI compatible API to use a image generation model
      */
     callImageGenerationModel(prompt: Prompt): Promise<ImagePromptResult>;
-    /**
-     * Internal method that handles parameter retry for image generation model calls
-     */
-    private callImageGenerationModelWithRetry;
     /**
      * Get the model that should be used as default
      */
@@ -108,19 +99,4 @@ export declare abstract class OpenAiCompatibleExecutionTools implements LlmExecu
      * Default model for image generation variant.
      */
     protected abstract getDefaultImageGenerationModel(): AvailableModel;
-    /**
-     * Makes a request with retry logic for network errors like ECONNRESET
-     */
-    private makeRequestWithNetworkRetry;
-    /**
-     * Determines if an error is retryable (network-related errors)
-     */
-    private isRetryableNetworkError;
 }
-/**
- * TODO: [🛄] Some way how to re-wrap the errors from `OpenAiCompatibleExecutionTools`
- * TODO: [🛄] Maybe make custom `OpenAiCompatibleError`
- * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
- * TODO: [🧠][🌰] Allow to pass `title` for tracking purposes
- * TODO: [🧠][🦢] Make reverse adapter from LlmExecutionTools to OpenAI-compatible:
- */

package/umd/src/llm-providers/openai/OpenAiCompatibleExecutionToolsOptions.d.ts

@@ -15,6 +15,7 @@ export type OpenAiCompatibleExecutionToolsOptions = OpenAiCompatibleExecutionToo
  * Options for directly used `OpenAiCompatibleExecutionTools`
  *
  * This extends OpenAI's `ClientOptions` with are directly passed to the OpenAI client.
+ *
  * @public exported from `@promptbook/openai`
  */
 export type OpenAiCompatibleExecutionToolsNonProxiedOptions = CommonToolsOptions & ClientOptions & {
@@ -39,6 +40,7 @@ export type OpenAiCompatibleExecutionToolsNonProxiedOptions = CommonToolsOptions
  * Options for proxied `OpenAiCompatibleExecutionTools`
  *
  * This extends OpenAI's `ClientOptions` with are directly passed to the OpenAI client.
+ *
  * @public exported from `@promptbook/openai`
  */
 export type OpenAiCompatibleExecutionToolsProxiedOptions = CommonToolsOptions & ClientOptions & {

package/umd/src/llm-providers/openai/OpenAiCompatibleModelCatalog.d.ts

@@ -0,0 +1,31 @@
+import type OpenAI from 'openai';
+import type { AvailableModel } from '../../execution/AvailableModel';
+import type { string_model_name } from '../../types/string_model_name';
+import type { string_markdown_text } from '../../types/string_markdown';
+import type { string_title } from '../../types/string_title';
+/**
+ * Dependencies required to resolve OpenAI-compatible models.
+ */
+type OpenAiCompatibleModelCatalogOptions = {
+    readonly getTitle: () => string_title & string_markdown_text;
+    readonly getClient: () => Promise<OpenAI>;
+    readonly getHardcodedModels: () => ReadonlyArray<AvailableModel>;
+};
+/**
+ * Resolves model lists and default-model lookup for OpenAI-compatible execution tools.
+ *
+ * @private helper of `OpenAiCompatibleExecutionTools`
+ */
+export declare class OpenAiCompatibleModelCatalog {
+    private readonly options;
+    constructor(options: OpenAiCompatibleModelCatalogOptions);
+    /**
+     * Lists available models by merging the live API list with hardcoded metadata when possible.
+     */
+    listModels(): Promise<ReadonlyArray<AvailableModel>>;
+    /**
+     * Resolves one default model by exact or family-prefix name.
+     */
+    getDefaultModel(defaultModelName: string_model_name): AvailableModel;
+}
+export {};

package/umd/src/llm-providers/openai/OpenAiCompatibleNonChatPromptCaller.d.ts

@@ -0,0 +1,57 @@
+import OpenAI from 'openai';
+import type { AvailableModel } from '../../execution/AvailableModel';
+import type { CompletionPromptResult, EmbeddingPromptResult, ImagePromptResult } from '../../execution/PromptResult';
+import type { Usage } from '../../execution/Usage';
+import type { Prompt } from '../../types/Prompt';
+import type { string_markdown_text } from '../../types/string_markdown';
+import type { string_title } from '../../types/string_title';
+import type { computeOpenAiUsage } from './computeOpenAiUsage';
+/**
+ * Dependencies required to run non-chat OpenAI-compatible prompt variants.
+ */
+type OpenAiCompatibleNonChatPromptCallerOptions = {
+    readonly getTitle: () => string_title & string_markdown_text;
+    readonly isVerbose: boolean | undefined;
+    readonly userId: string | number | undefined;
+    readonly getClient: () => Promise<OpenAI>;
+    readonly executeRateLimitedRequest: <T>(requestFn: () => Promise<T>) => Promise<T>;
+    readonly computeUsage: (...args: Parameters<typeof computeOpenAiUsage>) => Usage;
+    readonly getDefaultCompletionModel: () => AvailableModel;
+    readonly getDefaultEmbeddingModel: () => AvailableModel;
+    readonly getDefaultImageGenerationModel: () => AvailableModel;
+    readonly getHardcodedModels: () => ReadonlyArray<AvailableModel>;
+};
+/**
+ * Executes completion, embedding, and image-generation prompts for OpenAI-compatible providers.
+ *
+ * @private helper of `OpenAiCompatibleExecutionTools`
+ */
+export declare class OpenAiCompatibleNonChatPromptCaller {
+    private readonly options;
+    constructor(options: OpenAiCompatibleNonChatPromptCallerOptions);
+    /**
+     * Calls one OpenAI-compatible completion model.
+     */
+    callCompletionModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements'>): Promise<CompletionPromptResult>;
+    /**
+     * Calls one OpenAI-compatible embedding model.
+     */
+    callEmbeddingModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements'>): Promise<EmbeddingPromptResult>;
+    /**
+     * Calls one OpenAI-compatible image-generation model.
+     */
+    callImageGenerationModel(prompt: Prompt): Promise<ImagePromptResult>;
+    /**
+     * Retries completion requests while stripping unsupported model parameters.
+     */
+    private callCompletionModelWithRetry;
+    /**
+     * Retries embedding requests while stripping unsupported model parameters.
+     */
+    private callEmbeddingModelWithRetry;
+    /**
+     * Retries image-generation requests while stripping unsupported model parameters.
+     */
+    private callImageGenerationModelWithRetry;
+}
+export {};

package/umd/src/llm-providers/openai/OpenAiCompatibleRequestManager.d.ts

@@ -0,0 +1,29 @@
+import OpenAI from 'openai';
+import type { OpenAiCompatibleExecutionToolsNonProxiedOptions } from './OpenAiCompatibleExecutionToolsOptions';
+/**
+ * Manages OpenAI-compatible client creation plus shared retry and rate-limit behavior.
+ *
+ * @private helper of `OpenAiCompatibleExecutionTools`
+ */
+export declare class OpenAiCompatibleRequestManager {
+    private readonly options;
+    private client;
+    private readonly limiter;
+    constructor(options: OpenAiCompatibleExecutionToolsNonProxiedOptions);
+    /**
+     * Returns the lazily initialized OpenAI client configured from execution-tool options.
+     */
+    getClient(): Promise<OpenAI>;
+    /**
+     * Schedules one request through the shared limiter and retry policy.
+     */
+    executeRateLimitedRequest<T>(requestFn: () => Promise<T>): Promise<T>;
+    /**
+     * Retries transient transport errors with exponential backoff.
+     */
+    private makeRequestWithNetworkRetry;
+    /**
+     * Determines whether the thrown error should be retried as a transient network failure.
+     */
+    private isRetryableNetworkError;
+}

package/umd/src/llm-providers/openai/OpenAiExecutionTools.d.ts

@@ -1,7 +1,8 @@
 import type { ChatParticipant } from '../../book-components/Chat/types/ChatParticipant';
 import type { AvailableModel } from '../../execution/AvailableModel';
 import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
-import type { string_markdown, string_markdown_text, string_title } from '../../types/typeAliases';
+import type { string_markdown, string_markdown_text } from '../../types/string_markdown';
+import type { string_title } from '../../types/string_title';
 import { computeOpenAiUsage } from './computeOpenAiUsage';
 import { OpenAiCompatibleExecutionTools } from './OpenAiCompatibleExecutionTools';
 /**

package/umd/src/llm-providers/openai/OpenAiVectorStoreFileBatchHandler.d.ts

@@ -0,0 +1,51 @@
+import type OpenAI from 'openai';
+import type { TODO_any } from '../../utils/organization/TODO_any';
+/**
+ * Uploads prepared knowledge-source files and starts vector-store ingestion polling.
+ *
+ * @private helper of `OpenAiVectorStoreHandler`
+ */
+export declare class OpenAiVectorStoreFileBatchHandler {
+    private readonly options;
+    /**
+     * Creates one vector-store file-batch handler instance.
+     */
+    constructor(options: {
+        readonly isVerbose: boolean;
+        readonly getVectorStoresApi: (client: OpenAI) => TODO_any;
+    });
+    /**
+     * Uploads knowledge source files to the vector store and polls until processing completes.
+     */
+    uploadKnowledgeSourceFilesToVectorStore(options: {
+        readonly client: OpenAI;
+        readonly vectorStoreId: string;
+        readonly files: ReadonlyArray<File>;
+        readonly totalBytes: number;
+        readonly maxConcurrency: number;
+        readonly pollIntervalMs: number;
+        readonly uploadTimeoutMs: number;
+        readonly shouldContinueOnVectorStoreStall: boolean;
+        readonly logLabel: string;
+    }): Promise<TODO_any | null>;
+    /**
+     * Uploads the prepared knowledge-source files with bounded concurrency.
+     */
+    private uploadPreparedKnowledgeSourceFiles;
+    /**
+     * Reuses the shared iterator to upload one slice of knowledge-source files.
+     */
+    private uploadPreparedKnowledgeSourceFilesWorker;
+    /**
+     * Uploads one prepared knowledge-source file to OpenAI and records detailed diagnostics.
+     */
+    private uploadPreparedKnowledgeSourceFile;
+    /**
+     * Creates the OpenAI vector-store file batch for the uploaded knowledge-source files.
+     */
+    private createVectorStoreFileBatch;
+    /**
+     * Logs warnings for unexpected vector-store batch metadata right after creation.
+     */
+    private logCreatedVectorStoreFileBatchIssues;
+}

package/umd/src/llm-providers/openai/OpenAiVectorStoreFileBatchPoller.d.ts

@@ -0,0 +1,75 @@
+import type OpenAI from 'openai';
+import type { TODO_any } from '../../utils/organization/TODO_any';
+/**
+ * Metadata for uploaded knowledge source files used for vector store diagnostics.
+ *
+ * @private internal utility of `OpenAiVectorStoreFileBatchPoller`
+ */
+type KnowledgeSourceUploadMetadata = {
+    readonly fileId: string;
+    readonly filename: string;
+    readonly sizeBytes?: number;
+};
+/**
+ * Polls one vector-store file batch until it settles.
+ *
+ * @private helper of `OpenAiVectorStoreHandler`
+ */
+export declare class OpenAiVectorStoreFileBatchPoller {
+    private readonly options;
+    /**
+     * Creates one vector-store file-batch poller instance.
+     */
+    constructor(options: {
+        readonly isVerbose: boolean;
+        readonly getVectorStoresApi: (client: OpenAI) => TODO_any;
+    });
+    /**
+     * Polls the created vector-store batch until ingestion completes, fails, or times out.
+     */
+    pollVectorStoreFileBatchUntilSettled(options: {
+        readonly client: OpenAI;
+        readonly vectorStoreId: string;
+        readonly batch: TODO_any;
+        readonly expectedBatchId: string;
+        readonly isExpectedBatchIdValid: boolean;
+        readonly uploadedFiles: ReadonlyArray<KnowledgeSourceUploadMetadata>;
+        readonly pollIntervalMs: number;
+        readonly uploadTimeoutMs: number;
+        readonly shouldContinueOnVectorStoreStall: boolean;
+        readonly logLabel: string;
+    }): Promise<TODO_any>;
+    /**
+     * Logs vector store file batch diagnostics to help trace ingestion stalls or failures.
+     */
+    private logVectorStoreFileBatchDiagnostics;
+    /**
+     * Resolves the next batch id to poll and retrieves the freshest OpenAI batch snapshot.
+     */
+    private retrieveVectorStoreFileBatchForPolling;
+    /**
+     * Normalizes the batch identifier returned by OpenAI and logs unusual id situations once.
+     */
+    private resolveVectorStoreFileBatchId;
+    /**
+     * Tracks observed polling progress and emits throttled verbose status logs.
+     */
+    private trackVectorStoreFileBatchProgress;
+    /**
+     * Emits deeper diagnostics when vector-store ingestion appears stalled for too long.
+     */
+    private maybeLogStalledVectorStoreFileBatch;
+    /**
+     * Handles terminal vector-store batch states that do not require further polling.
+     */
+    private handleVectorStoreFileBatchTerminalState;
+    /**
+     * Stops polling once the batch exceeds the configured timeout and handles optional cancellation.
+     */
+    private handleVectorStoreFileBatchTimeout;
+    /**
+     * Attempts to cancel a timed-out vector-store batch and logs any unusual id situation.
+     */
+    private cancelVectorStoreFileBatchAfterTimeout;
+}
+export {};

package/umd/src/llm-providers/openai/OpenAiVectorStoreHandler.d.ts

@@ -1,17 +1,9 @@
 import type { ClientOptions } from 'openai';
-import OpenAI from 'openai';
-import { TODO_any } from '../../_packages/types.index';
-import type { string_title } from '../../types/typeAliases';
+import type OpenAI from 'openai';
+import type { string_title } from '../../types/string_title';
+import type { TODO_any } from '../../utils/organization/TODO_any';
 import type { OpenAiCompatibleExecutionToolsOptions } from './OpenAiCompatibleExecutionToolsOptions';
 import { OpenAiExecutionTools } from './OpenAiExecutionTools';
-/**
- * Metadata for uploaded knowledge source files used for vector store diagnostics.
- */
-type KnowledgeSourceUploadMetadata = {
-    readonly fileId: string;
-    readonly filename: string;
-    readonly sizeBytes?: number;
-};
 /**
  * Shared options for OpenAI vector store handling.
  *
@@ -83,40 +75,6 @@ export declare abstract class OpenAiVectorStoreHandler extends OpenAiExecutionTo
      * Returns the OpenAI vector stores API surface, supporting stable and beta SDKs.
      */
     protected getVectorStoresApi(client: OpenAI): TODO_any;
-    /**
-     * Downloads a knowledge source URL into a File for vector store upload.
-     */
-    protected downloadKnowledgeSourceFile(options: {
-        readonly source: string;
-        readonly timeoutMs: number;
-        readonly logLabel: string;
-    }): Promise<{
-        readonly file: File;
-        readonly sizeBytes: number;
-        readonly filename: string;
-        readonly elapsedMs: number;
-    } | null>;
-    /**
-     * Logs vector store file batch diagnostics to help trace ingestion stalls or failures.
-     */
-    protected logVectorStoreFileBatchDiagnostics(options: {
-        readonly client: OpenAI;
-        readonly vectorStoreId: string;
-        readonly batchId: string;
-        readonly uploadedFiles: ReadonlyArray<KnowledgeSourceUploadMetadata>;
-        readonly logLabel: string;
-        readonly reason: 'stalled' | 'timeout' | 'failed';
-    }): Promise<void>;
-    /**
-     * Uploads knowledge source files to the vector store and polls until processing completes.
-     */
-    protected uploadKnowledgeSourceFilesToVectorStore(options: {
-        readonly client: OpenAI;
-        readonly vectorStoreId: string;
-        readonly files: ReadonlyArray<File>;
-        readonly totalBytes: number;
-        readonly logLabel: string;
-    }): Promise<TODO_any | null>;
     /**
      * Creates a vector store and uploads knowledge sources, returning its ID.
      */
@@ -132,4 +90,3 @@ export declare abstract class OpenAiVectorStoreHandler extends OpenAiExecutionTo
         readonly totalBytes: number;
     }>;
 }
-export {};

package/umd/src/llm-providers/openai/OpenAiVectorStoreKnowledgeSourcePreparer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Prepared knowledge-source files together with skipped-source bookkeeping.
+ *
+ * @private internal utility of `OpenAiVectorStoreKnowledgeSourcePreparer`
+ */
+type PreparedKnowledgeSourceFiles = {
+    readonly files: File[];
+    readonly skippedSources: Array<{
+        source: string;
+        reason: string;
+    }>;
+    readonly totalBytes: number;
+};
+/**
+ * Prepares vector-store knowledge sources for upload.
+ *
+ * @private helper of `OpenAiVectorStoreHandler`
+ */
+export declare class OpenAiVectorStoreKnowledgeSourcePreparer {
+    private readonly options;
+    /**
+     * Creates one knowledge-source preparer instance.
+     */
+    constructor(options: {
+        readonly isVerbose: boolean;
+    });
+    /**
+     * Resolves supported knowledge sources into uploadable `File` objects.
+     */
+    prepareKnowledgeSourceFiles(options: {
+        readonly knowledgeSources: ReadonlyArray<string>;
+        readonly downloadTimeoutMs: number;
+        readonly logLabel: string;
+    }): Promise<PreparedKnowledgeSourceFiles>;
+    /**
+     * Converts one knowledge source into a `File` or a skip reason.
+     */
+    private prepareKnowledgeSourceFile;
+    /**
+     * Downloads one knowledge source URL into a `File`.
+     */
+    private downloadKnowledgeSourceFile;
+}
+export {};

package/umd/src/llm-providers/openai/computeOpenAiUsage.d.ts

@@ -11,10 +11,8 @@ import type { Prompt } from '../../types/Prompt';
  * @param rawResponse The raw response from OpenAI API
  * @param duration The duration of the execution
  * @throws {PipelineExecutionError} If the usage is not defined in the response from OpenAI
+ *
  * @private internal utility of `OpenAiExecutionTools`
  */
 export declare function computeOpenAiUsage(promptContent: Prompt['content'], // <- Note: Intentionally using [] to access type properties to bring jsdoc from Prompt/PromptResult to consumer
 resultContent: string, rawResponse: PartialDeep<Pick<OpenAI.Chat.Completions.ChatCompletion | OpenAI.Completions.Completion | OpenAI.Embeddings.CreateEmbeddingResponse, 'model' | 'usage'>>, duration?: UncertainNumber): Usage;
-/**
- * TODO: [🤝] DRY Maybe some common abstraction between `computeOpenAiUsage` and `computeAnthropicClaudeUsage`
- */

package/umd/src/llm-providers/openai/computeOpenAiUsage.test.d.ts

@@ -1,4 +1 @@
 export {};
-/**
- * TODO: [🤝] DRY Maybe some common abstraction between `computeOpenAiUsage` and `computeAnthropicClaudeUsage`
- */

package/umd/src/llm-providers/openai/createOpenAiAssistantExecutionTools.d.ts

@@ -9,7 +9,3 @@ export declare const createOpenAiAssistantExecutionTools: ((options: OpenAiAssis
     packageName: string;
     className: string;
 };
-/**
- * TODO: [🦺] Is there some way how to put `packageName` and `className` on top and function definition on bottom?
- * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
- */

package/umd/src/llm-providers/openai/createOpenAiCompatibleExecutionTools.d.ts

@@ -1,7 +1,9 @@
 import type { AvailableModel } from '../../execution/AvailableModel';
 import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
 import type { Usage } from '../../execution/Usage';
-import type { string_markdown, string_markdown_text, string_model_name, string_title } from '../../types/typeAliases';
+import type { string_markdown, string_markdown_text } from '../../types/string_markdown';
+import type { string_model_name } from '../../types/string_model_name';
+import type { string_title } from '../../types/string_title';
 import { RemoteLlmExecutionTools } from '../remote/RemoteLlmExecutionTools';
 import { computeOpenAiUsage } from './computeOpenAiUsage';
 import { OpenAiCompatibleExecutionTools } from './OpenAiCompatibleExecutionTools';
@@ -68,7 +70,3 @@ export declare class HardcodedOpenAiCompatibleExecutionTools extends OpenAiCompa
      */
     protected getDefaultImageGenerationModel(): AvailableModel;
 }
-/**
- * TODO: [🦺] Is there some way how to put `packageName` and `className` on top and function definition on bottom?
- * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
- */

package/umd/src/llm-providers/openai/createOpenAiExecutionTools.d.ts

@@ -11,7 +11,3 @@ export declare const createOpenAiExecutionTools: ((options: OpenAiExecutionTools
     packageName: string;
     className: string;
 };
-/**
- * TODO: [🦺] Is there some way how to put `packageName` and `className` on top and function definition on bottom?
- * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
- */

package/umd/src/llm-providers/openai/openai-models.d.ts

@@ -2,10 +2,11 @@ import type { AvailableModel } from '../../execution/AvailableModel';
 /**
  * List of available OpenAI models with pricing
  *
- * Note: Synced with official API docs at 2025-11-19
+ * Note: Synced with official API docs at 2026-03-22
  *
  * @see https://platform.openai.com/docs/models/
  * @see https://openai.com/api/pricing/
+ *
  * @public exported from `@promptbook/openai`
  */
 export declare const OPENAI_MODELS: ReadonlyArray<AvailableModel>;

package/umd/src/llm-providers/openai/openai-models.test.d.ts

@@ -1,4 +1 @@
 export {};
-/**
- * TODO: [🧠] Maybe do this test for all model providers + boilerplate
- */

package/umd/src/llm-providers/openai/playground/playground.d.ts

@@ -1,6 +1,2 @@
 #!/usr/bin/env ts-node
 export {};
-/**
- * TODO: [main] !!3 Test here that `systemMessage`, `temperature` and `seed` are working correctly
- * Note: [⚫] Code in this file should never be published in any package
- */