@promptbook/wizard 0.105.0-3 → 0.105.0-5

package/esm/typings/src/_packages/browser.index.d.ts

@@ -1,6 +1,7 @@
 import { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION } from '../version';
 import { SimplePromptInterfaceTools } from '../dialogs/simple-prompt/SimplePromptInterfaceTools';
 import { $provideScrapersForBrowser } from '../scrapers/_common/register/$provideScrapersForBrowser';
+import { BrowserSpeechRecognition } from '../speech-recognition/BrowserSpeechRecognition';
 import { getIndexedDbStorage } from '../storage/local-storage/getIndexedDbStorage';
 import { getLocalStorage } from '../storage/local-storage/getLocalStorage';
 import { getSessionStorage } from '../storage/local-storage/getSessionStorage';
@@ -10,6 +11,7 @@ import { ObjectUrl } from '../utils/files/ObjectUrl';
 export { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION };
 export { SimplePromptInterfaceTools };
 export { $provideScrapersForBrowser };
+export { BrowserSpeechRecognition };
 export { getIndexedDbStorage };
 export { getLocalStorage };
 export { getSessionStorage };

package/esm/typings/src/_packages/types.index.d.ts

@@ -183,6 +183,7 @@ import type { PostprocessingFunction } from '../scripting/javascript/JavascriptE
 import type { ToolFunction } from '../scripting/javascript/JavascriptExecutionToolsOptions';
 import type { SearchEngine } from '../search-engines/SearchEngine';
 import type { SearchResult } from '../search-engines/SearchResult';
+import type { OpenAiSpeechRecognitionOptions } from '../speech-recognition/OpenAiSpeechRecognition';
 import type { PromptbookStorage } from '../storage/_common/PromptbookStorage';
 import type { FileCacheStorageOptions } from '../storage/file-cache-storage/FileCacheStorageOptions';
 import type { IndexedDbStorageOptions } from '../storage/local-storage/utils/IndexedDbStorageOptions';
@@ -207,6 +208,10 @@ import type { ImagePrompt } from '../types/Prompt';
 import type { EmbeddingPrompt } from '../types/Prompt';
 import type { ScriptLanguage } from '../types/ScriptLanguage';
 import type { SectionType } from '../types/SectionType';
+import type { SpeechRecognition } from '../types/SpeechRecognition';
+import type { SpeechRecognitionStartOptions } from '../types/SpeechRecognition';
+import type { SpeechRecognitionState } from '../types/SpeechRecognition';
+import type { SpeechRecognitionEvent } from '../types/SpeechRecognition';
 import type { TaskType } from '../types/TaskType';
 import type { string_char_emoji } from '../types/typeAliasEmoji';
 import type { string_business_category_name } from '../types/typeAliases';
@@ -316,6 +321,7 @@ import type { string_license_token } from '../types/typeAliases';
 import type { string_password } from '../types/typeAliases';
 import type { string_ssh_key } from '../types/typeAliases';
 import type { string_pgp_key } from '../types/typeAliases';
+import type { string_language } from '../types/typeAliases';
 import type { string_date_iso8601 } from '../types/typeAliases';
 import type { number_usd } from '../types/typeAliases';
 import type { number_id } from '../types/typeAliases';
@@ -557,6 +563,7 @@ export type { PostprocessingFunction };
 export type { ToolFunction };
 export type { SearchEngine };
 export type { SearchResult };
+export type { OpenAiSpeechRecognitionOptions };
 export type { PromptbookStorage };
 export type { FileCacheStorageOptions };
 export type { IndexedDbStorageOptions };
@@ -581,6 +588,10 @@ export type { ImagePrompt };
 export type { EmbeddingPrompt };
 export type { ScriptLanguage };
 export type { SectionType };
+export type { SpeechRecognition };
+export type { SpeechRecognitionStartOptions };
+export type { SpeechRecognitionState };
+export type { SpeechRecognitionEvent };
 export type { TaskType };
 export type { string_char_emoji };
 export type { string_business_category_name };
