@promptbook/browser 0.112.0-71 → 0.112.0-73

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

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

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

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

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

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

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

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

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

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

package/esm/src/llm-providers/openai/utils/OpenAiCompatibleChatProgressReporter.d.ts

@@ -0,0 +1,86 @@
+import type OpenAI from 'openai';
+import type { ToolCallProgressUpdate } from '../../../commitments/_common/toolRuntimeContext';
+import type { serializeError } from '../../../errors/utils/serializeError';
+import type { ChatPromptResult } from '../../../execution/PromptResult';
+import type { Usage } from '../../../execution/Usage';
+import type { string_model_name } from '../../../types/string_model_name';
+import type { string_date_iso8601 } from '../../../types/string_token';
+import type { TODO_any } from '../../../utils/organization/TODO_any';
+/**
+ * Type describing streamed tool call.
+ */
+type StreamedToolCall = NonNullable<ChatPromptResult['toolCalls']>[number];
+/**
+ * Builds incremental chat progress updates, tool-call snapshots, and the final prompt result.
+ *
+ * @private helper of `callOpenAiCompatibleChatModel`
+ */
+export declare class OpenAiCompatibleChatProgressReporter {
+    /**
+     * Creates an empty usage accumulator for multi-turn chat requests.
+     */
+    createEmptyUsage(): Usage;
+    /**
+     * Creates the initial pending snapshot for one chat tool call.
+     */
+    createPendingToolCall(options: {
+        readonly toolCall: OpenAI.Chat.Completions.ChatCompletionMessageToolCall;
+        readonly functionName: string;
+        readonly functionArguments: TODO_any;
+        readonly calledAt: string_date_iso8601;
+    }): StreamedToolCall;
+    /**
+     * Appends one incremental progress update to the currently tracked tool-call snapshot.
+     */
+    applyToolCallProgressUpdate(toolCall: StreamedToolCall, update: ToolCallProgressUpdate): StreamedToolCall;
+    /**
+     * Finalizes one chat tool-call snapshot after execution ends.
+     */
+    createCompletedToolCall(options: {
+        readonly toolCall: OpenAI.Chat.Completions.ChatCompletionMessageToolCall;
+        readonly functionName: string;
+        readonly calledAt: string_date_iso8601;
+        readonly currentToolCallSnapshot: StreamedToolCall;
+        readonly toolResult: TODO_any;
+        readonly errors: Array<ReturnType<typeof serializeError>> | undefined;
+    }): StreamedToolCall;
+    /**
+     * Emits one chat progress chunk with shared timing, request metadata, and tool-call snapshots.
+     */
+    emitProgress(options: {
+        readonly start: string_date_iso8601;
+        readonly complete?: string_date_iso8601;
+        readonly rawPromptContent: string;
+        readonly onProgress: (chunk: ChatPromptResult) => void;
+        readonly content: string;
+        readonly modelName: string;
+        readonly usage: Usage;
+        readonly rawRequest: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
+        readonly rawResponse: OpenAI.Chat.Completions.ChatCompletion;
+        readonly toolCalls?: ChatPromptResult['toolCalls'];
+    }): void;
+    /**
+     * Creates the final chat prompt result after the tool loop has finished.
+     */
+    createChatPromptResult(options: {
+        readonly title: string;
+        readonly responseMessage: OpenAI.Chat.Completions.ChatCompletionMessage;
+        readonly rawPromptContent: string;
+        readonly rawRequest: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
+        readonly rawResponse: OpenAI.Chat.Completions.ChatCompletion;
+        readonly modelName: string_model_name;
+        readonly start: string_date_iso8601;
+        readonly complete: string_date_iso8601;
+        readonly usage: Usage;
+        readonly toolCalls: Array<StreamedToolCall>;
+    }): ChatPromptResult;
+    /**
+     * Creates one structured log entry for streamed tool-call updates.
+     */
+    private createToolCallLogEntry;
+    /**
+     * Resolves the final lifecycle state for one tool call after execution ends.
+     */
+    private resolveFinalToolCallState;
+}
+export {};

package/esm/src/llm-providers/openai/utils/OpenAiCompatibleChatPromptBuilder.d.ts

