@promptbook/utils 0.112.0-72 → 0.112.0-73

package/esm/src/llm-providers/agent/AgentLlmExecutionToolsOpenAiAssistantRunner.d.ts

@@ -0,0 +1,43 @@
+import type { CallChatModelStreamOptions } from '../../execution/LlmExecutionTools';
+import type { ChatPromptResult, CommonPromptResult } from '../../execution/PromptResult';
+import type { Prompt } from '../../types/Prompt';
+import type { string_model_name } from '../../types/string_model_name';
+import type { string_title } from '../../types/string_title';
+import { OpenAiAssistantExecutionTools } from '../openai/OpenAiAssistantExecutionTools';
+import type { AgentLlmExecutionToolsPromptPreparer } from './AgentLlmExecutionToolsPromptPreparer';
+/**
+ * Handles deprecated OpenAI Assistant-backed executions for `AgentLlmExecutionTools`.
+ *
+ * @private internal utility of `AgentLlmExecutionTools`
+ */
+export declare class AgentLlmExecutionToolsOpenAiAssistantRunner {
+    private readonly context;
+    /**
+     * Cache of OpenAI assistants to avoid creating duplicates.
+     */
+    private static assistantCache;
+    constructor(context: {
+        readonly getTitle: () => string_title;
+        readonly getModelName: () => string_model_name;
+        readonly isVerbose?: boolean;
+        readonly assistantPreparationMode?: 'internal' | 'external';
+    });
+    /**
+     * Runs one prepared prompt through the deprecated OpenAI Assistant backend.
+     */
+    callChatModelStream(options: {
+        readonly llmTools: OpenAiAssistantExecutionTools;
+        readonly originalPrompt: Prompt;
+        readonly preparedChatPrompt: Awaited<ReturnType<AgentLlmExecutionToolsPromptPreparer['prepareChatPrompt']>>;
+        readonly onProgress: (chunk: ChatPromptResult) => void;
+        readonly streamOptions?: CallChatModelStreamOptions;
+    }): Promise<CommonPromptResult>;
+    /**
+     * 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;
+}

package/esm/src/llm-providers/agent/AgentLlmExecutionToolsPromptPreparer.d.ts

@@ -0,0 +1,41 @@
+import type { AgentModelRequirements } from '../../book-2.0/agent-source/AgentModelRequirements';
+import type { ChatPrompt, Prompt } from '../../types/Prompt';
+import type { string_title } from '../../types/string_title';
+/**
+ * Agent model requirements stripped of prompt-only bookkeeping before forwarding to runtime tools.
+ */
+type SanitizedAgentModelRequirements = Omit<AgentModelRequirements, '_metadata' | 'promptSuffix'>;
+/**
+ * Resolves runtime prompts into the fully enriched prompt shape forwarded by `AgentLlmExecutionTools`.
+ *
+ * @private internal utility of `AgentLlmExecutionTools`
+ */
+export declare class AgentLlmExecutionToolsPromptPreparer {
+    private readonly context;
+    constructor(context: {
+        readonly getModelRequirements: () => Promise<AgentModelRequirements>;
+        readonly getTitle: () => string_title;
+        readonly isVerbose?: boolean;
+        readonly hasPrecomputedModelRequirements: () => boolean;
+    });
+    /**
+     * Resolves agent requirements, attachments, and runtime overrides into one forwarded chat prompt.
+     */
+    prepareChatPrompt(prompt: Prompt): Promise<{
+        readonly forwardedPrompt: ChatPrompt;
+        readonly sanitizedRequirements: SanitizedAgentModelRequirements;
+        readonly mergedTools: Array<NonNullable<ChatPrompt['tools']>[number]>;
+        readonly knowledgeSourcesForAgent?: Array<string>;
+        readonly hasAttachmentSources: boolean;
+        readonly hasRuntimePromptTools: boolean;
+    }>;
+    /**
+     * Removes bookkeeping-only properties from compiled agent requirements before forwarding them.
+     */
+    private getSanitizedAgentModelRequirements;
+    /**
+     * Ensures the agent wrapper only processes chat prompts.
+     */
+    private requireChatPrompt;
+}
+export {};

package/esm/src/llm-providers/agent/emitAgentLlmExecutionToolsAssistantPreparationProgress.d.ts

@@ -0,0 +1,26 @@
+import type { ChatPromptResult } from '../../execution/PromptResult';
+import type { Prompt } from '../../types/Prompt';
+import type { string_model_name } from '../../types/string_model_name';
+/**
+ * Emits a progress update to signal assistant preparation before long setup work.
+ *
+ * @private internal utility of `AgentLlmExecutionTools`
+ */
+export declare function emitAgentLlmExecutionToolsAssistantPreparationProgress(options: {
+    /**
+     * Callback to send progress updates to the caller.
+     */
+    readonly onProgress: (chunk: ChatPromptResult) => void;
+    /**
+     * Original prompt being executed.
+     */
+    readonly prompt: Prompt;
+    /**
+     * Model name used for the update payload.
+     */
+    readonly modelName: string_model_name;
+    /**
+     * Optional detail describing the current preparation phase.
+     */
+    readonly phase?: string;
+}): void;

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

@@ -1,60 +1,13 @@
 import { Agent as AgentFromKit } from '@openai/agents';
-import OpenAI from 'openai';
 import type { CallChatModelStreamOptions, LlmExecutionTools } from '../../execution/LlmExecutionTools';
 import type { ChatPromptResult } from '../../execution/PromptResult';
 import type { ModelRequirements } from '../../types/ModelRequirements';
 import type { Prompt } from '../../types/Prompt';
 import type { string_markdown, string_markdown_text } from '../../types/string_markdown';
 import type { string_title } from '../../types/string_title';
-import type { TODO_any } from '../../utils/organization/TODO_any';
 import type { OpenAiAgentKitExecutionToolsOptions } from './OpenAiAgentKitExecutionToolsOptions';
+import { OpenAiAgentKitExecutionToolsOutputTypeMapper } from './OpenAiAgentKitExecutionToolsOutputTypeMapper';
 import { OpenAiVectorStoreHandler } from './OpenAiVectorStoreHandler';
-/**
- * Represents the AgentKit output configuration used to match OpenAI `response_format` expectations.
- *
- * @private utility of Open AI
- */
-export type AgentOutputType = 'text' | JsonSchemaDefinition;
-/**
- * Type describing Json schema definition entry.
- */
-type JsonSchemaDefinitionEntry = {
-    type?: string;
-    description?: string;
-    properties?: Record<string, JsonSchemaDefinitionEntry>;
-    required?: Array<string>;
-    items?: JsonSchemaDefinitionEntry;
-    [key: string]: TODO_any;
-};
-/**
- * Definition of Json schema.
- */
-type JsonSchemaDefinition = {
-    type: 'json_schema';
-    name: string;
-    strict: boolean;
-    schema: {
-        type: 'object';
-        properties: Record<string, JsonSchemaDefinitionEntry>;
-        required: Array<string>;
-        additionalProperties: boolean;
-        description?: string;
-    };
-};
-/**
- * Type describing open Ai chat response format.
- */
-type OpenAiChatResponseFormat = OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming['response_format'];
-/**
- * Maps OpenAI `response_format` payloads to AgentKit output types so the runner can forward
- * structured-output preferences to OpenAI while still reusing the same AgentKit agent instance.
- *
- * @param responseFormat - The OpenAI `response_format` payload from the user request.
- * @returns An Agent output type compatible with the requested schema or `undefined` when no impact is required.
- *
- * @private utility of Open AI
- */
-export declare function mapResponseFormatToAgentOutputType(responseFormat?: OpenAiChatResponseFormat): AgentOutputType | undefined;
 /**
  * Alias for OpenAI AgentKit agent to avoid naming confusion with Promptbook agents.
  */
@@ -66,6 +19,10 @@ type OpenAiAgentKitPreparedAgent = {
     readonly agent: OpenAiAgentKitAgent;
     readonly vectorStoreId?: string;
 };
+/**
+ * AgentKit output type returned by the dedicated response-format mapper.
+ */
+type OpenAiAgentKitAgentOutputType = ReturnType<typeof OpenAiAgentKitExecutionToolsOutputTypeMapper.mapResponseFormatToAgentOutputType>;
 /**
  * Execution tools for OpenAI AgentKit (Agents SDK).
  *
@@ -73,9 +30,9 @@ type OpenAiAgentKitPreparedAgent = {
  */
 export declare class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandler implements LlmExecutionTools {
     private preparedAgentKitAgent;
-    private readonly agentKitToolResultsByCallId;
-    private readonly agentKitToolSnapshotsByCallId;
     private readonly agentKitModelName;
+    private readonly inputBuilder;
+    private readonly toolBuilder;
     /**
      * Creates OpenAI AgentKit execution tools.
      */
@@ -113,18 +70,6 @@ export declare class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandl
         readonly vectorStoreId?: string;
         readonly storeAsPrepared?: boolean;
     }): Promise<OpenAiAgentKitPreparedAgent>;
