@promptbook/browser 0.112.0-71 → 0.112.0-73

package/esm/src/llm-providers/openai/OpenAiAgentKitExecutionToolsToolBuilder.d.ts

@@ -0,0 +1,99 @@
+import type { Tool as AgentKitTool } from '@openai/agents';
+import type { ToolCallProgressUpdate } from '../../commitments/_common/toolRuntimeContext';
+import type { ModelRequirements } from '../../types/ModelRequirements';
+import type { ToolCall, ToolCallLogEntry, ToolCallState } from '../../types/ToolCall';
+import type { OpenAiAgentKitExecutionToolsOptions } from './OpenAiAgentKitExecutionToolsOptions';
+/**
+ * Builds AgentKit tools and tracks their execution state.
+ *
+ * @private helper of `OpenAiAgentKitExecutionTools`
+ */
+export declare class OpenAiAgentKitExecutionToolsToolBuilder {
+    private readonly context;
+    private readonly agentKitToolResultsByCallId;
+    private readonly agentKitToolSnapshotsByCallId;
+    constructor(context: {
+        readonly options: OpenAiAgentKitExecutionToolsOptions;
+        readonly agentKitModelName: string;
+    });
+    /**
+     * Clears per-run tool state before a new AgentKit stream starts.
+     */
+    clearRunState(): void;
+    /**
+     * Stores one latest tool-call snapshot keyed by AgentKit call id.
+     */
+    storeToolSnapshot(callId: string | undefined, toolCall: ToolCall): void;
+    /**
+     * Returns one latest tool-call snapshot keyed by AgentKit call id.
+     */
+    getToolSnapshot(callId: string | undefined): ToolCall | undefined;
+    /**
+     * Deletes one latest tool-call snapshot keyed by AgentKit call id.
+     */
+    deleteToolSnapshot(callId: string | undefined): void;
+    /**
+     * Builds the tool list for AgentKit, including hosted file search when applicable.
+     */
+    buildAgentKitTools(options: {
+        readonly tools?: ModelRequirements['tools'];
+        readonly vectorStoreId?: string;
+    }): Array<AgentKitTool>;
+    /**
+     * Resolves the stored Promptbook tool result for one AgentKit tool call.
+     */
+    resolveAgentKitToolOutputResult(callId: string | undefined, output: unknown): ToolCall['result'];
+    /**
+     * Creates one structured log entry for streamed tool-call updates.
+     */
+    static createToolCallLogEntry(options: {
+        readonly kind: string;
+        readonly title: string;
+        readonly message: string;
+        readonly level?: ToolCallLogEntry['level'];
+        readonly payload?: unknown;
+    }): ToolCallLogEntry;
+    /**
+     * Appends one incremental progress update to the currently tracked tool-call snapshot.
+     */
+    static applyToolCallProgressUpdate(toolCall: ToolCall, update: ToolCallProgressUpdate): ToolCall;
+    /**
+     * Resolves the final lifecycle state for one AgentKit tool call after execution ends.
+     */
+    static resolveFinalToolCallState(options: {
+        readonly currentState: ToolCallState | undefined;
+        readonly errors: ReadonlyArray<unknown> | undefined;
+    }): ToolCallState;
+    /**
+     * Returns true when one tool definition represents the dedicated DeepSearch capability.
+     */
+    private isDeepSearchToolDefinition;
+    /**
+     * Normalizes Promptbook JSON-schema tool parameters for AgentKit function tools.
+     */
+    private normalizeAgentKitToolParameters;
+    /**
+     * Creates the native Agent SDK tool used for `USE DEEPSEARCH`.
+     */
+    private createDeepSearchAgentKitTool;
+    /**
+     * Creates instructions for the nested DeepSearch specialist agent.
+     */
+    private createDeepSearchAgentInstructions;
+    /**
+     * Builds the nested DeepSearch prompt from structured tool arguments.
+     */
+    private buildDeepSearchToolInput;
+    /**
+     * Resolves the configured script tools for tool execution.
+     */
+    private resolveScriptTools;
+    /**
+     * Resolves the assistant-visible AgentKit tool response while preserving structured tool result data.
+     */
+    private resolveAgentKitToolResponse;
+    /**
+     * Normalizes AgentKit tool outputs into a string for Promptbook tool call results.
+     */
+    private formatAgentKitToolOutput;
+}

package/esm/src/llm-providers/openai/OpenAiAssistantExecutionTools.d.ts

@@ -26,6 +26,10 @@ import { OpenAiVectorStoreHandler } from './OpenAiVectorStoreHandler';
 export declare class OpenAiAssistantExecutionTools extends OpenAiVectorStoreHandler implements LlmExecutionTools {
     readonly assistantId: string_token;
     private readonly isCreatingNewAssistantsAllowed;
+    private readonly promptBuilder;
+    private readonly progressReporter;
+    private readonly toolRunner;
+    private readonly streamRunner;
     /**
      * Creates OpenAI Execution Tools.
      *
@@ -42,10 +46,6 @@ export declare class OpenAiAssistantExecutionTools extends OpenAiVectorStoreHand
      * Calls OpenAI API to use a chat model with streaming.
      */
     callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void, options?: CallChatModelStreamOptions): Promise<ChatPromptResult>;
