@promptbook/types 0.112.0-39 → 0.112.0-41

package/umd/src/book-components/Chat/Chat/useChatInputAreaAttachments.d.ts

@@ -1,5 +1,5 @@
 import { type ChangeEvent, type ClipboardEvent, type DragEvent } from 'react';
-import type { ChatInputUploadedFile } from './ChatInputArea';
+import type { ChatInputUploadedFile } from './ChatInputUploadedFile';
 import type { ChatProps } from './ChatProps';
 /**
  * Props for `useChatInputAreaAttachments`.

package/umd/src/book-components/Chat/Chat/useChatInputAreaComposer.d.ts

@@ -0,0 +1,39 @@
+import { type ChangeEvent, type KeyboardEvent as ReactKeyboardEvent, type MutableRefObject } from 'react';
+import type { ChatMessage } from '../types/ChatMessage';
+import type { ChatInputUploadedFile } from './ChatInputUploadedFile';
+import type { ChatProps, ChatSoundSystem } from './ChatProps';
+/**
+ * Props for `useChatInputAreaComposer`.
+ *
+ * @private function of `<ChatInputArea/>`
+ */
+type UseChatInputAreaComposerProps = {
+    readonly onMessage?: ChatProps['onMessage'];
+    readonly onChange?: ChatProps['onChange'];
+    readonly defaultMessage?: string;
+    readonly enterBehavior?: ChatProps['enterBehavior'];
+    readonly resolveEnterBehavior?: ChatProps['resolveEnterBehavior'];
+    readonly isFocusedOnLoad?: boolean;
+    readonly isMobile: boolean;
+    readonly uploadedFiles: ReadonlyArray<ChatInputUploadedFile>;
+    readonly uploadedFilesRef: MutableRefObject<Array<ChatInputUploadedFile>>;
+    readonly clearUploadedFiles: () => void;
+    readonly replyingToMessage?: ChatMessage | null;
+    readonly onCancelReply?: ChatProps['onCancelReply'];
+    readonly soundSystem?: ChatSoundSystem;
+};
+/**
+ * Manages textarea state, send/newline behavior, and deferred Enter resolution for `<ChatInputArea/>`.
+ *
+ * @private function of `<ChatInputArea/>`
+ */
+export declare function useChatInputAreaComposer(props: UseChatInputAreaComposerProps): {
+    textareaRef: import("react").RefObject<HTMLTextAreaElement | null>;
+    messageContent: string;
+    messageContentRef: import("react").RefObject<string>;
+    applyMessageContent: (nextContent: string) => void;
+    handleTextInputChange: (event: ChangeEvent<HTMLTextAreaElement>) => void;
+    handleComposerKeyDown: (event: ReactKeyboardEvent<HTMLTextAreaElement>) => void;
+    handleSend: () => Promise<void>;
+};
+export {};

package/umd/src/book-components/Chat/Chat/useChatPostprocessedMessages.d.ts

@@ -0,0 +1,17 @@
+import type { ChatMessage } from '../types/ChatMessage';
+/**
+ * Inputs required to normalize rendered chat messages.
+ *
+ * @private function of `useChatPostprocessedMessages`
+ */
+type UseChatPostprocessedMessagesProps = {
+    messages: ReadonlyArray<ChatMessage>;
+    isAiTextHumanizedAndPromptbookified: boolean;
+};
+/**
+ * Memoizes the render-only message normalization used by `<Chat/>`.
+ *
+ * @private function of `<Chat/>`
+ */
+export declare function useChatPostprocessedMessages({ messages, isAiTextHumanizedAndPromptbookified, }: UseChatPostprocessedMessagesProps): ReadonlyArray<ChatMessage>;
+export {};

package/umd/src/book-components/Chat/Chat/useChatScrollState.d.ts

