@promptbook/utils 0.103.0-9 → 0.104.0-0

package/esm/typings/src/llm-providers/_common/register/$provideLlmToolsForWizardOrCli.d.ts

@@ -1,7 +1,7 @@
 import { Promisable } from 'type-fest';
 import type { Identification } from '../../../remote-server/socket-types/_subtypes/Identification';
 import type { string_app_id, string_url } from '../../../types/typeAliases';
-import type { really_any } from '../../../utils/organization/really_any';
+import type { chococake } from '../../../utils/organization/really_any';
 import type { CacheLlmToolsOptions } from '../utils/cache/CacheLlmToolsOptions';
 import type { LlmExecutionToolsWithTotalUsage } from '../utils/count-total-usage/LlmExecutionToolsWithTotalUsage';
 type ProvideLlmToolsForWizardOrCliOptions = {
@@ -38,7 +38,7 @@ type ProvideLlmToolsForWizardOrCliOptions = {
      *
      * Note: When login prompt fails, `process.exit(1)` is called
      */
-    loginPrompt(): Promisable<Identification<really_any>>;
+    loginPrompt(): Promisable<Identification<chococake>>;
 });
 /**
  * Returns LLM tools for CLI

package/esm/typings/src/llm-providers/_common/register/$registeredLlmToolsMessage.d.ts

@@ -1,4 +1,5 @@
 import type { string_filename, string_markdown } from '../../../types/typeAliases';
+import type { $side_effect } from '../../../utils/organization/$side_effect';
 /**
  * Pass the `.env` file which was used to configure LLM tools
  *
@@ -6,7 +7,7 @@ import type { string_filename, string_markdown } from '../../../types/typeAliase
  *
  * @private internal log of `$provideLlmToolsConfigurationFromEnv` and `$registeredLlmToolsMessage`
  */
-export declare function $setUsedEnvFilename(filepath: string_filename): void;
+export declare function $setUsedEnvFilename(filepath: string_filename): $side_effect;
 /**
  * Creates a message with all registered LLM tools
  *

package/esm/typings/src/llm-providers/_common/register/LlmToolsMetadata.d.ts

@@ -26,7 +26,7 @@ export type LlmToolsMetadata = Registered & {
     /**
      * How is the model provider important and should be sorted in the list of available providers?
      */
-    readonly order: typeof MODEL_ORDERS[keyof typeof MODEL_ORDERS] | number;
+    readonly order: (typeof MODEL_ORDERS)[keyof typeof MODEL_ORDERS] | number;
     /**
      * List of environment variables that can be used to configure the provider
      *

package/esm/typings/src/llm-providers/_common/utils/assertUniqueModels.d.ts

@@ -0,0 +1,12 @@
+import { AvailableModel } from '../../../execution/AvailableModel';
+/**
+ * Utility to assert that all models in the provided array have unique `modelName` values.
+ *
+ * This is internal utility for unit tests to ensure no duplicate model names exist.
+ *
+ * @private internal utility of unit tests
+ */
+export declare function assertUniqueModels(models: ReadonlyArray<AvailableModel>): void;
+/**
+ * Note: [⚪] This should never be in any released package
+ */

package/esm/typings/src/llm-providers/_multiple/getSingleLlmExecutionTools.d.ts

@@ -7,5 +7,6 @@ import { MultipleLlmExecutionTools } from './MultipleLlmExecutionTools';
  */
 export declare function getSingleLlmExecutionTools(oneOrMoreLlmExecutionTools: undefined | LlmExecutionTools | ReadonlyArray<LlmExecutionTools>): LlmExecutionTools | MultipleLlmExecutionTools;
 /**
+ * TODO: [🙆] `getSingleLlmExecutionTools` vs `joinLlmExecutionTools` - explain difference or pick one
  * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
  */

package/esm/typings/src/llm-providers/_multiple/joinLlmExecutionTools.d.ts

@@ -18,5 +18,6 @@ import { MultipleLlmExecutionTools } from './MultipleLlmExecutionTools';
  */
 export declare function joinLlmExecutionTools(title: string_title & string_markdown_text, ...llmExecutionTools: ReadonlyArray<LlmExecutionTools>): MultipleLlmExecutionTools;
 /**
+ * TODO: [🙆] `getSingleLlmExecutionTools` vs `joinLlmExecutionTools` - explain difference or pick one
  * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
  */