-    /**
-     * Logs one assistant chat call when verbose output is enabled.
-     */
-    private logAssistantChatCall;
     /**
      * Validates the subset of model requirements supported by OpenAI Assistants.
      */
@@ -54,122 +54,6 @@ export declare class OpenAiAssistantExecutionTools extends OpenAiVectorStoreHand
      * Returns true when the prompt exposes callable tools that require the Runs API flow.
      */
     private hasAssistantTools;
-    /**
-     * Resolves the raw user-visible prompt content sent to the assistant.
-     */
-    private createAssistantRawPromptContent;
-    /**
-     * Builds the thread history plus the current user message for one assistant call.
-     */
-    private createAssistantThreadMessages;
-    /**
-     * Converts the existing prompt thread into OpenAI assistant thread messages.
-     */
-    private createAssistantThreadHistoryMessages;
-    /**
-     * Creates the current user message, including uploaded file attachments when present.
-     */
-    private createAssistantCurrentUserMessage;
-    /**
-     * Runs assistant calls with tools through the non-streaming Runs API.
-     */
-    private callChatModelStreamWithTools;
-    /**
-     * 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;
-    /**
-     * Runs assistant calls without tools through the streaming Assistants API.
-     */
-    private callChatModelStreamWithoutTools;
-    /**
-     * Builds the streaming assistant request payload used when no tool execution flow is needed.
-     */
-    private createAssistantStreamingRequest;
-    /**
-     * Registers verbose stream diagnostics plus incremental text progress forwarding.
-     */
-    private attachAssistantStreamListeners;
-    /**
-     * Resolves the final visible assistant text from a streaming response.
-     */
-    private resolveAssistantStreamingResultContent;
-    /**
-     * Extracts the single text content block returned by the assistant stream.
-     */
-    private extractSingleAssistantTextContentBlock;
-    /**
-     * Rewrites file citation markers to use retrieved filenames instead of generic source labels.
-     */
-    private replaceAssistantFileCitationMarkers;
-    /**
-     * Returns one citation filename, caching OpenAI file lookups across annotations.
-     */
-    private retrieveAssistantCitationFilename;
-    /**
-     * Emits one assistant progress chunk with shared timing and prompt metadata.
-     */
-    private emitAssistantProgress;
-    /**
-     * Creates the final assistant prompt result with uncertain usage plus measured duration.
-     */
-    private createAssistantPromptResult;
-    /**
-     * Computes the usage payload for assistant responses.
-     */
-    private createAssistantUsage;
-    /**
-     * Wraps the final assistant prompt result in the standard exported JSON envelope.
-     */
-    private exportAssistantPromptResult;
-    /**
-     * Logs one assistant request payload when verbose output is enabled.
-     */
-    private logVerboseAssistantRequest;
     /**
      * Get an existing assistant tool wrapper
      */
@@ -214,6 +98,26 @@ export declare class OpenAiAssistantExecutionTools extends OpenAiVectorStoreHand
          */
         readonly tools?: ModelRequirements['tools'];
     }): Promise<OpenAiAssistantExecutionTools>;
+    /**
+     * Ensures assistant creation/update helpers stay disabled unless explicitly enabled.
+     */
+    private assertAssistantMutationsAllowed;
+    /**
+     * Prepares the optional vector store backing assistant file search.
+     */
+    private prepareAssistantVectorStore;
+    /**
+     * Builds the assistant tool definition list shared by create and update flows.
+     */
+    private createAssistantToolDefinitions;
+    /**
+     * Creates a new tools wrapper bound to one assistant id.
+     */
+    private createAssistantWrapper;
+    /**
+     * Returns assistant-specific options with direct OpenAI execution helpers attached.
+     */
+    private get assistantOptions();
     /**
      * Discriminant for type guards
      */

package/esm/src/llm-providers/openai/OpenAiAssistantExecutionToolsProgressReporter.d.ts

