@promptbook/openai 0.61.0-9 → 0.62.0-0

package/esm/typings/src/execution/LlmExecutionTools.d.ts

@@ -1,13 +1,13 @@
 import type { Promisable } from 'type-fest';
-import type { ModelVariant } from '../types/ModelRequirements';
+import type { ModelVariant } from '../types/ModelVariant';
 import type { Prompt } from '../types/Prompt';
 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 { PromptChatResult } from './PromptResult';
-import type { PromptCompletionResult } from './PromptResult';
-import type { PromptEmbeddingResult } from './PromptResult';
+import type { ChatPromptResult } from './PromptResult';
+import type { CompletionPromptResult } from './PromptResult';
+import type { EmbeddingPromptResult } from './PromptResult';
 /**
  * Container for all the tools needed to execute prompts to large language models like GPT-4
  * On its interface it exposes common methods for prompt execution.
@@ -31,15 +31,15 @@ export type LlmExecutionTools = {
     /**
      * Calls a chat model
      */
-    callChatModel?(prompt: Prompt): Promise<PromptChatResult>;
+    callChatModel?(prompt: Prompt): Promise<ChatPromptResult>;
     /**
      * Calls a completion model
      */
-    callCompletionModel?(prompt: Prompt): Promise<PromptCompletionResult>;
+    callCompletionModel?(prompt: Prompt): Promise<CompletionPromptResult>;
     /**
      * Calls an embedding model
      */
-    callEmbeddingModel?(prompt: Prompt): Promise<PromptEmbeddingResult>;
+    callEmbeddingModel?(prompt: Prompt): Promise<EmbeddingPromptResult>;
     /**
      * List all available models that can be used
      */
@@ -63,8 +63,10 @@ export type AvailableModel = {
     readonly modelVariant: ModelVariant;
 };
 /**
- * TODO: !!!! Translation model
+ * TODO: [🏳] Add `callTranslationModel`
+ * TODO: Maybe reorder `listModels` and put it befor `callChatModel`, `callCompletionModel`, `callEmbeddingModel`
  * TODO: [🧠] Emulation of one type of model with another one - emuate chat with completion; emulate translation with chat
  * TODO: [🍓][♐] Some heuristic to pick the best model in listed models
  * TODO: [🧠] Should or should not there be a word "GPT" in both callCompletionModel and callChatModel
+ * TODO: [🧠][🪐] Should be common things like types, utils in folder containing A,B,C,.. or else outside this listing folder?
  */

package/esm/typings/src/execution/PipelineExecutor.d.ts

@@ -1,42 +1,64 @@
 import type { Promisable } from 'type-fest';
+import type { PipelineJson } from '../types/PipelineJson/PipelineJson';
+import { PipelineExecutionError } from '../errors/PipelineExecutionError';
 import type { TaskProgress } from '../types/TaskProgress';
 import type { ExecutionReportJson } from '../types/execution-report/ExecutionReportJson';