package/esm/typings/src/llm-providers/agent/Agent.d.ts

@@ -0,0 +1,72 @@
+import { BehaviorSubject } from 'rxjs';
+import type { AgentBasicInformation, BookParameter } from '../../book-2.0/agent-source/AgentBasicInformation';
+import type { string_book } from '../../book-2.0/agent-source/string_book';
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import type { ChatPromptResult } from '../../execution/PromptResult';
+import type { Prompt } from '../../types/Prompt';
+import type { string_agent_hash, string_agent_name, string_agent_url, string_color, string_fonts, string_url_image } from '../../types/typeAliases';
+import { AgentLlmExecutionTools } from './AgentLlmExecutionTools';
+import type { AgentOptions } from './AgentOptions';
+/**
+ * Represents one AI Agent
+ *
+ * Note: [🦖] There are several different things in Promptbook:
+ * - `Agent` - which represents an AI Agent with its source, memories, actions, etc. Agent is a higher-level abstraction which is internally using:
+ * - `LlmExecutionTools` - which wraps one or more LLM models and provides an interface to execute them
+ * - `AgentLlmExecutionTools` - which is a specific implementation of `LlmExecutionTools` that wraps another LlmExecutionTools and applies agent-specific system prompts and requirements
+ * - `OpenAiAssistantExecutionTools` - which is a specific implementation of `LlmExecutionTools` for OpenAI models with assistant capabilities, recommended for usage in `Agent` or `AgentLlmExecutionTools`
+ * - `RemoteAgent` - which is an `Agent` that connects to a Promptbook Agents Server
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare class Agent extends AgentLlmExecutionTools implements LlmExecutionTools, AgentBasicInformation {
+    private _agentName;
+    /**
+     * Name of the agent
+     */
+    get agentName(): string_agent_name;
+    /**
+     * Description of the agent
+     */
+    personaDescription: string | null;
+    /**
+     * The initial message shown to the user when the chat starts
+     */
+    initialMessage: string | null;
+    /**
+     * Links found in the agent source
+     */
+    links: Array<string_agent_url>;
+    /**
+     * Computed hash of the agent source for integrity verification
+     */
+    get agentHash(): string_agent_hash;
+    /**
+     * Metadata like image or color
+     */
+    meta: {
+        fullname?: string;
+        image?: string_url_image;
+        link?: string;
+        font?: string_fonts;
+        color?: string_color;
+        title?: string;
+        description?: string;
+        [key: string]: string | undefined;
+    };
+    /**
+     * Not used in Agent, always returns empty array
+     */
+    get parameters(): BookParameter[];
+    readonly agentSource: BehaviorSubject<string_book>;
+    constructor(options: AgentOptions);
+    /**
+     * Calls the chat model with agent-specific system prompt and requirements with streaming
+     *
+     * Note: This method also implements the learning mechanism
+     */
+    callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void): Promise<ChatPromptResult>;
+}
+/**
+ * TODO: [🧠][😰]Agent is not working with the parameters, should it be?
+ */

package/esm/typings/src/llm-providers/agent/AgentLlmExecutionTools.d.ts

@@ -1,4 +1,5 @@
 import type { Promisable } from 'type-fest';
+import type { AgentModelRequirements } from '../../book-2.0/agent-source/AgentModelRequirements';
 import type { string_book } from '../../book-2.0/agent-source/string_book';
 import type { ChatParticipant } from '../../book-components/Chat/types/ChatParticipant';
 import type { AvailableModel } from '../../execution/AvailableModel';
@@ -6,15 +7,26 @@ import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
 import type { ChatPromptResult } from '../../execution/PromptResult';
 import type { Prompt } from '../../types/Prompt';
 import type { string_markdown, string_markdown_text, string_model_name, string_title } from '../../types/typeAliases';
