@promptbook/remote-client 0.111.0-7 → 0.112.0-101

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

@@ -1,49 +1,13 @@
 import { Agent as AgentFromKit } from '@openai/agents';
-import OpenAI from 'openai';
-import { TODO_any } from '../../_packages/types.index';
-import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+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, 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 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 JsonSchemaDefinitionEntry = {
-    type?: string;
-    description?: string;
-    properties?: Record<string, JsonSchemaDefinitionEntry>;
-    required?: Array<string>;
-    items?: JsonSchemaDefinitionEntry;
-    [key: string]: TODO_any;
-};
-type JsonSchemaDefinition = {
-    type: 'json_schema';
-    name: string;
-    strict: boolean;
-    schema: {
-        type: 'object';
-        properties: Record<string, JsonSchemaDefinitionEntry>;
-        required: Array<string>;
-        additionalProperties: boolean;
-        description?: string;
-    };
-};
-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.
  */
@@ -55,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).
  *
@@ -63,6 +31,8 @@ type OpenAiAgentKitPreparedAgent = {
 export declare class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandler implements LlmExecutionTools {
     private preparedAgentKitAgent;
     private readonly agentKitModelName;
+    private readonly inputBuilder;
+    private readonly toolBuilder;
     /**
      * Creates OpenAI AgentKit execution tools.
      */
@@ -76,7 +46,7 @@ export declare class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandl
     /**
      * Calls OpenAI AgentKit with a chat prompt (streaming).
      */
-    callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void): Promise<ChatPromptResult>;
+    callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void, options?: CallChatModelStreamOptions): Promise<ChatPromptResult>;
     /**
      * Returns a prepared AgentKit agent when the server wants to manage caching externally.
      */
@@ -100,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.
      */
@@ -119,25 +77,31 @@ export declare class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandl
         readonly openAiAgentKitAgent: OpenAiAgentKitAgent;
         readonly prompt: Prompt;
         readonly rawPromptContent?: string;
-        readonly onProgress: (chunk: ChatPromptResult) => void;
-        readonly responseFormatOutputType?: AgentOutputType;
+        readonly onProgress: (chunk: ChatPromptResult & {
+            isFinished?: boolean;
+        }) => void;
+        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.
+     * Ensures the AgentKit SDK is wired to the OpenAI client and API key.
      */
-    private buildAgentKitUserContent;
+    private ensureAgentKitDefaults;
     /**
-     * Normalizes AgentKit tool outputs into a string for Promptbook tool call results.
+     * Builds the tool list for AgentKit while keeping the public facade small.
      */
-    private formatAgentKitToolOutput;
+    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/OpenAiAgentKitExecutionTools.test.d.ts

@@ -0,0 +1 @@
+export {};

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/OpenAiAgentKitExecutionToolsOptions.d.ts

@@ -1,4 +1,4 @@
-import type { string_model_name } from '../../types/typeAliases';
+import type { string_model_name } from '../../types/string_model_name';
 import type { OpenAiVectorStoreHandlerOptions } from './OpenAiVectorStoreHandler';
 /**
  * Options for `OpenAiAgentKitExecutionTools`.

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

@@ -1,8 +1,10 @@
-import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+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, string_title, string_token } from '../../types/typeAliases';
+import type { string_markdown, string_markdown_text } from '../../types/string_markdown';
+import type { string_title } from '../../types/string_title';
+import type { string_token } from '../../types/string_token';
 import type { OpenAiAssistantExecutionToolsOptions } from './OpenAiAssistantExecutionToolsOptions';
 import { OpenAiVectorStoreHandler } from './OpenAiVectorStoreHandler';
 /**
@@ -18,11 +20,16 @@ import { OpenAiVectorStoreHandler } from './OpenAiVectorStoreHandler';
  * - `RemoteAgent` - which is an `Agent` that connects to a Promptbook Agents Server
  *
  * @deprecated Use `OpenAiAgentKitExecutionTools` instead.
+ *
  * @public exported from `@promptbook/openai`
  */
 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.
      *
@@ -38,7 +45,15 @@ export declare class OpenAiAssistantExecutionTools extends OpenAiVectorStoreHand
     /**
      * Calls OpenAI API to use a chat model with streaming.
      */
-    callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void): Promise<ChatPromptResult>;
+    callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void, options?: CallChatModelStreamOptions): Promise<ChatPromptResult>;
+    /**
+     * 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;
     /**
      * Get an existing assistant tool wrapper
      */
@@ -83,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
      */
@@ -94,11 +129,3 @@ export declare class OpenAiAssistantExecutionTools extends OpenAiVectorStoreHand
      */
     static isOpenAiAssistantExecutionTools(llmExecutionTools: LlmExecutionTools): llmExecutionTools is OpenAiAssistantExecutionTools;
 }
-/**
- * TODO: !!!!! [✨🥚] Knowledge should work both with and without scrapers
- * TODO: [🙎] In `OpenAiAssistantExecutionTools` Allow to create abstract assistants with `isCreatingNewAssistantsAllowed`
- * TODO: [🧠][🧙‍♂️] Maybe there can be some wizard for those who want to use just OpenAI
- * TODO: Maybe make custom OpenAiError
- * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
- * TODO: [🧠][🌰] Allow to pass `title` for tracking purposes
- */

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

@@ -1,4 +1,4 @@
-import type { string_token } from '../../types/typeAliases';
+import type { string_token } from '../../types/string_token';
 import type { OpenAiVectorStoreHandlerOptions } from './OpenAiVectorStoreHandler';
 /**
  * Options for `createOpenAiAssistantExecutionTools` and `OpenAiAssistantExecutionTools`

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 {};