@promptbook/wizard 0.95.0

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

@@ -0,0 +1,41 @@
+import { MultipleLlmExecutionTools } from '../../_multiple/MultipleLlmExecutionTools';
+import type { CreateLlmToolsFromConfigurationOptions } from './createLlmToolsFromConfiguration';
+/**
+ * Automatically configures LLM tools from environment variables in Node.js
+ *
+ * This utility function detects available LLM providers based on environment variables
+ * and creates properly configured LLM execution tools for each detected provider.
+ *
+ * Note: This function is not cached, every call creates new instance of `MultipleLlmExecutionTools`
+ *
+ * Supports environment variables from .env files when dotenv is configured
+ * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
+ *
+ * It looks for environment variables:
+ * - `process.env.OPENAI_API_KEY`
+ * - `process.env.ANTHROPIC_CLAUDE_API_KEY`
+ * - ...
+ *
+ * @param options Configuration options for the LLM tools
+ * @returns A unified interface containing all detected and configured LLM tools
+ * @public exported from `@promptbook/node`
+ */
+export declare function $provideLlmToolsFromEnv(options?: CreateLlmToolsFromConfigurationOptions): Promise<MultipleLlmExecutionTools>;
+/**
+ * TODO: The architecture for LLM tools configuration consists of three key functions:
+ * 1. `$provideLlmToolsFromEnv` - High-level function that detects available providers from env vars and returns ready-to-use LLM tools
+ * 2. `$provideLlmToolsConfigurationFromEnv` - Middle layer that extracts configuration objects from environment variables
+ * 3. `createLlmToolsFromConfiguration` - Low-level function that instantiates LLM tools from explicit configuration
+ *
+ * This layered approach allows flexibility in how tools are configured:
+ * - Use $provideLlmToolsFromEnv for automatic detection and setup in Node.js environments
+ * - Use $provideLlmToolsConfigurationFromEnv to extract config objects for modification before instantiation
+ * - Use createLlmToolsFromConfiguration for explicit control over tool configurations
+ *
+ * TODO: [🧠][🍛] Which name is better `$provideLlmToolsFromEnv` or `$provideLlmToolsFromEnvironment`?
+ * TODO: [🧠] Is there some meaningfull way how to test this util
+ * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
+ * TODO: [🥃] Allow `ptbk make` without llm tools
+ * TODO: This should be maybe not under `_common` but under `utils`
+ * TODO: [®] DRY Register logic
+ */

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

@@ -0,0 +1,22 @@
+import type { string_filename } from '../../../types/typeAliases';
+import type { string_markdown } from '../../../types/typeAliases';
+/**
+ * Pass the `.env` file which was used to configure LLM tools
+ *
+ * Note: `$` is used to indicate that this variable is making side effect
+ *
+ * @private internal log of `$provideLlmToolsConfigurationFromEnv` and `$registeredLlmToolsMessage`
+ */
+export declare function $setUsedEnvFilename(filepath: string_filename): void;
+/**
+ * Creates a message with all registered LLM tools
+ *
+ * Note: This function is used to create a (error) message when there is no constructor for some LLM provider
+ *
+ * @private internal function of `createLlmToolsFromConfiguration` and `$provideLlmToolsFromEnv`
+ */
+export declare function $registeredLlmToolsMessage(): string_markdown;
+/**
+ * TODO: [®] DRY Register logic
+ * TODO: [🧠][⚛] Maybe pass env as argument
+ */

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

@@ -0,0 +1,30 @@
+import type { string_title } from '../../../types/typeAliases';
+import type { Registered } from '../../../utils/$Register';
+import type { LlmToolsOptions } from './LlmToolsOptions';
+/**
+ * Configuration definition for LLM execution tools, containing provider-specific settings
+ * that can be passed during runtime to instantiate and configure LLM tools properly.
+ *
+ * The Promptbook LLM tools architecture involves several related types:
+ * - `LlmToolsMetadata`: Contains static metadata about the tool, such as name, version, and capabilities
+ * - `LlmToolsConfiguration`: Runtime configuration from environment variables or settings
+ * - `LlmToolsOptions`: Provider-specific options for instantiating tools
+ * - `Registered`: The record of a registered tool in the global registry
+ */
+export type LlmToolsConfiguration = ReadonlyArray<Registered & {
+    /**
+     * Human-readable name for this specific provider configuration
+     * Used in UI components and logs for identifying this particular configuration
+     */
+    readonly title: string_title;
+    /**
+     * Provider-specific configuration options used for instantiating and configuring LLM tools
+     * Contains values like API keys, model preferences, endpoint URLs, and other settings
+     */
+    readonly options: LlmToolsOptions;
+}>;
+/**
+ * TODO: [🧠][🌰] `title` is redundant BUT maybe allow each provider pass it's own title for tracking purposes
+ * TODO: Maybe instead of `LlmToolsConfiguration[number]` make `LlmToolsConfigurationItem`
+ * TODO: [®] DRY Register logic
+ */

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