+import type { CreateAgentLlmExecutionToolsOptions } from './CreateAgentLlmExecutionToolsOptions';
 /**
  * Execution Tools for calling LLM models with a predefined agent "soul"
  * This wraps underlying LLM execution tools and applies agent-specific system prompts and requirements
  *
+ * Note: [🦖] There are several different things in Promptbook:
+ * - `Agent` - which represents an AI Agent with its source, memories, actions, etc. Agent is a higher-level abstraction which is internally using:
+ * - `LlmExecutionTools` - which wraps one or more LLM models and provides an interface to execute them
+ * - `AgentLlmExecutionTools` - which is a specific implementation of `LlmExecutionTools` that wraps another LlmExecutionTools and applies agent-specific system prompts and requirements
+ * - `OpenAiAssistantExecutionTools` - which is a specific implementation of `LlmExecutionTools` for OpenAI models with assistant capabilities, recommended for usage in `Agent` or `AgentLlmExecutionTools`
+ * - `RemoteAgent` - which is an `Agent` that connects to a Promptbook Agents Server
+ *
  * @public exported from `@promptbook/core`
  */
 export declare class AgentLlmExecutionTools implements LlmExecutionTools {
-    private readonly llmTools;
-    private readonly agentSource;
+    private readonly options;
+    /**
+     * Cache of OpenAI assistants to avoid creating duplicates
+     */
+    private static assistantCache;
     /**
      * Cached model requirements to avoid re-parsing the agent source
      */
@@ -29,7 +41,13 @@ export declare class AgentLlmExecutionTools implements LlmExecutionTools {
      * @param llmTools The underlying LLM execution tools to wrap
      * @param agentSource The agent source string that defines the agent's behavior
      */
-    constructor(llmTools: LlmExecutionTools, agentSource: string_book);
+    constructor(options: CreateAgentLlmExecutionToolsOptions);
+    /**
+     * Updates the agent source and clears the cache
+     *
+     * @param agentSource The new agent source string
+     */
+    protected updateAgentSource(agentSource: string_book): void;
     /**
      * Get cached or parse agent information
      */
@@ -37,7 +55,7 @@ export declare class AgentLlmExecutionTools implements LlmExecutionTools {
     /**
      * Get cached or create agent model requirements
      */
-    private getAgentModelRequirements;
+    protected getAgentModelRequirements(): Promise<AgentModelRequirements>;
     get title(): string_title & string_markdown_text;
     get description(): string_markdown;
     get profile(): ChatParticipant | undefined;
@@ -51,6 +69,10 @@ export declare class AgentLlmExecutionTools implements LlmExecutionTools {
      * Calls the chat model with agent-specific system prompt and requirements
      */
     callChatModel(prompt: Prompt): Promise<ChatPromptResult>;
+    /**
+     * Calls the chat model with agent-specific system prompt and requirements with streaming
+     */
+    callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void): Promise<ChatPromptResult>;
 }
 /**
  * TODO: [🍚] Implement Destroyable pattern to free resources

package/esm/typings/src/llm-providers/agent/AgentOptions.d.ts

@@ -0,0 +1,19 @@
+import type { string_book } from '../../book-2.0/agent-source/string_book';
+import type { CommonToolsOptions } from '../../execution/CommonToolsOptions';
+import type { ExecutionTools } from '../../execution/ExecutionTools';
+import type { Updatable } from '../../types/Updatable';
+/**
+ * Options for creating an Agent
+ */
+export type AgentOptions = CommonToolsOptions & {
+    /**
+     * The execution tools available to the agent
+     *
+     * Here the agent has access to various LLM models, browser, scrapers, LibreOffice, tools, etc.
+     */
+    executionTools: ExecutionTools;
+    /**
+     * The source of the agent
+     */
+    agentSource: Updatable<string_book>;
+};

package/esm/typings/src/llm-providers/agent/CreateAgentLlmExecutionToolsOptions.d.ts

@@ -0,0 +1,17 @@
+import type { string_book } from '../../book-2.0/agent-source/string_book';
+import type { CommonToolsOptions } from '../../execution/CommonToolsOptions';
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import { OpenAiAssistantExecutionTools } from '../openai/OpenAiAssistantExecutionTools';
+/**
+ * Options for creating AgentLlmExecutionTools
+ */
+export type CreateAgentLlmExecutionToolsOptions = CommonToolsOptions & {
+    /**
+     * The underlying LLM execution tools to wrap
+     */
+    llmTools: LlmExecutionTools | OpenAiAssistantExecutionTools;
+    /**
+     * The agent source string that defines the agent's behavior
+     */
+    agentSource: string_book;
+};

package/esm/typings/src/llm-providers/agent/RemoteAgent.d.ts

@@ -0,0 +1,50 @@
+import type { ChatPromptResult } from '../../execution/PromptResult';
+import type { Prompt } from '../../types/Prompt';
+import type { string_agent_hash, string_agent_name } from '../../types/typeAliases';
+import { Agent } from './Agent';
+import type { RemoteAgentOptions } from './RemoteAgentOptions';
+/**
+ * Represents one AI Agent
+ *
+ * Note: [🦖] There are several different things in Promptbook:
+ * - `Agent` - which represents an AI Agent with its source, memories, actions, etc. Agent is a higher-level abstraction which is internally using:
+ * - `LlmExecutionTools` - which wraps one or more LLM models and provides an interface to execute them
+ * - `AgentLlmExecutionTools` - which is a specific implementation of `LlmExecutionTools` that wraps another LlmExecutionTools and applies agent-specific system prompts and requirements
+ * - `OpenAiAssistantExecutionTools` - which is a specific implementation of `LlmExecutionTools` for OpenAI models with assistant capabilities, recommended for usage in `Agent` or `AgentLlmExecutionTools`
+ * - `RemoteAgent` - which is an `Agent` that connects to a Promptbook Agents Server
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare class RemoteAgent extends Agent {
+    static connect(options: RemoteAgentOptions): Promise<RemoteAgent>;
+    /**
+     * The source of the agent
+     */
+    private agentUrl;
+    private _remoteAgentName;
+    private _remoteAgentHash;
+    private _isVoiceCallingEnabled;
+    private constructor();
+    get agentName(): string_agent_name;
+    get agentHash(): string_agent_hash;
+    /**
+     * Calls the agent on agents remote server
+     */
+    callChatModel(prompt: Prompt): Promise<ChatPromptResult>;
+    /**
+     * Calls the agent on agents remote server with voice
+     * [✨✷] Only available when voice calling is enabled on the server
+     * Returns undefined if voice calling is disabled
+     */
+    get callVoiceChatModel(): ((audio: Blob, prompt: Prompt) => Promise<{
+        text: string;
+        audio: Blob;
+        userMessage?: string;
+        agentMessage?: string;
+    }>) | undefined;
+    callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void): Promise<ChatPromptResult>;
+}
+/**
+ * TODO: [🧠][😰]Agent is not working with the parameters, should it be?
+ * TODO: !!! Agent on remote server
+ */