@@ -0,0 +1,34 @@
+import { type MutableRefObject, type UIEvent } from 'react';
+import type { ChatMessage } from '../types/ChatMessage';
+/**
+ * Inputs required to coordinate Chat scroll behavior.
+ *
+ * @private function of `useChatScrollState`
+ */
+type UseChatScrollStateProps = {
+    messages: ReadonlyArray<ChatMessage>;
+};
+/**
+ * Public result consumed by `<Chat/>`.
+ *
+ * @private function of `useChatScrollState`
+ */
+type UseChatScrollStateResult = {
+    readonly actionsRef: MutableRefObject<HTMLDivElement | null>;
+    readonly ariaLabel: string;
+    readonly badgeLabel: string;
+    readonly handleChatScroll: (event: UIEvent<HTMLDivElement>) => void;
+    readonly isMobile: boolean;
+    readonly scrollToBottom: (behavior?: 'smooth' | 'auto') => void;
+    readonly setChatMessagesElement: (element: HTMLDivElement | null) => void;
+    readonly shouldDisableActions: boolean;
+    readonly shouldFadeActions: boolean;
+    readonly shouldShowScrollToBottom: boolean;
+};
+/**
+ * Coordinates auto-scroll, overlap tracking, and the scroll-to-bottom indicator for `<Chat/>`.
+ *
+ * @private function of `<Chat/>`
+ */
+export declare function useChatScrollState({ messages }: UseChatScrollStateProps): UseChatScrollStateResult;
+export {};

package/umd/src/book-components/Chat/Chat/useChatToolCallModalState.d.ts

@@ -0,0 +1,61 @@
+import { type MutableRefObject } from 'react';
+import type { AgentChipData } from '../AgentChip/AgentChip';
+import type { ChatMessage } from '../types/ChatMessage';
+import { type TeamToolCallSummary, type TransitiveToolCall } from '../utils/collectTeamToolCallSummary';
+import { type AgentProfileData } from '../utils/loadAgentProfile';
+import { type TeamToolResult } from '../utils/toolCallParsing';
+/**
+ * Tool-call snapshot rendered by the modal.
+ *
+ * @private function of `ChatToolCallModal`
+ */
+type ToolCallModalToolCall = NonNullable<ChatMessage['toolCalls']>[number];
+/**
+ * Export target used by the advanced tool-call report controls.
+ *
+ * @private function of `ChatToolCallModal`
+ */
+type ToolCallReportDestination = 'clipboard' | 'file';
+/**
+ * Inputs required to coordinate `<ChatToolCallModal/>` state.
+ *
+ * @private function of `useChatToolCallModalState`
+ */
+type UseChatToolCallModalStateProps = {
+    readonly isOpen: boolean;
+    readonly toolCall: ToolCallModalToolCall | null;
+    /**
+     * Stable identity of the selected tool call.
+     */
+    readonly toolCallIdentity?: string | null;
+    readonly onClose: () => void;
+    readonly toolTitles?: Record<string, string>;
+    readonly teamAgentProfiles?: Record<string, AgentChipData>;
+};
+/**
+ * State and callbacks consumed by `<ChatToolCallModal/>`.
+ *
+ * @private function of `useChatToolCallModalState`
+ */
+type UseChatToolCallModalStateResult = {
+    readonly clearSelectedTeamToolCall: () => void;
+    readonly exportAdvancedToolCallReport: (destination: ToolCallReportDestination) => Promise<void>;
+    readonly focusedToolCall: ToolCallModalToolCall | null;
+    readonly isAdvancedView: boolean;
+    readonly modalDialogRef: MutableRefObject<HTMLDivElement | null>;
+    readonly openAdvancedView: () => void;
+    readonly selectTeamToolCall: (toolCall: TransitiveToolCall) => void;
+    readonly selectedTeamToolCall: TransitiveToolCall | null;
+    readonly teamProfiles: Record<string, AgentProfileData>;
+    readonly teamResult: TeamToolResult | null;
+    readonly teamToolCallSummary: TeamToolCallSummary;
+    readonly toggleViewMode: () => void;
+    readonly toolCallDate: Date | null;
+};
+/**
+ * Coordinates derived data, modal lifecycle, and advanced-export actions for `<ChatToolCallModal/>`.
+ *
+ * @private function of `ChatToolCallModal`
+ */
+export declare function useChatToolCallModalState({ isOpen, toolCall, toolCallIdentity, onClose, toolTitles, teamAgentProfiles, }: UseChatToolCallModalStateProps): UseChatToolCallModalStateResult;
+export {};

package/umd/src/book-components/Chat/Chat/useChatToolCallState.d.ts