@@ -0,0 +1,58 @@
+import { MODEL_ORDERS } from '../../../constants';
+import { MODEL_TRUST_LEVELS } from '../../../constants';
+import type { string_name } from '../../../types/typeAliases';
+import type { string_title } from '../../../types/typeAliases';
+import type { Registered } from '../../../utils/$Register';
+import type { string_SCREAMING_CASE } from '../../../utils/normalization/normalizeTo_SCREAMING_CASE';
+import type { LlmToolsConfiguration } from './LlmToolsConfiguration';
+/**
+ * Metadata definition for LLM execution tools that provides information about a provider's capabilities,
+ * configuration options, and relationships within the registry system.
+ *
+ * The Promptbook LLM tools architecture involves several related types:
+ * - `LlmToolsMetadata`: Contains static metadata about the tool, such as name, version, and capabilities
+ * - `LlmToolsConfiguration`: Runtime configuration from environment variables or settings
+ * - `LlmToolsOptions`: Provider-specific options for instantiating tools
+ * - `Registered`: The record of a registered tool in the global registry
+ */
+export type LlmToolsMetadata = Registered & {
+    /**
+     * Human-readable display name for the LLM provider
+     * Used in UI components and documentation references
+     */
+    readonly title: string_title;
+    /**
+     * How is the model is trusted?
+     */
+    readonly trustLevel: keyof typeof MODEL_TRUST_LEVELS;
+    /**
+     * 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;
+    /**
+     * List of environment variables that can be used to configure the provider
+     *
+     * If `[]`, empty array, it means that the provider is available automatically without any configuration
+     * If `null`, it means that the provider can not be configured via environment variables
+     */
+    readonly envVariables: ReadonlyArray<string_name & string_SCREAMING_CASE> | null;
+    /**
+     * Provides a default configuration template for this LLM provider
+     * Used to generate example configurations or as fallback when no specific configuration is provided
+     * @returns A standardized configuration object for this LLM provider
+     */
+    getBoilerplateConfiguration(): LlmToolsConfiguration[number];
+    /**
+     * Creates a provider-specific configuration object from environment variables
+     * Used to automatically configure LLM tools based on available environment settings
+     *
+     * @param env Dictionary of environment variables (key-value pairs)
+     * @returns Configuration object for this LLM provider if required variables are present, or null if configuration is not possible
+     */
+    createConfigurationFromEnv(env: Record<string_name, string>): LlmToolsConfiguration[number] | null;
+};
+/**
+ * TODO: Add configuration schema and maybe some documentation link
+ * TODO: Maybe constrain LlmToolsConfiguration[number] by generic to ensure that `createConfigurationFromEnv` and `getBoilerplateConfiguration` always create same `packageName` and `className`
+ * TODO: [®] DRY Register logic
+ */

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

@@ -0,0 +1,17 @@
+import type { TODO_object } from '../../../utils/organization/TODO_object';
+/**
+ * Options for configuring LLM (Large Language Model) tools.
+ *
+ * This type is used to pass provider-specific options to LLM execution tools.
+ *
+ *
+ * The Promptbook LLM tools architecture involves several related types:
+ * - `LlmToolsMetadata`: Contains static metadata about the tool, such as name, version, and capabilities
+ * - `LlmToolsConfiguration`: Runtime configuration from environment variables or settings
+ * - `LlmToolsOptions`: Provider-specific options for instantiating tools
+ * - `Registered`: The record of a registered tool in the global registry
+ */
+export type LlmToolsOptions = TODO_object;
+/**
+ * TODO: [®] DRY Register logic
+ */

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