package/esm/typings/src/llm-providers/agent/RemoteAgentOptions.d.ts

@@ -0,0 +1,11 @@
+import type { CommonToolsOptions } from '../../execution/CommonToolsOptions';
+import type { string_agent_url } from '../../types/typeAliases';
+/**
+ * Options for creating a Remote Agent
+ */
+export type RemoteAgentOptions = CommonToolsOptions & {
+    /**
+     * Url of the remote agent
+     */
+    agentUrl: string_agent_url;
+};

package/esm/typings/src/llm-providers/agent/createAgentLlmExecutionTools.d.ts

@@ -1,19 +1,5 @@
-import type { string_book } from '../../book-2.0/agent-source/string_book';
-import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
 import { AgentLlmExecutionTools } from './AgentLlmExecutionTools';
-/**
- * Options for creating AgentLlmExecutionTools
- */
-export type CreateAgentLlmExecutionToolsOptions = {
-    /**
-     * The underlying LLM execution tools to wrap
-     */
-    llmTools: LlmExecutionTools;
-    /**
-     * The agent source string that defines the agent's behavior
-     */
-    agentSource: string_book;
-};
+import type { CreateAgentLlmExecutionToolsOptions } from './CreateAgentLlmExecutionToolsOptions';
 /**
  * Creates new AgentLlmExecutionTools that wrap underlying LLM tools with agent-specific behavior
  *
@@ -23,7 +9,3 @@ export declare const createAgentLlmExecutionTools: ((options: CreateAgentLlmExec
     packageName: string;
     className: string;
 };
-/**
- * TODO: [🧠] Consider adding validation for agent source format
- * TODO: [🧠] Consider adding options for caching behavior
- */

package/esm/typings/src/llm-providers/anthropic-claude/anthropic-claude-models.d.ts