@@ -690,6 +701,7 @@ export type { string_license_token };
 export type { string_password };
 export type { string_ssh_key };
 export type { string_pgp_key };
+export type { string_language };
 export type { string_date_iso8601 };
 export type { number_usd };
 export type { number_id };

package/esm/typings/src/book-2.0/agent-source/AgentBasicInformation.d.ts

@@ -31,7 +31,7 @@ export type AgentCapability = {
     /**
      * The type of the capability
      */
-    type: 'browser' | 'search-engine' | 'knowledge' | 'time';
+    type: 'browser' | 'search-engine' | 'knowledge' | 'time' | 'inheritance' | 'import';
     /**
      * The label to display for this capability
      */
@@ -40,6 +40,11 @@ export type AgentCapability = {
      * The name of the icon to display for this capability
      */
     iconName: string;
+    /**
+     * Optional link to another agent
+     * This is used for 'inheritance' and 'import' types
+     */
+    agentUrl?: string_agent_url;
 };
 export type AgentBasicInformation = {
     /**

package/esm/typings/src/book-components/Chat/Chat/ChatProps.d.ts

@@ -5,6 +5,7 @@ import type { ChatMessage } from '../types/ChatMessage';
 import type { ChatParticipant } from '../types/ChatParticipant';
 import { string_color } from '../../../types/typeAliases';
 import { Color } from '../../../_packages/color.index';
+import { SpeechRecognition } from '../../../types/SpeechRecognition';
 /**
  * @public exported from `@promptbook/components`
  */
@@ -47,13 +48,9 @@ export type ChatProps = {
      */
     readonly isVoiceRecognitionButtonShown?: boolean;
     /**
-     * Optional callback to trigger voice input
+     * Speech recognition provider
      */
-    onVoiceInput?(): void;
-    /**
-     * The language code to use for voice recognition
-     */
-    readonly voiceLanguage?: string;
+    readonly speechRecognition?: SpeechRecognition;
     /**
      * Optional placeholder message for the textarea
      *

package/esm/typings/src/book-components/Chat/types/ChatMessage.d.ts

@@ -33,6 +33,15 @@ export type ChatMessage = Omit<Message<id>, 'direction' | 'recipients' | 'thread
      * Indicates if the message was sent via a voice call
      */
     isVoiceCall?: boolean;
+    /**
+     * Optional tool calls made during the execution
+     */
+    readonly ongoingToolCalls?: ReadonlyArray<{
+        /**
+         * Name of the tool
+         */
+        readonly name: string;
+    }>;
     /**
      * Optional file attachments
      */

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

@@ -56,7 +56,9 @@ export type LlmExecutionTools = {
     /**
      * Calls a chat model with streaming
      */
-    callChatModelStream?(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void): Promise<ChatPromptResult>;
+    callChatModelStream?(prompt: Prompt, onProgress: (chunk: ChatPromptResult & {
+        isFinished?: boolean;
+    }) => void): Promise<ChatPromptResult>;
     /**
      * Calls a voice chat model
      */

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

@@ -39,10 +39,17 @@ export declare abstract class OpenAiCompatibleExecutionTools implements LlmExecu
      * List all available OpenAI compatible models that can be used
      */
     listModels(): Promise<ReadonlyArray<AvailableModel>>;
+    /**
+     * Calls OpenAI compatible API to use a chat model.
+     */
     /**
      * Calls OpenAI compatible API to use a chat model.
      */
     callChatModel(prompt: Prompt): Promise<ChatPromptResult>;
+    /**
+     * Calls OpenAI compatible API to use a chat model with streaming.
+     */
+    callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void): Promise<ChatPromptResult>;
     /**
      * Internal method that handles parameter retry for chat model calls
      */

package/esm/typings/src/search-engines/_index.d.ts

@@ -0,0 +1,6 @@
+export * from './bing/BingSearchEngine';
+export * from './dummy/DummySearchEngine';
+export * from './google/GoogleSearchEngine';
+export * from './SearchEngine';
+export * from './SearchResult';
+export * from './serp/SerpSearchEngine';

package/esm/typings/src/search-engines/google/GoogleSearchEngine.d.ts

@@ -0,0 +1,18 @@
+import type { Promisable } from 'type-fest';
+import type { string_markdown, string_markdown_text, string_title } from '../../types/typeAliases';
+import type { SearchEngine } from '../SearchEngine';
+import type { SearchResult } from '../SearchResult';
+/**
+ * A search engine implementation that uses the Google Custom Search JSON API.
+ *
+ * @private <- TODO: !!!! Export via some package
+ */
+export declare class GoogleSearchEngine implements SearchEngine {
+    get title(): string_title & string_markdown_text;
+    get description(): string_markdown;
+    /**
+     * @see https://developers.google.com/custom-search/v1/overview
+     */
+    checkConfiguration(): Promisable<void>;
+    search(query: string): Promise<SearchResult[]>;
+}

package/esm/typings/src/search-engines/serp/SerpSearchEngine.d.ts

@@ -0,0 +1,15 @@
+import type { Promisable } from 'type-fest';
+import type { string_markdown, string_markdown_text, string_title } from '../../types/typeAliases';
+import type { SearchEngine } from '../SearchEngine';
+import type { SearchResult } from '../SearchResult';
+/**
+ * A search engine implementation that uses the SerpApi to fetch Google search results.
+ *
+ * @private <- TODO: !!!! Export via some package
+ */
+export declare class SerpSearchEngine implements SearchEngine {
+    get title(): string_title & string_markdown_text;
+    get description(): string_markdown;
+    checkConfiguration(): Promisable<void>;
+    search(query: string): Promise<SearchResult[]>;
+}

package/esm/typings/src/speech-recognition/BrowserSpeechRecognition.d.ts

@@ -0,0 +1,21 @@
+import type { SpeechRecognition, SpeechRecognitionEvent, SpeechRecognitionStartOptions, SpeechRecognitionState } from '../types/SpeechRecognition';
+/**
+ * Speech recognition using Web Speech API `SpeechRecognition` available in modern browsers
+ *
+ * @public exported from `@promptbook/browser`
+ */
+export declare class BrowserSpeechRecognition implements SpeechRecognition {
+    private recognition;
+    private callbacks;
+    private _state;
+    get state(): SpeechRecognitionState;
+    constructor();
+    $start(options?: SpeechRecognitionStartOptions): void;
+    $stop(): void;
+    subscribe(callback: (event: SpeechRecognitionEvent) => void): () => void;
+    private emit;
+}
+/**
+ * TODO: !!!! Search ACRY for `window` and put -> [🔵]
+ * Note: [🔵] Code in this file should never be published outside of `@promptbook/browser`
+ */

package/esm/typings/src/speech-recognition/OpenAiSpeechRecognition.d.ts

@@ -0,0 +1,32 @@
+import type { SpeechRecognition, SpeechRecognitionEvent, SpeechRecognitionStartOptions, SpeechRecognitionState } from '../types/SpeechRecognition';
+/**
+ * Options for OpenAiSpeechRecognition
+ */
+export type OpenAiSpeechRecognitionOptions = {
+    /**
+     * OpenAI API base URL or proxy endpoint
+     * @default '/api/openai/v1'
+     */
+    readonly baseUrl?: string;
+};
+/**
+ * Speech recognition using OpenAI Whisper API to transcribe audio into text
+ *
+ * @private because it requires server-client communication with a proxy endpoint
+ *
+ * Note: This implementation uses a server-side proxy to avoid exposing the OpenAI API key on the client.
+ */
+export declare class OpenAiSpeechRecognition implements SpeechRecognition {
+    private readonly options;
+    private mediaRecorder;
+    private audioChunks;
+    private callbacks;
+    private _state;
+    get state(): SpeechRecognitionState;
+    constructor(options?: OpenAiSpeechRecognitionOptions);
+    $start(options?: SpeechRecognitionStartOptions): Promise<void>;
+    $stop(): void;
+    private transcribe;
+    subscribe(callback: (event: SpeechRecognitionEvent) => void): () => void;
+    private emit;
+}

package/esm/typings/src/types/SpeechRecognition.d.ts

@@ -0,0 +1,58 @@
+import type { string_language } from './typeAliases';
+/**
+ * Interface for speech-to-text recognition
+ *
+ * @🚉 fully serializable as JSON
+ */
+export type SpeechRecognition = {
+    /**
+     * Start the speech recognition
+     */
+    $start(options: SpeechRecognitionStartOptions): void;
+    /**
+     * Stop the speech recognition
+     */
+    $stop(): void;
+    /**
+     * Current state of the speech recognition
+     */
+    readonly state: SpeechRecognitionState;
+    /**
+     * Subscribe to speech recognition events
+     */
+    subscribe(callback: (event: SpeechRecognitionEvent) => void): () => void;
+};
+/**
+ * Options for starting speech recognition
+ */
+export type SpeechRecognitionStartOptions = {
+    /**
+     * Language for speech recognition
+     * @default 'en-US'
+     */
+    readonly language?: string_language;
+    /**
+     * Whether to return interim results
+     * @default true
+     */
+    readonly interimResults?: boolean;
+};
+/**
+ * Current state of the speech recognition
+ */
+export type SpeechRecognitionState = 'IDLE' | 'STARTING' | 'RECORDING' | 'TRANSCRIBING' | 'ERROR';
+/**
+ * Event emitted by speech recognition
+ */
+export type SpeechRecognitionEvent = {
+    readonly type: 'START';
+} | {
+    readonly type: 'RESULT';
+    readonly text: string;
+    readonly isFinal: boolean;
+} | {
+    readonly type: 'ERROR';
+    readonly message: string;
+} | {
+    readonly type: 'STOP';
+};

package/esm/typings/src/types/typeAliases.d.ts

@@ -668,6 +668,10 @@ export type string_license_token = string_token;
 export type string_password = string;
 export type string_ssh_key = string;
 export type string_pgp_key = string;
+/**
+ * Language as a string, e.g. 'en-US', 'cs-CZ', 'en'
+ */
+export type string_language = string;
 /**
  * Semantic helper for `Date.toISOString()` result
  *

package/esm/typings/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.105.0-2`).
+ * It follows semantic versioning (e.g., `0.105.0-4`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/wizard",
-    "version": "0.105.0-3",
+    "version": "0.105.0-5",
     "description": "Promptbook: Turn your company's scattered knowledge into AI ready books",
     "private": false,
     "sideEffects": false,
@@ -95,7 +95,7 @@
     "module": "./esm/index.es.js",
     "typings": "./esm/typings/src/_packages/wizard.index.d.ts",
     "peerDependencies": {
-        "@promptbook/core": "0.105.0-3"
+        "@promptbook/core": "0.105.0-5"
     },
     "dependencies": {
         "@ai-sdk/deepseek": "0.1.17",

package/umd/index.umd.js

@@ -48,7 +48,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.105.0-3';
+    const PROMPTBOOK_ENGINE_VERSION = '0.105.0-5';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -5844,20 +5844,29 @@
             });
             return availableModels;
         }
+        /**
+         * Calls OpenAI compatible API to use a chat model.
+         */
         /**
          * Calls OpenAI compatible API to use a chat model.
          */
         async callChatModel(prompt) {
+            return this.callChatModelStream(prompt, () => { });
+        }
+        /**
+         * Calls OpenAI compatible API to use a chat model with streaming.
+         */
+        async callChatModelStream(prompt, onProgress) {
             // Deep clone prompt and modelRequirements to avoid mutation across calls
             const clonedPrompt = JSON.parse(JSON.stringify(prompt));
             // Use local Set for retried parameters to ensure independence and thread safety
             const retriedUnsupportedParameters = new Set();
-            return this.callChatModelWithRetry(clonedPrompt, clonedPrompt.modelRequirements, [], retriedUnsupportedParameters);
+            return this.callChatModelWithRetry(clonedPrompt, clonedPrompt.modelRequirements, [], retriedUnsupportedParameters, onProgress);
         }
         /**
          * Internal method that handles parameter retry for chat model calls
          */
-        async callChatModelWithRetry(prompt, currentModelRequirements, attemptStack = [], retriedUnsupportedParameters = new Set()) {
+        async callChatModelWithRetry(prompt, currentModelRequirements, attemptStack = [], retriedUnsupportedParameters = new Set(), onProgress) {
             var _a;
             if (this.options.isVerbose) {
                 console.info(`💬 ${this.title} callChatModel call`, { prompt, currentModelRequirements });
@@ -5963,6 +5972,23 @@
                     const usage = this.computeUsage(content || '', responseMessage.content || '', rawResponse);
                     totalUsage = addUsage(totalUsage, usage);
                     if (responseMessage.tool_calls && responseMessage.tool_calls.length > 0) {
+                        if (onProgress) {
+                            onProgress({
+                                content: responseMessage.content || '',
+                                modelName: rawResponse.model || modelName,
+                                timing: { start, complete: $getCurrentDate() },
+                                usage: totalUsage,
+                                toolCalls: responseMessage.tool_calls.map((toolCall) => ({
+                                    name: toolCall.function.name,
+                                    arguments: toolCall.function.arguments,
+                                    result: '',
+                                    rawToolCall: toolCall,
+                                })),
+                                rawPromptContent,
+                                rawRequest,
+                                rawResponse,
+                            });
+                        }
                         await forEachAsync(responseMessage.tool_calls, {}, async (toolCall) => {
                             const functionName = toolCall.function.name;
                             const functionArgs = toolCall.function.arguments;
@@ -5984,7 +6010,7 @@
                                     const args = ${functionArgs};
                                     return await ${functionName}(args);
                                 `,
-                                    parameters: {}, // <- TODO: [🧠] What parameters to pass?
+                                    parameters: prompt.parameters,
                                 });
                             }
                             catch (error) {
@@ -6090,7 +6116,7 @@
                     });
                     // Remove the unsupported parameter and retry
                     const modifiedModelRequirements = removeUnsupportedModelRequirement(currentModelRequirements, unsupportedParameter);
-                    return this.callChatModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters);
+                    return this.callChatModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters, onProgress);
                 }
             }
             throw new PipelineExecutionError(`Tool calling loop did not return a result from ${this.title}`);
@@ -8204,6 +8230,15 @@
             // [🐱‍🚀] When tools are present, we need to use the non-streaming Runs API
             // because streaming doesn't support tool execution flow properly
             if (hasTools) {
+                onProgress({
+                    content: '',
+                    modelName: 'assistant',
+                    timing: { start, complete: $getCurrentDate() },
+                    usage: UNCERTAIN_USAGE,
+                    rawPromptContent,
+                    rawRequest: null,
+                    rawResponse: null,
+                });
                 const rawRequest = {
                     assistant_id: this.assistantId,
                     thread: {
@@ -8227,6 +8262,23 @@
                             if (toolCall.type === 'function') {
                                 const functionName = toolCall.function.name;
                                 const functionArgs = JSON.parse(toolCall.function.arguments);
+                                onProgress({
+                                    content: '',
+                                    modelName: 'assistant',
+                                    timing: { start, complete: $getCurrentDate() },
+                                    usage: UNCERTAIN_USAGE,
+                                    rawPromptContent,
+                                    rawRequest: null,
+                                    rawResponse: null,
+                                    toolCalls: [
+                                        {
+                                            name: functionName,
+                                            arguments: toolCall.function.arguments,
+                                            result: '',
+                                            rawToolCall: toolCall,
+                                        },
+                                    ],
+                                });
                                 if (this.options.isVerbose) {
                                     console.info(`🔧 Executing tool: ${functionName}`, functionArgs);
                                 }
@@ -8249,7 +8301,7 @@
                                         const args = ${JSON.stringify(functionArgs)};
                                         return await ${functionName}(args);
                                     `,
-                                        parameters: {}, // <- TODO: [🧠] What parameters to pass?
+                                        parameters: prompt.parameters,
                                     });
                                     if (this.options.isVerbose) {
                                         console.info(`✅ Tool ${functionName} executed:`, functionResponse);
@@ -17838,7 +17890,12 @@
                         description: 'Get the current date and time in ISO 8601 format.',
                         parameters: {
                             type: 'object',
-                            properties: {},
+                            properties: {
+                                timezone: {
+                                    type: 'string',
+                                    description: 'Optional timezone name (e.g. "Europe/Prague", "UTC", "America/New_York").',
+                                },
+                            },
                             required: [],
                         },
                     },
@@ -17858,9 +17915,36 @@
          */
         getToolFunctions() {
             return {
-                async get_current_time() {
-                    console.log('!!!! [Tool] get_current_time called');
-                    return new Date().toISOString();
+                async get_current_time(args) {
+                    var _a;
+                    console.log('!!!! [Tool] get_current_time called', { args });
+                    const { timezone } = args;
+                    if (!timezone) {
+                        return new Date().toISOString();
+                    }
+                    try {
+                        // Note: Returning ISO 8601 string but in the requested timezone
+                        const formatter = new Intl.DateTimeFormat('en-CA', {
+                            timeZone: timezone,
+                            year: 'numeric',
+                            month: '2-digit',
+                            day: '2-digit',
+                            hour: '2-digit',
+                            minute: '2-digit',
+                            second: '2-digit',
+                            hour12: false,
+                            timeZoneName: 'shortOffset',
+                        });
+                        const parts = formatter.formatToParts(new Date());
+                        const part = (type) => { var _a; return (_a = parts.find((p) => p.type === type)) === null || _a === void 0 ? void 0 : _a.value; };
+                        // en-CA format is YYYY-MM-DD
+                        const isoString = `${part('year')}-${part('month')}-${part('day')}T${part('hour')}:${part('minute')}:${part('second')}${(_a = part('timeZoneName')) === null || _a === void 0 ? void 0 : _a.replace('GMT', '')}`;
+                        return isoString;
+                    }
+                    catch (error) {
+                        // Fallback to UTC if timezone is invalid
+                        return new Date().toISOString();
+                    }
                 },
             };
         }
@@ -18727,26 +18811,52 @@
                 });
                 continue;
             }
+            if (commitment.type === 'FROM') {
+                const content = spaceTrim__default["default"](commitment.content).split('\n')[0] || '';
+                if (content === 'Adam' || content === '' /* <- Note: Adam is implicit */) {
+                    continue;
+                }
+                let label = content;
+                let iconName = 'SquareArrowOutUpRight'; // Inheritance remote
+                if (content.startsWith('./') || content.startsWith('../') || content.startsWith('/')) {
+                    label = content.split('/').pop() || content;
+                    iconName = 'SquareArrowUpRight'; // Inheritance local
+                }
+                if (content === 'VOID') {
+                    label = 'VOID';
+                    iconName = 'ShieldAlert'; // [🧠] Or some other icon for VOID
+                }
+                capabilities.push({
+                    type: 'inheritance',
+                    label,
+                    iconName,
+                    agentUrl: content,
+                });
+                continue;
+            }
             if (commitment.type === 'IMPORT') {
                 const content = spaceTrim__default["default"](commitment.content).split('\n')[0] || '';
                 let label = content;
-                const iconName = 'Download';
+                let iconName = 'ExternalLink'; // Import remote
                 try {
                     if (content.startsWith('http://') || content.startsWith('https://')) {
                         const url = new URL(content);
                         label = url.hostname.replace(/^www\./, '') + '.../' + url.pathname.split('/').pop();
+                        iconName = 'ExternalLink';
                     }
                     else if (content.startsWith('./') || content.startsWith('../') || content.startsWith('/')) {
                         label = content.split('/').pop() || content;
+                        iconName = 'Link'; // Import local
                     }
                 }
                 catch (e) {
                     // Invalid URL or path, keep default label
                 }
                 capabilities.push({
-                    type: 'knowledge',
+                    type: 'import',
                     label,
                     iconName,
+                    agentUrl: content,
                 });
                 continue;
             }