@@ -0,0 +1,49 @@
+import type { string_user_id } from '../../../types/typeAliases';
+import { MultipleLlmExecutionTools } from '../../_multiple/MultipleLlmExecutionTools';
+import type { LlmToolsConfiguration } from './LlmToolsConfiguration';
+/**
+ * Options for `$provideLlmToolsFromEnv`
+ *
+ * @private internal type for `$provideLlmToolsFromEnv` and `$provideLlmToolsForTestingAndScriptsAndPlayground`
+ */
+export type CreateLlmToolsFromConfigurationOptions = {
+    /**
+     * This will will be passed to the created `LlmExecutionTools`
+     *
+     * @default false
+     */
+    isVerbose?: boolean;
+    /**
+     * Identifier of the end user
+     *
+     * Note: This is passed to the LLM tools providers to identify misuse
+     */
+    readonly userId?: string_user_id;
+};
+/**
+ * Creates LLM execution tools from provided configuration objects
+ *
+ * Instantiates and configures LLM tool instances for each configuration entry,
+ * combining them into a unified interface via MultipleLlmExecutionTools.
+ *
+ * Note: This function is not cached, every call creates new instance of `MultipleLlmExecutionTools`
+ *
+ * @param configuration Array of LLM tool configurations to instantiate
+ * @param options Additional options for configuring the LLM tools
+ * @returns A unified interface combining all successfully instantiated LLM tools
+ * @public exported from `@promptbook/core`
+ */
+export declare function createLlmToolsFromConfiguration(configuration: LlmToolsConfiguration, options?: CreateLlmToolsFromConfigurationOptions): MultipleLlmExecutionTools;
+/**
+ * TODO: [🎌] Together with `createLlmToolsFromConfiguration` + 'EXECUTION_TOOLS_CLASSES' gets to `@promptbook/core` ALL model providers, make this more efficient
+ * TODO: [🧠][🎌] Dynamically install required providers
+ * TODO: We should implement an interactive configuration wizard that would:
+ *       1. Detect which LLM providers are available in the environment
+ *       2. Guide users through required configuration settings for each provider
+ *       3. Allow testing connections before completing setup
+ *       4. Generate appropriate configuration code for application integration
+ * TODO: [🧠][🍛] Which name is better `createLlmToolsFromConfig` or `createLlmToolsFromConfiguration`?
+ * TODO: [🧠] Is there some meaningfull way how to test this util
+ * TODO: This should be maybe not under `_common` but under `utils`
+ * TODO: [®] DRY Register logic
+ */

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

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

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

@@ -0,0 +1,33 @@
+import type { PromptResult } from '../../../../execution/PromptResult';
+import type { Prompt } from '../../../../types/Prompt';
+import type { string_date_iso8601 } from '../../../../types/typeAliases';
+import type { string_semantic_version } from '../../../../types/typeAliases';
+import type { string_promptbook_version } from '../../../../version';
+/**
+ * Represents a single item stored in the LLM cache.
+ */
+export type CacheItem = {
+    /**
+     * The date and time when the cache item was created, in ISO 8601 format.
+     */
+    date: string_date_iso8601;
+    /**
+     * The version of the Promptbook library used when this cache item was created.
+     */
+    promptbookVersion?: string_promptbook_version;
+    /**
+     * The version of the Book language used when this cache item was created.
+     */
+    bookVersion?: string_semantic_version;
+    /**
+     * The prompt that was sent to the LLM.
+     */
+    prompt: Prompt;
+    /**
+     * The response received from the LLM.
+     */
+    promptResult: PromptResult;
+};
+/**
+ * TODO: [🧠] Should be this exported alongsite `cacheLlmTools` through `@promptbook/utils` OR through `@promptbook/types`
+ */

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

@@ -0,0 +1,27 @@
+import type { PromptbookStorage } from '../../../../storage/_common/PromptbookStorage';
+import type { CacheItem } from './CacheItem';
+/**
+ * Options for configuring caching behavior for LlmExecutionTools.
+ */
+export type CacheLlmToolsOptions = {
+    /**
+     * The cache provider instance to use for storing and retrieving cached data.
+     *
+     * @default MemoryStorage
+     */
+    storage: PromptbookStorage<CacheItem>;
+    /**
+     * When set to `true`, the cache will be reloaded regardless of whether the data is already present in the cache.
+     * This can be useful for debugging or when you want to ensure that the latest data is always fetched.
+     * Data will ne still saved to the cache.
+     *
+     * @default false
+     */
+    isCacheReloaded?: boolean;
+    /**
+     * If true, the preparation logs additional information
+     *
+     * @default DEFAULT_IS_VERBOSE
+     */
+    readonly isVerbose?: boolean;
+};

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