@@ -3,7 +3,7 @@ import type { number_usd } from '../../types/typeAliases';
 /**
  * List of available Anthropic Claude models with pricing
  *
- * Note: Synced with official API docs at 2025-08-20
+ * Note: Synced with official API docs at 2025-11-19
  *
  * @see https://docs.anthropic.com/en/docs/models-overview
  * @public exported from `@promptbook/anthropic-claude`

package/esm/typings/src/llm-providers/google/google-models.d.ts

@@ -3,7 +3,7 @@ import type { number_usd } from '../../types/typeAliases';
 /**
  * List of available Google models with descriptions
  *
- * Note: Synced with official API docs at 2025-08-20
+ * Note: Synced with official API docs at 2025-11-19
  *
  * @see https://ai.google.dev/models/gemini
  * @public exported from `@promptbook/google`

package/esm/typings/src/llm-providers/ollama/OllamaExecutionTools.d.ts

@@ -38,6 +38,10 @@ export declare class OllamaExecutionTools extends OpenAiCompatibleExecutionTools
      * Default model for completion variant.
      */
     protected getDefaultEmbeddingModel(): AvailableModel;
+    /**
+     * Default model for image generation variant.
+     */
+    protected getDefaultImageGenerationModel(): AvailableModel;
 }
 /**
  * TODO: [🛄] Some way how to re-wrap the errors from `OpenAiCompatibleExecutionTools`

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

@@ -1,7 +1,7 @@
 import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
 import type { ChatPromptResult } from '../../execution/PromptResult';
 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, string_title, string_token } from '../../types/typeAliases';
 import type { OpenAiAssistantExecutionToolsOptions } from './OpenAiAssistantExecutionToolsOptions';
 import { OpenAiExecutionTools } from './OpenAiExecutionTools';
 /**
@@ -9,10 +9,18 @@ import { OpenAiExecutionTools } from './OpenAiExecutionTools';
  *
  * This is useful for calling OpenAI API with a single assistant, for more wide usage use `OpenAiExecutionTools`.
  *
+ * Note: [🦖] There are several different things in Promptbook:
+ * - `Agent` - which represents an AI Agent with its source, memories, actions, etc. Agent is a higher-level abstraction which is internally using:
+ * - `LlmExecutionTools` - which wraps one or more LLM models and provides an interface to execute them
+ * - `AgentLlmExecutionTools` - which is a specific implementation of `LlmExecutionTools` that wraps another LlmExecutionTools and applies agent-specific system prompts and requirements
+ * - `OpenAiAssistantExecutionTools` - which is a specific implementation of `LlmExecutionTools` for OpenAI models with assistant capabilities, recommended for usage in `Agent` or `AgentLlmExecutionTools`
+ * - `RemoteAgent` - which is an `Agent` that connects to a Promptbook Agents Server
+ *
  * @public exported from `@promptbook/openai`
  */
 export declare class OpenAiAssistantExecutionTools extends OpenAiExecutionTools implements LlmExecutionTools {
-    private readonly assistantId;
+    readonly assistantId: string_token;
+    private readonly isCreatingNewAssistantsAllowed;
     /**
      * Creates OpenAI Execution Tools.
      *
@@ -25,6 +33,56 @@ export declare class OpenAiAssistantExecutionTools extends OpenAiExecutionTools
      * Calls OpenAI API to use a chat model.
      */
     callChatModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements' | 'format'>): Promise<ChatPromptResult>;
+    /**
+     * Calls OpenAI API to use a chat model with streaming.
+     */
+    callChatModelStream(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements' | 'format'>, onProgress: (chunk: ChatPromptResult) => void): Promise<ChatPromptResult>;
+    /**
+     * Get an existing assistant tool wrapper
+     */
+    getAssistant(assistantId: string_token): OpenAiAssistantExecutionTools;
+    createNewAssistant(options: {
+        /**
+         * Name of the new assistant
+         */
+        readonly name: string_title;
+        /**
+         * Instructions for the new assistant
+         */
+        readonly instructions: string_markdown;
+        /**
+         * Optional list of knowledge source links (URLs or file paths) to attach to the assistant via vector store
+         */
+        readonly knowledgeSources?: ReadonlyArray<string>;
+    }): Promise<OpenAiAssistantExecutionTools>;
+    updateAssistant(options: {
+        /**
+         * ID of the assistant to update
+         */
+        readonly assistantId: string_token;
+        /**
+         * Name of the assistant
+         */
+        readonly name?: string_title;
+        /**
+         * Instructions for the assistant
+         */
+        readonly instructions?: string_markdown;
+        /**
+         * Optional list of knowledge source links (URLs or file paths) to attach to the assistant via vector store
+         */
+        readonly knowledgeSources?: ReadonlyArray<string>;
+    }): Promise<OpenAiAssistantExecutionTools>;
+    /**
+     * Discriminant for type guards
+     */
+    protected get discriminant(): string;
+    /**
+     * Type guard to check if given `LlmExecutionTools` are instanceof `OpenAiAssistantExecutionTools`
+     *
+     * Note: This is useful when you can possibly have multiple versions of `@promptbook/openai` installed
+     */
+    static isOpenAiAssistantExecutionTools(llmExecutionTools: LlmExecutionTools): llmExecutionTools is OpenAiAssistantExecutionTools;
 }
 /**
  * TODO: [🧠][🧙‍♂️] Maybe there can be some wizard for those who want to use just OpenAI

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

@@ -7,8 +7,14 @@ import type { OpenAiCompatibleExecutionToolsOptions } from './OpenAiCompatibleEx
  * @public exported from `@promptbook/openai`
  */
 export type OpenAiAssistantExecutionToolsOptions = OpenAiCompatibleExecutionToolsOptions & ClientOptions & {
+    /**
+     * Whether creating new assistants is allowed
+     *
+     * @default false
+     */
+    readonly isCreatingNewAssistantsAllowed?: boolean;
     /**
      * Which assistant to use
      */
-    assistantId: string_token;
+    readonly assistantId: string_token;
 };

package/esm/typings/src/llm-providers/openai/OpenAiCompatibleExecutionTools.d.ts

@@ -1,7 +1,7 @@
 import OpenAI from 'openai';
 import type { AvailableModel } from '../../execution/AvailableModel';
 import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
-import type { ChatPromptResult, CompletionPromptResult, EmbeddingPromptResult } from '../../execution/PromptResult';
+import type { ChatPromptResult, CompletionPromptResult, EmbeddingPromptResult, ImagePromptResult } from '../../execution/PromptResult';
 import type { Usage } from '../../execution/Usage';
 import type { Prompt } from '../../types/Prompt';
 import type { string_markdown, string_markdown_text, string_model_name, string_title } from '../../types/typeAliases';
@@ -63,6 +63,14 @@ export declare abstract class OpenAiCompatibleExecutionTools implements LlmExecu
      * Internal method that handles parameter retry for embedding model calls
      */
     private callEmbeddingModelWithRetry;
+    /**
+     * Calls OpenAI compatible API to use a image generation model
+     */
+    callImageGenerationModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements'>): Promise<ImagePromptResult>;
+    /**
+     * Internal method that handles parameter retry for image generation model calls
+     */
+    private callImageGenerationModelWithRetry;
     /**
      * Get the model that should be used as default
      */
@@ -89,6 +97,10 @@ export declare abstract class OpenAiCompatibleExecutionTools implements LlmExecu
      * Default model for completion variant.
      */
     protected abstract getDefaultEmbeddingModel(): AvailableModel;
+    /**
+     * Default model for image generation variant.
+     */
+    protected abstract getDefaultImageGenerationModel(): AvailableModel;
     /**
      * Makes a request with retry logic for network errors like ECONNRESET
      */

package/esm/typings/src/llm-providers/openai/OpenAiExecutionTools.d.ts

@@ -35,4 +35,8 @@ export declare class OpenAiExecutionTools extends OpenAiCompatibleExecutionTools
      * Default model for completion variant.
      */
     protected getDefaultEmbeddingModel(): AvailableModel;
+    /**
+     * Default model for image generation variant.
+     */
+    protected getDefaultImageGenerationModel(): AvailableModel;
 }