-import type { string_name } from '../types/typeAliases';
-import type { PromptResultUsage } from './PromptResult';
+import type { Parameters } from '../types/typeAliases';
+import type { PromptResultUsage } from './PromptResultUsage';
 /**
  * Executor is a simple async function that takes INPUT  PARAMETERs and returns result parameters _(along with all intermediate parameters and INPUT  PARAMETERs = it extends input object)_.
  * Executor is made by combining execution tools and pipeline collection.
  *
  * It can be created with `createPipelineExecutor` function.
  *
+ * @@@ almost-JSON (what about errors)
+ *
  * @see https://github.com/webgptorg/promptbook#executor
  */
 export type PipelineExecutor = {
-    (inputParameters: Record<string_name, string>, onProgress?: (taskProgress: TaskProgress) => Promisable<void>): Promise<{
-        /**
-         * Whether the execution was successful, details are aviable in `executionReport`
-         */
-        isSuccessful: boolean;
-        /**
-         * Added usage of whole execution, detailed usage is aviable in `executionReport`
-         */
-        usage: PromptResultUsage;
-        /**
-         * Errors that occured during the execution, details are aviable in `executionReport`
-         */
-        errors: Array<Error>;
-        /**
-         * The report of the execution with all details
-         */
-        executionReport: ExecutionReportJson;
-        /**
-         * Result parameters of the execution
-         *
-         * Note: If the execution was not successful, there are only some of the result parameters
-         */
-        outputParameters: Record<string_name, string>;
-    }>;
+    (inputParameters: Parameters, onProgress?: (taskProgress: TaskProgress) => Promisable<void>): Promise<PipelineExecutorResult>;
+};
+/**
+ * @@@
+ *
+ * @@@ almost-JSON (what about errors)
+ */
+export type PipelineExecutorResult = {
+    /**
+     * Result parameters of the execution
+     *
+     * Note: If the execution was not successful, there are only some of the result parameters
+     */
+    readonly outputParameters: Parameters;
+    /**
+     * Whether the execution was successful, details are aviable in `executionReport`
+     */
+    readonly isSuccessful: boolean;
+    /**
+     * Added usage of whole execution, detailed usage is aviable in `executionReport`
+     */
+    readonly usage: PromptResultUsage;
+    /**
+     * Errors that occured during the execution, details are aviable in `executionReport`
+     */
+    readonly errors: Array<PipelineExecutionError | Error>;
+    /**
+     * Warnings that occured during the execution, details are aviable in `executionReport`
+     */
+    readonly warnings: Array<PipelineExecutionError | Error>;
+    /**
+     * The report of the execution with all details
+     */
+    readonly executionReport: ExecutionReportJson;
+    /**
+     * The prepared pipeline that was used for the execution
+     *
+     * Note: If you called `createPipelineExecutor` with fully prepared pipeline, this is the same object as this pipeline
+     *       If you passed not fully prepared pipeline, this is same pipeline but fully prepared
+     */
+    readonly preparedPipeline: PipelineJson;
 };
 /**
  * TODO: [🧠] Should this file be in /execution or /types folder?
+ * TODO: [💷] `assertsExecutionSuccessful` should be the method of `PipelineExecutor` result - BUT maybe NOT?
  */

package/esm/typings/src/execution/PromptResult.d.ts

@@ -1,37 +1,46 @@
-import type { KebabCase } from 'type-fest';
-import type { ExpectationUnit } from '../types/PipelineJson/Expectations';
-import type { number_positive } from '../types/typeAliases';
-import type { number_usd } from '../types/typeAliases';
 import type { string_date_iso8601 } from '../types/typeAliases';
 import type { string_model_name } from '../types/typeAliases';
+import type { string_prompt } from '../types/typeAliases';
+import type { TODO_object } from '../utils/organization/TODO_object';
 import type { EmbeddingVector } from './EmbeddingVector';
+import type { PromptResultUsage } from './PromptResultUsage';
 /**
  * Prompt result is the simplest concept of execution.
  * It is the result of executing one prompt _(NOT a template)_.
  *
  * @see https://github.com/webgptorg/promptbook#prompt-result
  */
-export type PromptResult = PromptCompletionResult | PromptChatResult | PromptEmbeddingResult;
+export type PromptResult = CompletionPromptResult | ChatPromptResult | EmbeddingPromptResult;
 /**
- * Prompt completion result
- * It contains only the following text NOT the whole completion
+ * Completion prompt result
+ *
+ * Note:It contains only the newly generated text NOT the whole completion
+ * Note: This is fully serializable as JSON
  */
-export type PromptCompletionResult = PromptCommonResult;
+export type CompletionPromptResult = CommonPromptResult;
 /**
- * Prompt chat result
+ *Chat prompt result
+ *
+ * Note: This is fully serializable as JSON
  */
-export type PromptChatResult = PromptCommonResult & {};
+export type ChatPromptResult = CommonPromptResult & {};
 /**
- * Prompt embedding result
- * It contains only the following text NOT the whole completion
+ * Embedding prompt  result
+ *
+ * Note: This is fully serializable as JSON
  */