@@ -0,0 +1,19 @@
+import type { LlmExecutionTools } from '../../../../execution/LlmExecutionTools';
+import type { CacheLlmToolsOptions } from './CacheLlmToolsOptions';
+/**
+ * Intercepts LLM tools and counts total usage of the tools
+ *
+ * Note: It can take extended `LlmExecutionTools` and cache the
+ *
+ * @param llmTools LLM tools to be intercepted with usage counting, it can contain extra methods like `totalUsage`
+ * @returns LLM tools with same functionality with added total cost counting
+ * @public exported from `@promptbook/core`
+ */
+export declare function cacheLlmTools<TLlmTools extends LlmExecutionTools>(llmTools: TLlmTools, options?: Partial<CacheLlmToolsOptions>): TLlmTools;
+/**
+ * TODO: [🧠][💸] Maybe make some common abstraction `interceptLlmTools` and use here (or use javascript Proxy?)
+ * TODO: [🧠] Is there some meaningfull way how to test this util
+ * TODO: [👷‍♂️] Comprehensive manual about construction of llmTools
+ *            Detailed explanation about caching strategies and appropriate storage selection for different use cases
+ *            Examples of how to combine multiple interceptors for advanced caching, logging, and usage tracking
+ */

package/esm/typings/src/llm-providers/_common/utils/count-total-usage/LlmExecutionToolsWithTotalUsage.d.ts

@@ -0,0 +1,22 @@
+import type { Observable } from 'rxjs';
+import type { LlmExecutionTools } from '../../../../execution/LlmExecutionTools';
+import type { Usage } from '../../../../execution/Usage';
+/**
+ * LLM tools with option to get total usage of the execution
+ */
+export type LlmExecutionToolsWithTotalUsage = LlmExecutionTools & {
+    /**
+     * Get total cost of the execution up to this point
+     */
+    getTotalUsage(): Usage;
+    /**
+     * Observable of total cost of the execution up to this point
+     *
+     * Note: This does report the cost of the last prompt, not the total cost of the execution up to this point
+     */
+    spending(): Observable<Usage>;
+};
+/**
+ * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
+ * Note: [🥫] Not using getter `get totalUsage` but `getTotalUsage` to allow this object to be proxied
+ */

package/esm/typings/src/llm-providers/_common/utils/count-total-usage/countUsage.d.ts

@@ -0,0 +1,17 @@
+import type { LlmExecutionTools } from '../../../../execution/LlmExecutionTools';
+import type { LlmExecutionToolsWithTotalUsage } from './LlmExecutionToolsWithTotalUsage';
+/**
+ * Intercepts LLM tools and counts total usage of the tools
+ *
+ * @param llmTools LLM tools to be intercepted with usage counting
+ * @returns LLM tools with same functionality with added total cost counting
+ * @public exported from `@promptbook/core`
+ */
+export declare function countUsage(llmTools: LlmExecutionTools): LlmExecutionToolsWithTotalUsage;
+/**
+ * TODO: [🧠][💸] Maybe make some common abstraction `interceptLlmTools` and use here (or use javascript Proxy?)
+ * TODO: [🧠] Is there some meaningfull way how to test this util
+ * TODO: [🧠][🌯] Maybe a way how to hide ability to `get totalUsage`
+ *     > const [llmToolsWithUsage,getUsage] = countTotalUsage(llmTools);
+ * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
+ */

package/esm/typings/src/llm-providers/_common/utils/count-total-usage/limitTotalUsage.d.ts