package/esm/typings/src/llm-providers/openai/createOpenAiCompatibleExecutionTools.d.ts

@@ -1,15 +1,11 @@
 import type { AvailableModel } from '../../execution/AvailableModel';
 import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
 import type { Usage } from '../../execution/Usage';
-import type { string_markdown } from '../../types/typeAliases';
-import type { string_markdown_text } from '../../types/typeAliases';
-import type { string_model_name } from '../../types/typeAliases';
-import type { string_title } from '../../types/typeAliases';
+import type { string_markdown, string_markdown_text, string_model_name, string_title } from '../../types/typeAliases';
 import { RemoteLlmExecutionTools } from '../remote/RemoteLlmExecutionTools';
 import { computeOpenAiUsage } from './computeOpenAiUsage';
 import { OpenAiCompatibleExecutionTools } from './OpenAiCompatibleExecutionTools';
-import type { OpenAiCompatibleExecutionToolsNonProxiedOptions } from './OpenAiCompatibleExecutionToolsOptions';
-import type { OpenAiCompatibleExecutionToolsOptions } from './OpenAiCompatibleExecutionToolsOptions';
+import type { OpenAiCompatibleExecutionToolsNonProxiedOptions, OpenAiCompatibleExecutionToolsOptions } from './OpenAiCompatibleExecutionToolsOptions';
 /**
  * Execution Tools for calling OpenAI compatible API
  *
@@ -67,6 +63,10 @@ export declare class HardcodedOpenAiCompatibleExecutionTools extends OpenAiCompa
      * Default model for completion variant.
      */
     protected getDefaultEmbeddingModel(): AvailableModel;