@@ -0,0 +1,57 @@
+import type OpenAI from 'openai';
+import type { ChatModelRequirements } from '../../../types/ModelRequirements';
+import type { Prompt } from '../../../types/Prompt';
+import type { string_model_name } from '../../../types/string_model_name';
+import type { TODO_any } from '../../../utils/organization/TODO_any';
+/**
+ * Builds cloned prompt payloads, OpenAI messages, and raw chat requests.
+ *
+ * @private helper of `callOpenAiCompatibleChatModel`
+ */
+export declare class OpenAiCompatibleChatPromptBuilder {
+    /**
+     * Creates a deep copy of the prompt while keeping attached files intact when structured clone is not available.
+     */
+    clonePromptPreservingFiles(prompt: Prompt): Prompt;
+    /**
+     * Resolves OpenAI chat creation settings from model requirements and prompt format.
+     */
+    createModelSettings(options: {
+        readonly currentModelRequirements: ChatModelRequirements;
+        readonly format?: Prompt['format'];
+        readonly modelName: string_model_name;
+    }): OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
+    /**
+     * Creates the full OpenAI chat message list, including system, thread, and user content.
+     */
+    createMessages(options: {
+        readonly prompt: Prompt;
+        readonly currentModelRequirements: ChatModelRequirements;
+        readonly rawPromptContent: string;
+    }): Promise<Array<OpenAI.Chat.Completions.ChatCompletionMessageParam>>;
+    /**
+     * Creates one raw OpenAI chat request from the current conversation state.
+     */
+    createRawRequest(options: {
+        readonly modelSettings: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
+        readonly messages: Array<OpenAI.Chat.Completions.ChatCompletionMessageParam>;
+        readonly tools: ReadonlyArray<TODO_any> | undefined;
+        readonly userId: string | number | undefined;
+    }): OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
+    /**
+     * Provides access to the structured clone implementation when available.
+     */
+    private getStructuredCloneFunction;
+    /**
+     * Checks whether the prompt is a chat prompt that carries file attachments.
+     */
+    private hasChatPromptFiles;
+    /**
+     * Converts the existing prompt thread into OpenAI chat messages.
+     */
+    private createThreadMessages;
+    /**
+     * Builds the final user message, including inline image attachments when present.
+     */
+    private createPromptUserMessage;
+}

package/esm/src/llm-providers/openai/utils/OpenAiCompatibleChatToolCaller.d.ts

@@ -0,0 +1,57 @@
+import type OpenAI from 'openai';
+import type { ChatPromptResult } from '../../../execution/PromptResult';
+import type { Usage } from '../../../execution/Usage';
+import type { Prompt } from '../../../types/Prompt';
+import type { string_date_iso8601 } from '../../../types/string_token';
+import type { OpenAiCompatibleExecutionToolsNonProxiedOptions } from '../OpenAiCompatibleExecutionToolsOptions';
+import { OpenAiCompatibleChatProgressReporter } from './OpenAiCompatibleChatProgressReporter';
+/**
+ * Type describing streamed tool call.
+ */
+type StreamedToolCall = NonNullable<ChatPromptResult['toolCalls']>[number];
+/**
+ * Dependencies required to execute tool calls requested by an OpenAI-compatible chat response.
+ */
+type OpenAiCompatibleChatToolCallerOptions = {
+    readonly executionToolsOptions: OpenAiCompatibleExecutionToolsNonProxiedOptions;
+    readonly progressReporter: OpenAiCompatibleChatProgressReporter;
+};
+/**
+ * Executes chat-requested tools and keeps their progress snapshots in sync with streamed progress updates.
+ *
+ * @private helper of `callOpenAiCompatibleChatModel`
+ */
+export declare class OpenAiCompatibleChatToolCaller {
+    private readonly options;
+    constructor(options: OpenAiCompatibleChatToolCallerOptions);
+    /**
+     * Executes all tool calls requested in one assistant response and appends their results to the conversation.
+     */
+    handleToolCalls(options: {
+        readonly prompt: Prompt;
+        readonly start: string_date_iso8601;
+        readonly turnComplete: string_date_iso8601;
+        readonly rawPromptContent: string;
+        readonly responseMessage: OpenAI.Chat.Completions.ChatCompletionMessage;
+        readonly rawRequest: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
+        readonly rawResponse: OpenAI.Chat.Completions.ChatCompletion;
+        readonly modelName: string;
+        readonly usage: Usage;
+        readonly toolCalls: Array<StreamedToolCall>;
+        readonly messages: Array<OpenAI.Chat.Completions.ChatCompletionMessageParam>;
+        readonly onProgress: (chunk: ChatPromptResult) => void;
+    }): Promise<void>;
+    /**
+     * Executes one tool call requested by the chat response and appends the tool message.
+     */
+    private executeToolCall;
+    /**
+     * Resolves the configured script tools for chat tool execution.
+     */
+    private resolveScriptTools;
+    /**
+     * Executes the configured script tool for one chat-requested function call.
+     */
+    private executeFunctionTool;
+}
+export {};

package/esm/src/remote-server/startRemoteServer/RemoteServerRuntime.d.ts