-export type PromptEmbeddingResult = Omit<PromptCommonResult, 'content'> & {
+export type EmbeddingPromptResult = Omit<CommonPromptResult, 'content'> & {
     /**
      * The response from the model
      */
     content: EmbeddingVector;
 };
-export type PromptCommonResult = {
+/**
+ * Common properties for all prompt results
+ *
+ * Note: This is fully serializable as JSON
+ */
+export type CommonPromptResult = {
     /**
      * Exact text response from the model
      */
@@ -47,68 +56,44 @@ export type PromptCommonResult = {
         /**
          * Start of the execution
          */
-        start: string_date_iso8601;
+        readonly start: string_date_iso8601;
         /**
          * First token generated
          */
-        firstToken?: string_date_iso8601;
+        readonly firstToken?: string_date_iso8601;
         /**
          * End of the execution
          */
-        complete: string_date_iso8601;
+        readonly complete: string_date_iso8601;
     };
     /**
      * Usage of the prompt execution
      */
     readonly usage: PromptResultUsage;
     /**
-     * Raw response from the model
-     */
-    readonly rawResponse: object;
-};
-/**
- * Usage statistics for one or many prompt results
- */
-export type PromptResultUsage = {
-    /**
-     * Cost of the execution in USD
+     * Exact text of the prompt (with all replacements)
      *
-     * Note: If the cost is unknown, the value 0 and isUncertain is true
+     * Note: This contains redundant information
      */
-    price: UncertainNumber;
+    readonly rawPromptContent: string_prompt;
     /**
-     * Number of whatever used in the input aka. `prompt_tokens`
-     */
-    input: PromptResultUsageCounts;
-    /**
-     * Number of tokens used in the output aka. `completion_tokens`
-     */
-    output: PromptResultUsageCounts;
-};
-/**
- * Record of all possible measurable units
- */
-export type PromptResultUsageCounts = Record<`${KebabCase<'TOKENS' | ExpectationUnit>}Count`, UncertainNumber>;
-/**
- * Number which can be uncertain
- *
- * Note: If the value is completelly unknown, the value 0 and isUncertain is true
- * Note: Not using NaN or null because it looses the value which is better to be uncertain then not to be at all
- */
-export type UncertainNumber = {
-    /**
-     * The numeric value
+     * Raw request to the model
+     *
+     * Note: This contains redundant information
      */
-    value: number_usd & (number_positive | 0);
+    readonly rawRequest: TODO_object | null;
     /**
-     * Is the value uncertain
+     * Raw response from the model
+     *
+     * Note: This contains redundant information
      */
-    isUncertain?: true;
+    readonly rawResponse: TODO_object;
 };
 /**
  * TODO: [🧠] Maybe timing more accurate then seconds?
  * TODO: [🧠] Should here be link to the prompt?
- * TODO: [🧠] Maybe type raw properly - not onject but OpenAI.result.whatever
+ * TODO: [🧠] Maybe type `rawResponse` properly - not onject but OpenAI.result.whatever
  * TODO: [🧠] Maybe remove redundant raw.choices.text
  * TODO: Log raw even if prompt failed - log the raw error
+ * TODO: [🏳] Add `TranslationPromptResult`
  */

package/esm/typings/src/execution/PromptResultUsage.d.ts

@@ -0,0 +1,29 @@
+import type { KebabCase } from 'type-fest';
+import type { ExpectationUnit } from '../types/PipelineJson/Expectations';
+import type { UncertainNumber } from './UncertainNumber';
+/**
+ * Usage statistics for one or many prompt results
+ */
+export type PromptResultUsage = {
+    /**
+     * Cost of the execution in USD
+     *
+     * Note: If the cost is unknown, the value 0 and isUncertain is true
+     */
+    readonly price: UncertainNumber;
+    /**
+     * Number of whatever used in the input aka. `prompt_tokens`
+     */
+    readonly input: PromptResultUsageCounts;
+    /**
+     * Number of tokens used in the output aka. `completion_tokens`
+     */
+    readonly output: PromptResultUsageCounts;
+};
+/**
+ * Record of all possible measurable units
+ */
+export type PromptResultUsageCounts = Record<`${KebabCase<'TOKENS' | ExpectationUnit>}Count`, UncertainNumber>;
+/**
+ * TODO: [🍙] Make some standart order of json properties
+ */

package/esm/typings/src/execution/ScriptExecutionTools.d.ts

@@ -1,5 +1,5 @@
 import type { ScriptLanguage } from '../types/ScriptLanguage';
-import type { string_name } from '../types/typeAliases';
+import type { Parameters } from '../types/typeAliases';
 import type { string_script } from '../types/typeAliases';
 /**
  * Represents all the tools needed to EXECUTE SCRIPTs
@@ -16,13 +16,13 @@ export type ScriptExecutionToolsExecuteOptions = {
     /**
      * Language of the script
      */
-    scriptLanguage: ScriptLanguage;
+    readonly scriptLanguage: ScriptLanguage;
     /**
      * Parameters for the script
      * Theese parameters are passed to the script as variables
      * For example: { "name": "John" } => const name = "John";
      */
-    parameters: Record<string_name, string>;
+    readonly parameters: Parameters;
     /**
      * The content of the script to execute
      * - It can be a single statement
@@ -31,8 +31,9 @@ export type ScriptExecutionToolsExecuteOptions = {
      * - It can be IIFE (immediately invoked function expression)
      * - It can use the parameters as variables and functions from global scope
      */
-    script: string_script;
+    readonly script: string_script;
 };
 /**
  * TODO: [🧠][💙] Distinct between options passed into ExecutionTools and to ExecutionTools.execute
+ * TODO: [🧠][🪐] Should be common things like types, utils in folder containing A,B,C,.. or else outside this listing folder?
  */

package/esm/typings/src/execution/UncertainNumber.d.ts

@@ -0,0 +1,18 @@
+import type { number_positive } from '../types/typeAliases';
+import type { number_usd } from '../types/typeAliases';
+/**
+ * Number which can be uncertain
+ *
+ * Note: If the value is completelly unknown, the value 0 and isUncertain is true
+ * Note: Not using NaN or null because it looses the value which is better to be uncertain then not to be at all
+ */
+export type UncertainNumber = {
+    /**
+     * The numeric value
+     */
+    readonly value: number_usd & (number_positive | 0);
+    /**
+     * Is the value uncertain
+     */
+    readonly isUncertain?: true;
+};

package/esm/typings/src/execution/UserInterfaceTools.d.ts

@@ -21,26 +21,26 @@ export type UserInterfaceToolsPromptDialogOptions = {
      * Note: This is not a prompt to language model but a prompt to the user
      * @example "Your name"
      */
-    promptTitle: string;
+    readonly promptTitle: string;
     /**
      * Prompt message
      *
      * Note: This is not a prompt to language model but a prompt to the user
      * @example "Please enter your name, including your last name, title, etc."
      */
-    promptMessage: string;
+    readonly promptMessage: string;
     /**
      * Default value for the input/textarea
      */
-    defaultValue: string | null;
+    readonly defaultValue: string | null;
     /**
      * Placeholder for the input/textarea
      */
-    placeholder?: string;
+    readonly placeholder?: string;
     /**
      * Priority of the prompt
      *
      * Note: This would be reflected for example into the UI z-index of the prompt modal
      */
-    priority: number_integer & number_positive;
+    readonly priority: number_integer & number_positive;
 };

package/esm/typings/src/execution/createPipelineExecutor.d.ts

@@ -5,12 +5,34 @@ type CreatePipelineExecutorSettings = {
     /**
      * When executor does not satisfy expectations it will be retried this amount of times
      *
-     * @default 3
+     * @default MAX_EXECUTION_ATTEMPTS
      */
-    readonly maxExecutionAttempts: number;
+    readonly maxExecutionAttempts?: number;
+    /**
+     * Maximum number of tasks running in parallel
+     *
+     * @default MAX_PARALLEL_COUNT
+     */
+    readonly maxParallelCount?: number;
+    /**
+     * If true, the preparation logs additional information
+     *
+     * @default false
+     */
+    readonly isVerbose?: boolean;
+    /**
+     * If you pass fully prepared pipeline, this does not matter
+     *
+     * Otherwise:
+     * If false or not set, warning is shown when pipeline is not prepared
+     * If true, warning is suppressed
+     *
+     * @default false
+     */
+    readonly isNotPreparedWarningSupressed?: boolean;
 };
 /**
- * Options for creating a pipeline executor
+ * Options for `createPipelineExecutor`
  */
 interface CreatePipelineExecutorOptions {
     /**
@@ -35,8 +57,14 @@ interface CreatePipelineExecutorOptions {
 export declare function createPipelineExecutor(options: CreatePipelineExecutorOptions): PipelineExecutor;
 export {};
 /**
+ * TODO: Use isVerbose here (not only pass to `preparePipeline`)
+ * TODO: [🧠] Use here `countTotalUsage` and put preparation and prepared pipiline to report
+ * TODO: [🪂] Use maxParallelCount here (not only pass to `preparePipeline`)
+ * TODO: [♈] Probbably move expectations from templates to parameters
  * TODO: [🧠] When not meet expectations in PROMPT_DIALOG, make some way to tell the user
  * TODO: [👧] Strongly type the executors to avoid need of remove nullables whtn noUncheckedIndexedAccess in tsconfig.json
  * Note: CreatePipelineExecutorOptions are just connected to PipelineExecutor so do not extract to types folder
  * TODO: [🧠][3] transparent = (report intermediate parameters) / opaque execution = (report only output parameters) progress reporting mode
+ * TODO: [🛠] Actions, instruments (and maybe knowledge) => Functions and tools
+ * TODO: [🧠][💷] `assertsExecutionSuccessful` should be the method of `PipelineExecutor` result BUT maybe NOT to preserve pure JSON object
  */

package/esm/typings/src/execution/translation/automatic-translate/automatic-translators/TranslatorOptions.d.ts

@@ -1,4 +1,4 @@
 export type TranslatorOptions = {
-    from?: string;
-    to: string;
+    readonly from?: string;
+    readonly to: string;
 };

package/esm/typings/src/execution/utils/addUsage.d.ts

@@ -1,7 +1,63 @@
-import type { PromptResultUsage } from '../PromptResult';
+import type { PromptResultUsage } from '../PromptResultUsage';
+/**
+ * @@@
+ *
+ * TODO: [🔼] Export with addUsage
+ */
+export declare const ZERO_USAGE: import("type-fest/source/readonly-deep").ReadonlyObjectDeep<{
+    readonly price: {
+        readonly value: 0;
+    };
+    readonly input: {
+        readonly tokensCount: {
+            readonly value: 0;
+        };
+        readonly charactersCount: {
+            readonly value: 0;
+        };
+        readonly wordsCount: {
+            readonly value: 0;
+        };
+        readonly sentencesCount: {
+            readonly value: 0;
+        };
+        readonly linesCount: {
+            readonly value: 0;
+        };
+        readonly paragraphsCount: {
+            readonly value: 0;
+        };
+        readonly pagesCount: {
+            readonly value: 0;
+        };
+    };
+    readonly output: {
+        readonly tokensCount: {
+            readonly value: 0;
+        };
+        readonly charactersCount: {
+            readonly value: 0;
+        };
+        readonly wordsCount: {
+            readonly value: 0;
+        };
+        readonly sentencesCount: {
+            readonly value: 0;
+        };
+        readonly linesCount: {
+            readonly value: 0;
+        };
+        readonly paragraphsCount: {
+            readonly value: 0;
+        };
+        readonly pagesCount: {
+            readonly value: 0;
+        };
+    };
+}>;
 /**
  * Function `addUsage` will add multiple usages into one
  *
- * Note: If you provide 0 values, it returns void usage
+ * Note: If you provide 0 values, it returns ZERO_USAGE
  */
 export declare function addUsage(...usageItems: Array<PromptResultUsage>): PromptResultUsage;

package/esm/typings/src/execution/utils/computeUsageCounts.d.ts

@@ -1,4 +1,4 @@
-import type { PromptResultUsageCounts } from '../PromptResult';
+import type { PromptResultUsageCounts } from '../PromptResultUsage';
 /**
  * Helper of usage compute
  *

package/esm/typings/src/execution/utils/forEachAsync.d.ts

@@ -5,7 +5,7 @@ type ForEachAsyncOptions = {
      *
      * @default Infinity
      */
-    inParallelCount?: number;
+    readonly maxParallelCount?: number;
 };
 /**
  * Async version of Array.forEach

package/esm/typings/src/execution/utils/uncertainNumber.d.ts

@@ -1,4 +1,4 @@
-import type { UncertainNumber } from '../PromptResult';
+import type { UncertainNumber } from '../UncertainNumber';
 /**
  * Make UncertainNumber
  *

package/esm/typings/src/execution/utils/usageToHuman.d.ts

@@ -0,0 +1,15 @@
+import type { string_markdown } from '../../types/typeAliases';
+import type { PromptResultUsage } from '../PromptResultUsage';
+/**
+ * Function `usageToHuman` will take usage and convert it to human readable report
+ */
+export declare function usageToHuman(usage: PromptResultUsage): string_markdown;
+/**
+ * TODO: Use "$1" not "1 USD"
+ * TODO: Use markdown formatting like "Cost approximately **$1**"
+ * TODO: Report in minutes, seconds, days NOT 0.1 hours
+ * TODO: [🧠] Maybe make from `uncertainNumberToHuman` separate exported utility
+ * TODO: When negligible usage, report "Negligible" or just don't report it
+ * TODO: [🧠] Maybe use "~" instead of "approximately"
+ * TODO: [🏛] Maybe make some markdown builder
+ */

package/esm/typings/src/execution/utils/usageToWorktime.d.ts

@@ -1,5 +1,5 @@
-import type { PromptResultUsage } from '../PromptResult';
-import type { UncertainNumber } from '../PromptResult';
+import type { PromptResultUsage } from '../PromptResultUsage';
+import type { UncertainNumber } from '../UncertainNumber';
 /**
  * Function usageToWorktime will take usage and estimate saved worktime in hours of reading / writing
  *

package/esm/typings/src/formats/_common/FormatDefinition.d.ts

@@ -65,5 +65,5 @@ export type FormatDefinition<TValue extends TPartialValue, TPartialValue extends
  * TODO: [🍓][👨‍⚖️] Compute TPartialValue dynamically - PartialString<TValue>
  * TODO: [🍓][🧠] Should execution tools be aviable to heal, canBeValid and isValid?
  * TODO: [🍓][🧠] llm Provider Bindings
- * TODO: [🍓]Export via some package
+ * TODO: [🍓][🔼] Export via some package
  */ 

package/esm/typings/src/formats/csv/ListFormatDefinition.d.ts

@@ -8,4 +8,5 @@ export declare const CsvFormatDefinition: FormatDefinition<string, string, objec
  * TODO: [🍓] In `CsvFormatDefinition` implement partial `canBeValid`
  * TODO: [🍓] In `CsvFormatDefinition` implement `heal
  * TODO: [🍓] In `CsvFormatDefinition` implement `extractValues`
- */ 
+ * TODO: [🏢] Allow to expect something inside CSV objects and other formats
+ */

package/esm/typings/src/formats/json/JsonFormatDefinition.d.ts

@@ -12,4 +12,5 @@ export declare const JsonFormatDefinition: FormatDefinition<string, string, obje
  * TODO: [🍓] In `JsonFormatDefinition` implement partial `canBeValid`
  * TODO: [🍓] In `JsonFormatDefinition` implement `heal
  * TODO: [🍓] In `JsonFormatDefinition` implement `extractValues`
- */ 
+ * TODO: [🏢] Allow to expect something inside JSON objects and other formats
+ */

package/esm/typings/src/formats/list/ListFormatDefinition.d.ts

@@ -10,4 +10,5 @@ export declare const ListFormatDefinition: FormatDefinition<string, string, obje
  * TODO: [🍓] In `ListFormatDefinition` implement partial `canBeValid`
  * TODO: [🍓] In `ListFormatDefinition` implement `heal
  * TODO: [🍓] In `ListFormatDefinition` implement `extractValues`
- */ 
+ * TODO: [🏢] Allow to expect something inside each item of list and other formats
+ */

package/esm/typings/src/formats/xml/XmlFormatDefinition.d.ts

@@ -12,4 +12,5 @@ export declare const XmlFormatDefinition: FormatDefinition<string, string, objec
  * TODO: [🍓] In `XmlFormatDefinition` implement partial `canBeValid`
  * TODO: [🍓] In `XmlFormatDefinition` implement `heal
  * TODO: [🍓] In `XmlFormatDefinition` implement `extractValues`
+ * TODO: [🏢] Allow to expect something inside XML and other formats
  */

package/esm/typings/src/knowledge/dialogs/callback/CallbackInterfaceToolsOptions.d.ts

@@ -2,7 +2,7 @@ import type { Promisable } from 'type-fest';
 import type { CommonExecutionToolsOptions } from '../../../execution/CommonExecutionToolsOptions';
 import type { UserInterfaceToolsPromptDialogOptions } from '../../../execution/UserInterfaceTools';
 /**
- * Options for CallbackInterfaceTools
+ * Options for `CallbackInterfaceTools`
  */
 export type CallbackInterfaceToolsOptions = CommonExecutionToolsOptions & {
     /**

package/esm/typings/src/knowledge/dialogs/simple-prompt/SimplePromptInterfaceTools.d.ts

@@ -15,3 +15,6 @@ export declare class SimplePromptInterfaceTools implements UserInterfaceTools {
      */
     promptDialog(options: UserInterfaceToolsPromptDialogOptions): Promise<string>;
 }
+/**
+ * Note: [🔵] This code should never be published outside of `@promptbook/browser`
+ */