@promptbook/wizard 0.105.0-4 → 0.105.0-5

package/esm/index.es.js

@@ -36,7 +36,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.105.0-4';
+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
@@ -5832,20 +5832,29 @@ class OpenAiCompatibleExecutionTools {
         });
         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 });
@@ -5951,6 +5960,23 @@ class OpenAiCompatibleExecutionTools {
                 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;
@@ -6078,7 +6104,7 @@ class OpenAiCompatibleExecutionTools {
                 });
                 // 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}`);
@@ -8192,6 +8218,15 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         // [🐱‍🚀] 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: {
@@ -8215,6 +8250,23 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
                         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);
                             }
@@ -18747,26 +18799,52 @@ function parseAgentSource(agentSource) {
             });
             continue;
         }
+        if (commitment.type === 'FROM') {
+            const content = spaceTrim$2(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$2(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;
         }