-    /**
-     * Ensures the AgentKit SDK is wired to the OpenAI client and API key.
-     */
-    private ensureAgentKitDefaults;
-    /**
-     * Builds the tool list for AgentKit, including hosted file search when applicable.
-     */
-    private buildAgentKitTools;
-    /**
-     * Resolves the configured script tools for tool execution.
-     */
-    private resolveScriptTools;
     /**
      * Runs a prepared AgentKit agent and streams results back to the caller.
      */
@@ -135,50 +80,28 @@ export declare class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandl
         readonly onProgress: (chunk: ChatPromptResult & {
             isFinished?: boolean;
         }) => void;
-        readonly responseFormatOutputType?: AgentOutputType;
+        readonly responseFormatOutputType?: OpenAiAgentKitAgentOutputType;
         /**
          * Optional abort signal propagated from chat surfaces so stream generation can be cancelled.
          */
         readonly signal?: AbortSignal;
     }): Promise<ChatPromptResult>;
     /**
-     * Builds AgentKit input items from the prompt and optional thread.
-     */
-    private buildAgentKitInputItems;
-    /**
-     * Builds the user message content for AgentKit runs, including file inputs when provided.
-     */
-    private buildAgentKitUserContent;
-    /**
-     * Converts uploaded `File` objects into AgentKit `input_image` entries.
-     */
-    private createAgentKitInputImageItemsFromFiles;
-    /**
-     * Converts image chat attachments into AgentKit `input_image` entries.
-     *
-     * Note: This keeps images in the same completion request as multimodal input.
-     */
-    private createAgentKitInputImageItemsFromAttachments;
-    /**
-     * Builds AgentKit user content that can include text, uploaded files, and image attachments.
-     */
-    private buildAgentKitUserContentWithAttachments;
-    /**
-     * Normalizes AgentKit tool outputs into a string for Promptbook tool call results.
-     */
-    private formatAgentKitToolOutput;
-    /**
-     * Resolves the assistant-visible AgentKit tool response while preserving structured tool result data.
+     * Ensures the AgentKit SDK is wired to the OpenAI client and API key.
      */