@@ -0,0 +1,35 @@
+import type { ToolCall } from '../../../types/ToolCall';
+import type { ChatMessage } from '../types/ChatMessage';
+import type { ParsedCitation } from '../utils/parseCitationsFromContent';
+/**
+ * Inputs required to keep Chat tool-call and citation modals in sync.
+ *
+ * @private function of `useChatToolCallState`
+ */
+type UseChatToolCallStateProps = {
+    messages: ReadonlyArray<ChatMessage>;
+};
+/**
+ * State and callbacks exposed back to `<Chat/>`.
+ *
+ * @private function of `useChatToolCallState`
+ */
+type UseChatToolCallStateResult = {
+    readonly citationModalOpen: boolean;
+    readonly closeCitationModal: () => void;
+    readonly closeToolCallModal: () => void;
+    readonly openCitation: (citation: ParsedCitation) => void;
+    readonly openToolCall: (toolCall: ToolCall) => void;
+    readonly selectedCitation: ParsedCitation | null;
+    readonly selectedMessageAvailableTools: ChatMessage['availableTools'];
+    readonly selectedToolCall: ToolCall | null;
+    readonly selectedToolCallIdentity: string | null;
+    readonly toolCallModalOpen: boolean;
+};
+/**
+ * Keeps Chat modal state focused on one selected tool call or citation.
+ *
+ * @private function of `<Chat/>`
+ */
+export declare function useChatToolCallState({ messages }: UseChatToolCallStateProps): UseChatToolCallStateResult;
+export {};

package/umd/src/book-components/Chat/LlmChat/useLlmChatMessageHandler.d.ts

@@ -0,0 +1,58 @@
+import { type Dispatch, type MutableRefObject, type SetStateAction } from 'react';
+import type { LlmExecutionTools } from '../../../execution/LlmExecutionTools';
+import type { id } from '../../../types/typeAliases';
+import type { ChatMessage } from '../types/ChatMessage';
+import type { LlmChatProps } from './LlmChatProps';
+/**
+ * Minimal task-progress item rendered by `<Chat/>`.
+ *
+ * @private function of `useLlmChatMessageHandler`
+ */
+type LlmChatTaskProgress = {
+    readonly id: string;
+    readonly name: string;
+    readonly progress?: number;
+};
+/**
+ * Internal send signature shared across retry and visibility-recovery flows.
+ *
+ * @private function of `useLlmChatMessageHandler`
+ */
+type HandleMessageFn = (messageContent: string, attachments?: ChatMessage['attachments']) => Promise<void>;
+/**
+ * Inputs required by `useLlmChatMessageHandler`.
+ *
+ * @private function of `useLlmChatMessageHandler`
+ */
+type UseLlmChatMessageHandlerProps = {
+    readonly chatFailMessage: string;
+    readonly hasUserInteractedRef: MutableRefObject<boolean>;
+    readonly llmParticipantName: id;
+    readonly llmTools: LlmExecutionTools;
+    readonly messages: ReadonlyArray<ChatMessage>;
+    readonly onError?: LlmChatProps['onError'];
+    readonly promptParameters: Record<string, string>;
+    readonly setMessages: Dispatch<SetStateAction<Array<ChatMessage>>>;
+    readonly setTasksProgress: Dispatch<SetStateAction<Array<LlmChatTaskProgress>>>;
+    readonly thinkingVariants: ReadonlyArray<string>;
+    readonly thread?: ReadonlyArray<ChatMessage>;
+    readonly userParticipantName: id;
+};
+/**
+ * State and handlers returned by `useLlmChatMessageHandler`.
+ *
+ * @private function of `useLlmChatMessageHandler`
+ */
+type UseLlmChatMessageHandlerResult = {
+    readonly clearLastFailedMessage: () => void;
+    readonly handleMessage: HandleMessageFn;
+    readonly handleStopStreaming: () => void;
+    readonly isStreaming: boolean;
+};
+/**
+ * Manages send, stream, retry, and background-recovery flows for `<LlmChat/>`.
+ *
+ * @private function of `useLlmChatState`
+ */
+export declare function useLlmChatMessageHandler(props: UseLlmChatMessageHandlerProps): UseLlmChatMessageHandlerResult;
+export {};

package/umd/src/book-components/Chat/LlmChat/useLlmChatMessages.d.ts