+    /**
+     * Default model for image generation variant.
+     */
+    protected getDefaultImageGenerationModel(): AvailableModel;
 }
 /**
  * TODO: [🦺] Is there some way how to put `packageName` and `className` on top and function definition on bottom?

package/esm/typings/src/llm-providers/openai/openai-models.d.ts

@@ -2,7 +2,7 @@ import type { AvailableModel } from '../../execution/AvailableModel';
 /**
  * List of available OpenAI models with pricing
  *
- * Note: Synced with official API docs at 2025-08-20
+ * Note: Synced with official API docs at 2025-11-19
  *
  * @see https://platform.openai.com/docs/models/
  * @see https://openai.com/api/pricing/

package/esm/typings/src/llm-providers/openai/openai-models.test.d.ts

@@ -0,0 +1,4 @@
+export {};
+/**
+ * TODO: [🧠] Maybe do this test for all model providers + boilerplate
+ */

package/esm/typings/src/other/templates/getTemplatesPipelineCollection.d.ts

@@ -1,4 +1,4 @@
-import type { PipelineCollection } from '../../collection/PipelineCollection';
+import type { PipelineCollection } from '../../collection/pipeline-collection/PipelineCollection';
 /**
  * Get pipeline collection for Untitled Promptbook project
  *

package/esm/typings/src/pipeline/validatePipelineString.d.ts

@@ -3,6 +3,8 @@ import type { PipelineString } from './PipelineString';
  * Function `validatePipelineString` will validate the if the string is a valid pipeline string
  * It does not check if the string is fully logically correct, but if it is a string that can be a pipeline string or the string looks completely different.
  *
+ * Note: [🔂] This function is idempotent.
+ *
  * @param {string} pipelineString the candidate for a pipeline string
  * @returns {PipelineString} the same string as input, but validated as valid
  * @throws {ParseError} if the string is not a valid pipeline string

package/esm/typings/src/playground/permanent/_boilerplate.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env ts-node
+export {};
+/**
+ * Note: [⚫] Code in this file should never be published in any package
+ */

package/esm/typings/src/playground/permanent/agent-with-browser-playground.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env ts-node
+export {};
+/**
+ * Note: [⚫] Code in this file should never be published in any package
+ */

package/esm/typings/src/prepare/PrepareAndScrapeOptions.d.ts

@@ -47,5 +47,6 @@ export type PrepareAndScrapeOptions = {
     readonly isVerbose?: boolean;
 };
 /**
+ * TODO: [🧠] Maybe extend from `CommonToolsOptions`
  * TODO: [🧠] Maybe split `PrepareAndScrapeOptions` and `ScrapeOptions` (`ScrapeOptions` should be extended from `PrepareAndScrapeOptions`)
  */

package/esm/typings/src/remote-server/startAgentServer.d.ts

@@ -0,0 +1,26 @@
+import type { number_port } from '../types/typeAliases';
+import type { TODO_any } from '../utils/organization/TODO_any';
+type AgentsServerOptions = {
+    /**
+     * !!!
+     *
+     * @default 4440
+     */
+    port: number_port;
+};
+/**
+ * [🐱‍🚀]
+ * Remote server is a proxy server that uses its execution tools internally and exposes the executor interface externally.
+ *
+ * You can simply use `RemoteExecutionTools` on client-side javascript and connect to your remote server.
+ * This is useful to make all logic on browser side but not expose your API keys or no need to use customer's GPU.
+ *
+ * @see https://github.com/webgptorg/promptbook#remote-server
+ * @public exported from `@promptbook/remote-server`
+ * <- TODO: [🐱‍🚀] Change to `@promptbook/agent-server`
+ */
+export declare function startAgentServer(options: AgentsServerOptions): Promise<TODO_any>;
+export {};
+/**
+ * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+ */