@@ -0,0 +1,36 @@
+import type { LlmExecutionTools } from '../../../../execution/LlmExecutionTools';
+import type { Usage } from '../../../../execution/Usage';
+import type { PromptbookStorage } from '../../../../storage/_common/PromptbookStorage';
+import type { TODO_any } from '../../../../utils/organization/TODO_any';
+import type { LlmExecutionToolsWithTotalUsage } from './LlmExecutionToolsWithTotalUsage';
+/**
+ * Options for the `limitTotalUsage` function.
+ */
+type LimitTotalUsageOptions = {
+    /**
+     * The usage limits to apply.
+     *
+     * @default ZERO_USAGE
+     */
+    maxTotalUsage: Usage;
+    /**
+     * The storage mechanism to use for tracking usage across multiple executions or instances.
+     *
+     * @default MemoryStorage which will not persist when the process ends
+     */
+    storage: PromptbookStorage<TODO_any>;
+};
+/**
+ * Wraps LlmExecutionTools to limit the total usage based on provided limits.
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function limitTotalUsage(llmTools: LlmExecutionTools, options?: Partial<LimitTotalUsageOptions>): LlmExecutionToolsWithTotalUsage;
+export {};
+/**
+ * TODO: Maybe internally use `countTotalUsage`
+ * TODO: [🧠][💸] Maybe make some common abstraction `interceptLlmTools` and use here (or use javascript Proxy?)
+ * TODO: [🧠] Is there some meaningfull way how to test this util
+ * TODO: [🧠][🌯] Maybe a way how to hide ability to `get totalUsage`
+ * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
+ */

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

@@ -0,0 +1,16 @@
+/**
+ * String value found on OpenAI and Anthropic Claude page
+ *
+ * @see https://openai.com/api/pricing/
+ * @see https://docs.anthropic.com/en/docs/models-overview
+ *
+ * @private within the repository, used only as internal helper for `OPENAI_MODELS` and `computeUsage`
+ */
+type string_model_price = `$${number}.${number} / ${number}M tokens`;
+/**
+ * Create price per one token based on the string value found on openai page
+ *
+ * @private within the repository, used only as internal helper for `OPENAI_MODELS`
+ */
+export declare function pricing(value: string_model_price): number;
+export {};

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

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

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

@@ -0,0 +1,63 @@
+import type { AvailableModel } from '../../execution/AvailableModel';
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import type { ChatPromptResult } from '../../execution/PromptResult';
+import type { CompletionPromptResult } from '../../execution/PromptResult';
+import type { EmbeddingPromptResult } from '../../execution/PromptResult';
+import type { PromptResult } from '../../execution/PromptResult';
+import type { ChatPrompt } from '../../types/Prompt';
+import type { CompletionPrompt } from '../../types/Prompt';
+import type { EmbeddingPrompt } from '../../types/Prompt';
+import type { Prompt } from '../../types/Prompt';
+import type { string_markdown } from '../../types/typeAliases';
+import type { string_markdown_text } from '../../types/typeAliases';
+import type { string_title } from '../../types/typeAliases';
+/**
+ * Multiple LLM Execution Tools is a proxy server that uses multiple execution tools internally and exposes the executor interface externally.
+ *
+ * Note: Internal utility of `joinLlmExecutionTools` but exposed type
+ * @public exported from `@promptbook/core`
+ */
+export declare class MultipleLlmExecutionTools implements LlmExecutionTools {
+    /**
+     * Array of execution tools in order of priority
+     */
+    readonly llmExecutionTools: ReadonlyArray<LlmExecutionTools>;
+    /**
+     * Gets array of execution tools in order of priority
+     */
+    constructor(...llmExecutionTools: ReadonlyArray<LlmExecutionTools>);
+    get title(): string_title & string_markdown_text;
+    get description(): string_markdown;
+    /**
+     * Check the configuration of all execution tools
+     */
+    checkConfiguration(): Promise<void>;
+    /**
+     * List all available models that can be used
+     * This lists is a combination of all available models from all execution tools
+     */
+    listModels(): Promise<ReadonlyArray<AvailableModel>>;
+    /**
+     * Calls the best available chat model
+     */
+    callChatModel(prompt: ChatPrompt): Promise<ChatPromptResult>;
+    /**
+     * Calls the best available completion model
+     */
+    callCompletionModel(prompt: CompletionPrompt): Promise<CompletionPromptResult>;
+    /**
+     * Calls the best available embedding model
+     */
+    callEmbeddingModel(prompt: EmbeddingPrompt): Promise<EmbeddingPromptResult>;
+    /**
+     * Calls the best available model
+     *
+     * Note: This should be private or protected but is public to be usable with duck typing
+     */
+    callCommonModel(prompt: Prompt): Promise<PromptResult>;
+}
+/**
+ * TODO: [🧠][🎛] Aggregating multiple models - have result not only from one first available model BUT all of them
+ * TODO: [🏖] If no llmTools have for example not defined `callCompletionModel` this will still return object with defined `callCompletionModel` which just throws `PipelineExecutionError`, make it undefined instead
+ *       Look how `countTotalUsage` (and `cacheLlmTools`) implements it
+ */

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