-    private resolveAgentKitToolResponse;
+    private ensureAgentKitDefaults;
     /**
-     * Resolves the stored Promptbook tool result for one AgentKit tool call.
+     * Builds the tool list for AgentKit while keeping the public facade small.
      */
-    private resolveAgentKitToolOutputResult;
+    private buildAgentKitTools;
     /**
      * Returns AgentKit-specific options.
      */
     private get agentKitOptions();
+    /**
+     * Formats raw prompt content with the AgentKit model injected.
+     */
+    private templatePromptContent;
     /**
      * Discriminant for type guards.
      */

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

@@ -0,0 +1,41 @@
+import type { Prompt } from '../../types/Prompt';
+import type { TODO_any } from '../../utils/organization/TODO_any';
+/**
+ * Builds AgentKit input items, including multimodal attachments.
+ *
+ * @private helper of `OpenAiAgentKitExecutionTools`
+ */
+export declare class OpenAiAgentKitExecutionToolsInputBuilder {
+    /**
+     * Builds AgentKit input items from the prompt and optional thread.
+     */
+    buildAgentKitInputItems(prompt: Prompt, rawPromptContent: string): Promise<Array<TODO_any>>;
+    /**
+     * Builds the user message content for AgentKit runs, including file inputs when provided.
+     */
+    private buildAgentKitUserContent;
+    /**
+     * Converts uploaded `File` objects into AgentKit `input_image` entries.
+     */
+    private createAgentKitInputImageItemsFromFiles;
+    /**
+     * Converts image chat attachments into AgentKit `input_image` entries.
+     */
+    private createAgentKitInputImageItemsFromAttachments;
+    /**
+     * Builds AgentKit user content that can include text, uploaded files, and image attachments.
+     */
+    private buildAgentKitUserContentWithAttachments;
+    /**
+     * Checks whether one chat attachment can be sent as an image input.
+     */
+    private isImageAttachment;
+    /**
+     * Returns one lowercase extension extracted from a filename/pathname.
+     */
+    private getLowercaseFilenameExtension;
+    /**
+     * Tries to extract one extension from URL pathname.
+     */
+    private getUrlPathnameExtension;
+}

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

@@ -0,0 +1,56 @@
+import type OpenAI from 'openai';
+import type { TODO_any } from '../../utils/organization/TODO_any';
+/**
+ * Type describing Json schema definition entry.
+ */
+type JsonSchemaDefinitionEntry = {
+    type?: string;
+    description?: string;
+    properties?: Record<string, JsonSchemaDefinitionEntry>;
+    required?: Array<string>;
+    items?: JsonSchemaDefinitionEntry;
+    [key: string]: TODO_any;
+};
+/**
+ * Definition of Json schema.
+ */
+type JsonSchemaDefinition = {
+    type: 'json_schema';
+    name: string;
+    strict: boolean;
+    schema: {
+        type: 'object';
+        properties: Record<string, JsonSchemaDefinitionEntry>;
+        required: Array<string>;
+        additionalProperties: boolean;
+        description?: string;
+    };
+};
+/**
+ * Type describing open Ai chat response format.
+ */
+type OpenAiChatResponseFormat = OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming['response_format'];
+/**
+ * Maps OpenAI `response_format` payloads to AgentKit output types.
+ *
+ * @private helper of `OpenAiAgentKitExecutionTools`
+ */
+export declare class OpenAiAgentKitExecutionToolsOutputTypeMapper {
+    /**
+     * Maps one OpenAI `response_format` payload to the AgentKit output type shape.
+     */
+    static mapResponseFormatToAgentOutputType(responseFormat?: OpenAiChatResponseFormat): 'text' | JsonSchemaDefinition | undefined;
+    /**
+     * Determines whether a schema fragment includes meaningful constraints.
+     */
+    private static hasJsonSchemaContent;
+    /**
+     * Normalizes inline OpenAI JSON schema payloads to the AgentKit structure.
+     */
+    private static normalizeJsonSchemaInput;
+    /**
+     * Builds an AgentKit-compatible JSON schema definition from the supplied payload.
+     */
+    private static buildJsonSchemaDefinition;
+}
+export {};

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
      */