@@ -0,0 +1,29 @@
+import { type Dispatch, type MutableRefObject, type SetStateAction } from 'react';
+import type { ChatMessage } from '../types/ChatMessage';
+/**
+ * Inputs required to manage the persisted `<LlmChat/>` message list.
+ *
+ * @private function of `useLlmChatMessages`
+ */
+type UseLlmChatMessagesProps = {
+    readonly initialMessages?: ReadonlyArray<ChatMessage>;
+    readonly persistenceKey?: string;
+};
+/**
+ * State and helpers returned by `useLlmChatMessages`.
+ *
+ * @private function of `useLlmChatMessages`
+ */
+type UseLlmChatMessagesResult = {
+    readonly buildInitialMessages: () => Array<ChatMessage>;
+    readonly hasUserInteractedRef: MutableRefObject<boolean>;
+    readonly messages: Array<ChatMessage>;
+    readonly setMessages: Dispatch<SetStateAction<Array<ChatMessage>>>;
+};
+/**
+ * Manages initial seeding plus optional local persistence for `<LlmChat/>`.
+ *
+ * @private function of `useLlmChatState`
+ */
+export declare function useLlmChatMessages(props: UseLlmChatMessagesProps): UseLlmChatMessagesResult;
+export {};

package/umd/src/book-components/Chat/LlmChat/useLlmChatState.d.ts

@@ -0,0 +1,53 @@
+import type { ChatMessage } from '../types/ChatMessage';
+import type { ChatParticipant } from '../types/ChatParticipant';
+import type { LlmChatProps } from './LlmChatProps';
+/**
+ * Metadata for a teammate agent tool.
+ *
+ * @private function of `useLlmChatState`
+ */
+type TeammateMetadata = {
+    readonly url: string;
+    readonly label?: string;
+    readonly instructions?: string;
+    readonly toolName: string;
+};
+/**
+ * Lookup map of teammate metadata by tool name.
+ *
+ * @private function of `useLlmChatState`
+ */
+type TeammatesMap = Record<string, TeammateMetadata>;
+/**
+ * Minimal task-progress item rendered by `<Chat/>`.
+ *
+ * @private function of `useLlmChatState`
+ */
+type LlmChatTaskProgress = {
+    readonly id: string;
+    readonly name: string;
+    readonly progress?: number;
+};
+/**
+ * State returned by `useLlmChatState`.
+ *
+ * @private function of `useLlmChatState`
+ */
+type UseLlmChatStateResult = {
+    readonly handleMessage: (messageContent: string, attachments?: ChatMessage['attachments']) => Promise<void>;
+    readonly handleReset: () => Promise<void>;
+    readonly handleStopStreaming: () => void;
+    readonly isStreaming: boolean;
+    readonly isVoiceCalling: boolean;
+    readonly messages: Array<ChatMessage>;
+    readonly participants: ReadonlyArray<ChatParticipant>;
+    readonly tasksProgress: Array<LlmChatTaskProgress>;
+    readonly teammates: TeammatesMap | undefined;
+};
+/**
+ * Coordinates derived state and handlers consumed by `<LlmChat/>`.
+ *
+ * @private function of `<LlmChat/>`
+ */
+export declare function useLlmChatState(props: LlmChatProps): UseLlmChatStateResult;
+export {};

package/umd/src/collection/pipeline-collection/constructors/createPipelineCollectionFromDirectory.d.ts

@@ -43,6 +43,12 @@ type CreatePipelineCollectionFromDirectoryOptions = Omit<PrepareAndScrapeOptions
      */
     isCrashedOnError?: boolean;
 };
+/**
+ * Tools used by `createPipelineCollectionFromDirectory`.
+ *
+ * @private internal function of `createPipelineCollectionFromDirectory`
+ */
+type CreatePipelineCollectionFromDirectoryTools = Pick<ExecutionTools, 'llm' | 'fs' | 'scrapers'>;
 /**
  * Constructs `PipelineCollection` from given directory
  *
@@ -55,5 +61,5 @@ type CreatePipelineCollectionFromDirectoryOptions = Omit<PrepareAndScrapeOptions
  *
  * @public exported from `@promptbook/node`
  */
-export declare function createPipelineCollectionFromDirectory(rootPath: string_dirname, tools?: Pick<ExecutionTools, 'llm' | 'fs' | 'scrapers'>, options?: CreatePipelineCollectionFromDirectoryOptions): Promise<PipelineCollection>;
+export declare function createPipelineCollectionFromDirectory(rootPath: string_dirname, tools?: CreatePipelineCollectionFromDirectoryTools, options?: CreatePipelineCollectionFromDirectoryOptions): Promise<PipelineCollection>;
 export {};

package/umd/src/llm-providers/agent/AgentLlmExecutionTools.d.ts

@@ -84,4 +84,56 @@ export declare class AgentLlmExecutionTools implements LlmExecutionTools {
      * Calls the chat model with agent-specific system prompt and requirements with streaming
      */
     callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void, options?: CallChatModelStreamOptions): Promise<ChatPromptResult>;