@@ -0,0 +1,21 @@
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import { MultipleLlmExecutionTools } from './MultipleLlmExecutionTools';
+/**
+ * Joins multiple LLM Execution Tools into one
+ *
+ * @returns {LlmExecutionTools} Single wrapper for multiple LlmExecutionTools
+ *
+ * 0) If there is no LlmExecutionTools, it warns and returns valid but empty LlmExecutionTools
+ * 1) If there is only one LlmExecutionTools, it returns it wrapped in a proxy object
+ * 2) If there are multiple LlmExecutionTools, first will be used first, second will be used if the first hasn`t defined model variant or fails, etc.
+ * 3) When all LlmExecutionTools fail, it throws an error with a list of all errors merged into one
+ *
+ *
+ * Tip: You don't have to use this function directly, just pass an array of LlmExecutionTools to the `ExecutionTools`
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function joinLlmExecutionTools(...llmExecutionTools: ReadonlyArray<LlmExecutionTools>): MultipleLlmExecutionTools;
+/**
+ * TODO: [👷‍♂️] @@@ Manual about construction of llmTools
+ */

package/esm/typings/src/llm-providers/_multiple/playground/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/llm-providers/anthropic-claude/AnthropicClaudeExecutionTools.d.ts

@@ -0,0 +1,66 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type { AvailableModel } from '../../execution/AvailableModel';
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import type { ChatPromptResult } from '../../execution/PromptResult';
+import type { CompletionPromptResult } from '../../execution/PromptResult';
+import type { Prompt } from '../../types/Prompt';
+import type { string_markdown } from '../../types/typeAliases';
+import type { string_markdown_text } from '../../types/typeAliases';
+import type { string_title } from '../../types/typeAliases';
+import type { AnthropicClaudeExecutionToolsDirectOptions } from './AnthropicClaudeExecutionToolsOptions';
+/**
+ * Execution Tools for calling Anthropic Claude API.
+ *
+ * @public exported from `@promptbook/anthropic-claude`
+ * @deprecated use `createAnthropicClaudeExecutionTools` instead
+ */
+export declare class AnthropicClaudeExecutionTools implements LlmExecutionTools {
+    protected readonly options: AnthropicClaudeExecutionToolsDirectOptions;
+    /**
+     * Anthropic Claude API client.
+     */
+    private client;
+    private limiter;
+    /**
+     * Creates Anthropic Claude Execution Tools.
+     *
+     * @param options which are relevant are directly passed to the Anthropic Claude client
+     */
+    constructor(options?: AnthropicClaudeExecutionToolsDirectOptions);
+    get title(): string_title & string_markdown_text;
+    get description(): string_markdown;
+    getClient(): Promise<Anthropic>;
+    /**
+     * Check the `options` passed to `constructor`
+     */
+    checkConfiguration(): Promise<void>;
+    /**
+     * List all available Anthropic Claude models that can be used
+     */
+    listModels(): ReadonlyArray<AvailableModel>;
+    /**
+     * Calls Anthropic Claude API to use a chat model.
+     */
+    callChatModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements'>): Promise<ChatPromptResult>;
+    /**
+     * Calls Anthropic Claude API to use a completion model.
+     */
+    callCompletionModel(prompt: Pick<Prompt, 'content' | 'parameters' | 'modelRequirements'>): Promise<CompletionPromptResult>;
+    /**
+     * Get the model that should be used as default
+     */
+    private getDefaultModel;
+    /**
+     * Default model for chat variant.
+     */
+    private getDefaultChatModel;
+}
+/**
+ * TODO:  [🍆] JSON mode
+ * TODO: [🧠] Maybe handle errors via transformAnthropicError (like transformAzureError)
+ * TODO: Maybe Create some common util for callChatModel and callCompletionModel
+ * TODO: Maybe make custom OpenAiError
+ * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
+ * TODO: [🧠][🌰] Allow to pass `title` for tracking purposes
+ * TODO: [📅] Maybe instead of `RemoteLlmExecutionToolsOptions` use `proxyWithAnonymousRemoteServer` (if implemented)
+ */

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