@@ -0,0 +1,14 @@
+import type express from 'express';
+import type { ExecutionTask } from '../../execution/ExecutionTask';
+import type { StartRemoteServerConfiguration } from './StartRemoteServerConfiguration';
+/**
+ * Runtime state shared by HTTP and Socket.io handlers.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export type RemoteServerRuntime<TCustomOptions> = {
+    readonly app: express.Express;
+    readonly configuration: StartRemoteServerConfiguration<TCustomOptions>;
+    readonly runningExecutionTasks: Array<ExecutionTask>;
+    readonly startupDate: Date;
+};

package/esm/src/remote-server/startRemoteServer/SocketResponse.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Internal representation of a socket response payload.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export type SocketResponse<TPayload> = {
+    readonly eventName: string;
+    readonly payload: TPayload;
+};

package/esm/src/remote-server/startRemoteServer/StartRemoteServerConfiguration.d.ts

@@ -0,0 +1,18 @@
+import type { ApplicationRemoteServerOptions, RemoteServerOptions } from '../types/RemoteServerOptions';
+/**
+ * Normalized configuration shared by remote-server helpers.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export type StartRemoteServerConfiguration<TCustomOptions> = {
+    readonly port: RemoteServerOptions<TCustomOptions>['port'];
+    readonly collection: ApplicationRemoteServerOptions<TCustomOptions>['collection'] | null;
+    readonly createExecutionTools: RemoteServerOptions<TCustomOptions>['createExecutionTools'];
+    readonly createLlmExecutionTools: ApplicationRemoteServerOptions<TCustomOptions>['createLlmExecutionTools'] | null;
+    readonly isAnonymousModeAllowed: boolean;
+    readonly isApplicationModeAllowed: boolean;
+    readonly isRichUi: boolean | undefined;
+    readonly isVerbose: boolean;
+    readonly login: ApplicationRemoteServerOptions<TCustomOptions>['login'] | null;
+    readonly startOptions: RemoteServerOptions<TCustomOptions>;
+};

package/esm/src/remote-server/startRemoteServer/createRemoteServerExpressApp.d.ts

@@ -0,0 +1,7 @@
+import express from 'express';
+/**
+ * Creates the base express application with shared middleware.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export declare function createRemoteServerExpressApp(): express.Express;

package/esm/src/remote-server/startRemoteServer/createRemoteServerHandle.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import express from 'express';
+import http from 'http';
+import { Server } from 'socket.io';
+import type { RemoteServer } from '../RemoteServer';
+/**
+ * Creates the public RemoteServer handle with lazily exposed internals.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export declare function createRemoteServerHandle(app: express.Express, httpServer: http.Server, server: Server): RemoteServer;

package/esm/src/remote-server/startRemoteServer/createSocketServer.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import http from 'http';
+import { Server } from 'socket.io';
+/**
+ * Creates the Socket.io server with the existing transport and CORS settings.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export declare function createSocketServer(httpServer: http.Server): Server;

package/esm/src/remote-server/startRemoteServer/getExecutionToolsFromIdentification.d.ts

@@ -0,0 +1,12 @@
+import type { ExecutionTools } from '../../execution/ExecutionTools';
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import type { Identification } from '../socket-types/_subtypes/Identification';
+import type { StartRemoteServerConfiguration } from './StartRemoteServerConfiguration';
+/**
+ * Builds execution tools for a single incoming identification.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export declare function getExecutionToolsFromIdentification<TCustomOptions>(configuration: StartRemoteServerConfiguration<TCustomOptions>, identification: Identification<TCustomOptions> | null | undefined): Promise<ExecutionTools & {
+    llm: LlmExecutionTools;
+}>;

package/esm/src/remote-server/startRemoteServer/registerBookRoutes.d.ts

@@ -0,0 +1,7 @@
+import type { RemoteServerRuntime } from './RemoteServerRuntime';
+/**
+ * Registers book listing and book source download routes.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export declare function registerBookRoutes<TCustomOptions>(runtime: RemoteServerRuntime<TCustomOptions>): void;

package/esm/src/remote-server/startRemoteServer/registerExecutionRoutes.d.ts

@@ -0,0 +1,7 @@
+import type { RemoteServerRuntime } from './RemoteServerRuntime';
+/**
+ * Registers execution task listing, detail, and creation routes.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export declare function registerExecutionRoutes<TCustomOptions>(runtime: RemoteServerRuntime<TCustomOptions>): void;

package/esm/src/remote-server/startRemoteServer/registerListModelsSocketHandler.d.ts

@@ -0,0 +1,8 @@
+import type { Socket } from 'socket.io';
+import type { RemoteServerRuntime } from './RemoteServerRuntime';
+/**
+ * Registers the socket list-models request handler.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export declare function registerListModelsSocketHandler<TCustomOptions>(runtime: RemoteServerRuntime<TCustomOptions>, socket: Socket): void;

package/esm/src/remote-server/startRemoteServer/registerLoginRoute.d.ts

@@ -0,0 +1,7 @@
+import type { RemoteServerRuntime } from './RemoteServerRuntime';
+/**
+ * Registers the application-mode login endpoint.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export declare function registerLoginRoute<TCustomOptions>(runtime: RemoteServerRuntime<TCustomOptions>): void;

package/esm/src/remote-server/startRemoteServer/registerNotFoundRoute.d.ts

@@ -0,0 +1,7 @@
+import type express from 'express';
+/**
+ * Registers the catch-all 404 handler.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export declare function registerNotFoundRoute(app: express.Express): void;

package/esm/src/remote-server/startRemoteServer/registerOpenAiCompatibleChatCompletionsRoute.d.ts

@@ -0,0 +1,7 @@
+import type { RemoteServerRuntime } from './RemoteServerRuntime';
+/**
+ * Registers the OpenAI-compatible chat completions endpoint.
+ *
+ * @private internal utility of `startRemoteServer`
+ */
+export declare function registerOpenAiCompatibleChatCompletionsRoute<TCustomOptions>(runtime: RemoteServerRuntime<TCustomOptions>): void;