+    /**
+     * Ensures the agent wrapper only processes chat prompts.
+     */
+    private requireChatPrompt;
+    /**
+     * Resolves agent requirements, attachments, and runtime overrides into one forwarded chat prompt.
+     */
+    private prepareChatPrompt;
+    /**
+     * Removes bookkeeping-only properties from compiled agent requirements before forwarding them.
+     */
+    private getSanitizedAgentModelRequirements;
+    /**
+     * Dispatches one prepared agent prompt to the correct underlying LLM backend.
+     */
+    private callPreparedChatModelStream;
+    /**
+     * Runs one prepared prompt through the OpenAI AgentKit backend.
+     */
+    private callOpenAiAgentKitChatModelStream;
+    /**
+     * Resolves the AgentKit cache state for the current prompt, including external and in-memory caches.
+     */
+    private resolveAgentKitCacheState;
+    /**
+     * Returns a prepared AgentKit agent, creating one only when the cache could not satisfy the request.
+     */
+    private getOrPrepareAgentKitAgent;
+    /**
+     * Stores freshly prepared AgentKit resources back into the in-memory caches when caching is allowed.
+     */
+    private storeAgentKitCache;
+    /**
+     * Runs one prepared prompt through the deprecated OpenAI Assistant backend.
+     */
+    private callOpenAiAssistantChatModelStream;
+    /**
+     * Returns an assistant instance matching the current agent requirements, reusing caches when possible.
+     */
+    private getOrPrepareOpenAiAssistant;
+    /**
+     * Stores one assistant id in the shared assistant cache for this agent title.
+     */
+    private storeAssistantCache;
+    /**
+     * Runs one prepared prompt through generic LLM tools that do not need special assistant preparation.
+     */
+    private callGenericChatModelStream;
+    /**
+     * Applies the final agent-level content normalization to the underlying LLM result.
+     */
+    private finalizeAgentResult;
 }

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

@@ -40,6 +40,134 @@ 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.
+     */
+    private assertSupportedAssistantModelRequirements;
+    /**
+     * 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
      */

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

@@ -49,11 +49,11 @@ 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.
      */

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

@@ -6,6 +6,8 @@ import type { OpenAiCompatibleExecutionToolsOptions } from './OpenAiCompatibleEx
 import { OpenAiExecutionTools } from './OpenAiExecutionTools';
 /**
  * Metadata for uploaded knowledge source files used for vector store diagnostics.
+ *
+ * @private internal utility of `OpenAiVectorStoreHandler`
  */
 type KnowledgeSourceUploadMetadata = {
     readonly fileId: string;
@@ -117,6 +119,58 @@ export declare abstract class OpenAiVectorStoreHandler extends OpenAiExecutionTo
         readonly totalBytes: number;
         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;
+    /**
+     * Polls the created vector-store batch until ingestion completes, fails, or times out.
+     */
+    private pollVectorStoreFileBatchUntilSettled;
+    /**
+     * 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;
     /**
      * Creates a vector store and uploads knowledge sources, returning its ID.
      */

package/umd/src/llm-providers/openai/utils/OpenAiCompatibleUnsupportedParameterRetrier.d.ts

@@ -0,0 +1,29 @@
+import type { ModelRequirements } from '../../../types/ModelRequirements';
+import type { string_model_name } from '../../../types/typeAliases';
+/**
+ * Tracks unsupported-parameter retries for one OpenAI-compatible model call.
+ *
+ * @private helper of `OpenAiCompatibleExecutionTools`
+ */
+export declare class OpenAiCompatibleUnsupportedParameterRetrier {
+    private readonly isVerbose;
+    private readonly attemptStack;
+    private readonly retriedUnsupportedParameters;
+    constructor(isVerbose: boolean | undefined);
+    /**
+     * Resolves the next retry attempt after an unsupported-parameter failure or rethrows the final error.
+     */
+    resolveRetryOrThrow<TModelRequirements extends ModelRequirements>(options: {
+        readonly error: Error;
+        readonly modelName: string_model_name;
+        readonly currentModelRequirements: TModelRequirements;
+    }): TModelRequirements;
+    /**
+     * Rethrows the original error or wraps it with the collected retry history.
+     */
+    private throwWithAttemptHistory;
+    /**
+     * Creates the retry-history error message shared by all OpenAI-compatible model variants.
+     */
+    private createAttemptHistoryError;
+}