@@ -0,0 +1,31 @@
+import type { ClientOptions } from '@anthropic-ai/sdk';
+import type { CommonToolsOptions } from '../../execution/CommonToolsOptions';
+import type { RemoteClientOptions } from '../../remote-server/types/RemoteClientOptions';
+/**
+ * Options for `createAnthropicClaudeExecutionTools` and `AnthropicClaudeExecutionTools`
+ *
+ * This extends Anthropic's `ClientOptions` with are directly passed to the Anthropic client.
+ * @public exported from `@promptbook/anthropic-claude`
+ */
+export type AnthropicClaudeExecutionToolsOptions = AnthropicClaudeExecutionToolsDirectOptions | AnthropicClaudeExecutionToolsProxiedOptions;
+/**
+ * Options for directly used `AnthropicClaudeExecutionTools`
+ *
+ * This extends Anthropic's `ClientOptions` with are directly passed to the Anthropic client.
+ * @public exported from `@promptbook/anthropic-claude`
+ */
+export type AnthropicClaudeExecutionToolsDirectOptions = CommonToolsOptions & ClientOptions & {
+    isProxied?: false;
+};
+/**
+ * Options for proxied `AnthropicClaudeExecutionTools`
+ *
+ * This extends Anthropic's `ClientOptions` with are directly passed to the Anthropic client.
+ * @public exported from `@promptbook/anthropic-claude`
+ */
+export type AnthropicClaudeExecutionToolsProxiedOptions = CommonToolsOptions & ClientOptions & {
+    isProxied: true;
+} & Pick<RemoteClientOptions<undefined>, 'remoteServerUrl'>;
+/**
+ * TODO: [🧠][🤺] Pass `userId`
+ */

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

@@ -0,0 +1,24 @@
+import type { AvailableModel } from '../../execution/AvailableModel';
+import type { number_usd } from '../../types/typeAliases';
+/**
+ * List of available Anthropic Claude models with pricing
+ *
+ * Note: Done at 2025-05-06
+ *
+ * @see https://docs.anthropic.com/en/docs/models-overview
+ * @public exported from `@promptbook/anthropic-claude`
+ */
+export declare const ANTHROPIC_CLAUDE_MODELS: ReadonlyArray<AvailableModel & {
+    pricing?: {
+        readonly prompt: number_usd;
+        readonly output: number_usd;
+    };
+}>;
+/**
+ * Note: [🤖] Add models of new variant
+ * TODO: [🧠][main] !!3 Add embedding models OR Anthropic has only chat+completion models?
+ * TODO: [🧠] Some mechanism to propagate unsureness
+ * TODO: [🧠][👮‍♀️] Put here more info like description, isVision, trainingDateCutoff, languages, strengths (	Top-level performance, intelligence, fluency, and understanding), contextWindow,...
+ * TODO: [🎰] Some mechanism to auto-update available models
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */

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

@@ -0,0 +1,18 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { PartialDeep } from 'type-fest';
+import type { Usage } from '../../execution/Usage';
+import type { Prompt } from '../../types/Prompt';
+/**
+ * Computes the usage of the Anthropic Claude API based on the response from Anthropic Claude
+ *
+ * @param promptContent The content of the prompt
+ * @param resultContent The content of the result (for embedding prompts or failed prompts pass empty string)
+ * @param rawResponse The raw response from Anthropic Claude API
+ * @throws {PipelineExecutionError} If the usage is not defined in the response from Anthropic Claude
+ * @private internal utility of `AnthropicClaudeExecutionTools`
+ */
+export declare function computeAnthropicClaudeUsage(promptContent: Prompt['content'], // <- Note: Intentionally using [] to access type properties to bring jsdoc from Prompt/PromptResult to consumer
+resultContent: string, rawResponse: PartialDeep<Pick<Anthropic.Messages.Message, 'model' | 'usage'>>): Usage;
+/**
+ * TODO: [🤝] DRY Maybe some common abstraction between `computeOpenAiUsage` and `computeAnthropicClaudeUsage`
+ */

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

@@ -0,0 +1,4 @@
+export {};
+/**
+ * TODO: [🤝] DRY Maybe some common abstraction between `computeOpenAiUsage` and `computeAnthropicClaudeUsage`
+ */