@@ -0,0 +1,62 @@
+import type { ChatPromptResult } from '../../execution/PromptResult';
+import type { Prompt } from '../../types/Prompt';
+import type { string_markdown } from '../../types/string_markdown';
+import type { string_date_iso8601 } from '../../types/string_token';
+import type { chococake } from '../../utils/organization/really_any';
+/**
+ * Handles progress emission, verbose logging, and final result assembly.
+ *
+ * @private helper of `OpenAiAssistantExecutionTools`
+ */
+export declare class OpenAiAssistantExecutionToolsProgressReporter {
+    private readonly options;
+    /**
+     * Creates one reporter instance.
+     */
+    constructor(options: {
+        readonly isVerbose: boolean;
+    });
+    /**
+     * Logs one assistant chat call when verbose output is enabled.
+     */
+    logAssistantChatCall(prompt: Prompt): void;
+    /**
+     * Logs one assistant request payload when verbose output is enabled.
+     */
+    logVerboseAssistantRequest(label: string, rawRequest: unknown): void;
+    /**
+     * Emits one assistant progress chunk with shared timing and prompt metadata.
+     */
+    emitAssistantProgress(options: {
+        readonly start: string_date_iso8601;
+        readonly rawPromptContent: string;
+        readonly onProgress: (chunk: ChatPromptResult) => void;
+        readonly content?: string;
+        readonly rawRequest?: chococake;
+        readonly rawResponse?: chococake;
+        readonly toolCalls?: ChatPromptResult['toolCalls'];
+    }): void;
+    /**
+     * Creates the final assistant prompt result with uncertain usage plus measured duration.
+     */
+    createAssistantPromptResult(options: {
+        readonly content: string_markdown;
+        readonly start: string_date_iso8601;
+        readonly complete: string_date_iso8601;
+        readonly rawPromptContent: string;
+        readonly rawRequest: chococake;
+        readonly rawResponse: chococake;
+        readonly toolCalls?: ChatPromptResult['toolCalls'];
+    }): ChatPromptResult;
+    /**
+     * Wraps the final assistant prompt result in the standard exported JSON envelope.
+     */
+    exportAssistantPromptResult(options: {
+        readonly result: ChatPromptResult;
+        readonly isWithTools: boolean;
+    }): ChatPromptResult;
+    /**
+     * Computes the usage payload for assistant responses.
+     */
+    private createAssistantUsage;
+}

package/esm/src/llm-providers/openai/OpenAiAssistantExecutionToolsPromptBuilder.d.ts

@@ -0,0 +1,29 @@
+import type OpenAI from 'openai';
+import type { Prompt } from '../../types/Prompt';
+/**
+ * Builds assistant prompt content and thread messages.
+ *
+ * @private helper of `OpenAiAssistantExecutionTools`
+ */
+export declare class OpenAiAssistantExecutionToolsPromptBuilder {
+    /**
+     * Resolves the raw user-visible prompt content sent to the assistant.
+     */
+    createAssistantRawPromptContent(prompt: Prompt): string;
+    /**
+     * Builds the thread history plus the current user message for one assistant call.
+     */
+    createAssistantThreadMessages(options: {
+        readonly client: OpenAI;
+        readonly prompt: Prompt;
+        readonly rawPromptContent: string;
+    }): Promise<Array<OpenAI.Beta.ThreadCreateAndRunParams.Thread.Message>>;
+    /**
+     * Converts the existing prompt thread into OpenAI assistant thread messages.
+     */
+    private createAssistantThreadHistoryMessages;
+    /**
+     * Creates the current user message, including uploaded file attachments when present.
+     */
+    private createAssistantCurrentUserMessage;
+}

package/esm/src/llm-providers/openai/OpenAiAssistantExecutionToolsStreamRunner.d.ts

@@ -0,0 +1,63 @@
+import OpenAI from 'openai';
+import type { ChatPromptResult } from '../../execution/PromptResult';
+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 `OpenAiAssistantExecutionToolsStreamRunner`
+ */
+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 streaming assistant requests that do not require hosted tool execution.
+ *
+ * @private helper of `OpenAiAssistantExecutionTools`
+ */
+export declare class OpenAiAssistantExecutionToolsStreamRunner {
+    private readonly options;
+    /**
+     * Creates one stream runner instance.
+     */
+    constructor(options: {
+        readonly assistantId: string_token;
+        readonly isVerbose: boolean;
+        readonly progressReporter: OpenAiAssistantExecutionToolsProgressReporter;
+    });
+    /**
+     * Runs assistant calls without tools through the streaming Assistants API.
+     */
+    callChatModelStreamWithoutTools(context: AssistantChatCallContext): Promise<ChatPromptResult>;
+    /**
+     * Builds the streaming assistant request payload used when no tool execution flow is needed.
+     */
+    private createAssistantStreamingRequest;
+    /**
+     * Registers verbose stream diagnostics plus incremental text progress forwarding.
+     */
+    private attachAssistantStreamListeners;
+    /**
+     * Resolves the final visible assistant text from a streaming response.
+     */
+    private resolveAssistantStreamingResultContent;
+    /**
+     * Extracts the single text content block returned by the assistant stream.
+     */
+    private extractSingleAssistantTextContentBlock;
+    /**
+     * Rewrites file citation markers to use retrieved filenames instead of generic source labels.
+     */
+    private replaceAssistantFileCitationMarkers;
+    /**
+     * Returns one citation filename, caching OpenAI file lookups across annotations.
+     */
+    private retrieveAssistantCitationFilename;
+}
+export {};

package/esm/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/esm/src/llm-providers/openai/OpenAiCompatibleExecutionTools.d.ts

@@ -1,4 +1,4 @@
-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';
@@ -17,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.
      *
@@ -41,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.
      */
@@ -60,26 +61,14 @@ export declare abstract class OpenAiCompatibleExecutionTools implements LlmExecu
      * 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
      */
@@ -110,12 +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;
 }

package/esm/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/esm/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 {};