@promptbook/components 0.113.0-5 → 0.113.0-7

package/esm/src/book-components/Chat/Chat/insertDictationChunk.d.ts

@@ -8,7 +8,7 @@ export declare function insertDictationChunk(params: {
     readonly dictatedText: string;
     readonly selectionStart: number;
     readonly selectionEnd: number;
-    readonly shouldReplaceSelection: boolean;
+    readonly isReplacingSelection: boolean;
 }): {
     nextValue: string;
     start: number;

package/esm/src/book-components/Chat/Chat/insertDictationChunk.test.d.ts

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

package/esm/src/book-components/Chat/Chat/learnDictationDictionary.test.d.ts

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

package/esm/src/book-components/Chat/Chat/refineFinalDictationChunk.test.d.ts

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

package/esm/src/cli/cli-commands/common/createPositiveIntegerOptionParser.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a Commander argument parser that accepts only positive integers.
+ *
+ * The returned parser is meant to be passed as the coercion callback of `command.option(...)`.
+ * It throws a branded `NotAllowed` error with a clear message referencing the given option name
+ * when the provided value is not a positive integer.
+ *
+ * @private internal utility of `promptbookCli`
+ */
+export declare function createPositiveIntegerOptionParser(optionName: string): (value: string) => number;

package/esm/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.113.0-4`).
+ * It follows semantic versioning (e.g., `0.113.0-5`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/components",
-    "version": "0.113.0-5",
+    "version": "0.113.0-7",
     "description": "Promptbook: Create persistent AI agents that turn your company's scattered knowledge into action",
     "private": false,
     "sideEffects": false,

package/umd/index.umd.js

@@ -34,7 +34,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.113.0-5';
+    const PROMPTBOOK_ENGINE_VERSION = '0.113.0-7';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -6162,7 +6162,7 @@
         isAnimated: true,
         supportsPointerTracking: true,
         render({ context, size, palette, createRandom, timeMs, interaction }) {
-            const { morphologyProfile, animationPhase, leftEyePhaseOffset, rightEyePhaseOffset, tentacleProfiles, skinSpots } = getOctopus3d4StableState(createRandom);
+            const { morphologyProfile, animationPhase, leftEyePhaseOffset, rightEyePhaseOffset, tentacleProfiles, skinSpots, } = getOctopus3d4StableState(createRandom);
             const sceneCenterX = size * 0.5;
             const sceneCenterY = size * 0.535;
             const bob = Math.sin(timeMs / 980 + animationPhase) * size * 0.013;
@@ -6510,10 +6510,7 @@
             Math.max(0, Math.cos(effectiveLongitude)) * 0.12 +
             lowerBlend * tentacleInfluence.core * (0.12 + tentacleInfluence.depthScale * 0.07) -
             Math.max(0, -Math.cos(effectiveLongitude)) * 0.05;
-        const tentacleTubeRadius = lowerBlend *
-            tentacleInfluence.core *
-            (0.12 + tipBlend * 0.07 + tentacleInfluence.widthScale * 0.028) *
-            radiusX;
+        const tentacleTubeRadius = lowerBlend * tentacleInfluence.core * (0.12 + tipBlend * 0.07 + tentacleInfluence.widthScale * 0.028) * radiusX;
         const planarRadiusX = cosineLatitude * radiusX * horizontalScale + tentacleTubeRadius;
         const planarRadiusZ = cosineLatitude * radiusZ * depthScale + tentacleTubeRadius * 0.74;
         const lowerDrop = lowerBlend *
@@ -6525,9 +6522,7 @@
                         (morphologyProfile.tentacles.flowLengthScale - 1) * 0.1));
         const combinedTentacleSway = (primaryTentacleWave + secondaryTentacleWave) * radiusX * (0.06 + tipBlend * 0.06);
         return {
-            x: Math.sin(effectiveLongitude) * planarRadiusX +
-                combinedTentacleSway +
-                tentacleCurl * radiusX * 0.18,
+            x: Math.sin(effectiveLongitude) * planarRadiusX + combinedTentacleSway + tentacleCurl * radiusX * 0.18,
             y: Math.sin(latitude) * radiusY * (1 + upperBlend * 0.14) -
                 upperBlend * radiusY * 0.12 +
                 lowerDrop +
@@ -14164,10 +14159,10 @@
      *
      * @private
      */
-    const TEAM_SYSTEM_MESSAGE_GUIDANCE_LINES = [
-        '-   If a teammate is relevant to the request, consult that teammate using the matching tool.',
-        '-   Do not ask the user for information that a listed teammate can provide directly.',
-    ];
+    const TEAM_SYSTEM_MESSAGE_GUIDANCE = spacetrim.spaceTrim(`
+    -   If a teammate is relevant to the request, consult that teammate using the matching tool.
+    -   Do not ask the user for information that a listed teammate can provide directly.
+`);
     /**
      * Constant for remote agents by Url.
      */
@@ -14349,7 +14344,7 @@
             `);
         });
         return spacetrim.spaceTrim((block) => `
-            ${block(TEAM_SYSTEM_MESSAGE_GUIDANCE_LINES.join('\n'))}
+            ${block(TEAM_SYSTEM_MESSAGE_GUIDANCE)}
 
             ${block(teammateSections.join('\n\n'))}
         `);
@@ -31163,9 +31158,9 @@
      * @private function of `useChatInputAreaDictation`
      */
     function insertDictationChunk(params) {
-        const { currentValue, dictatedText, selectionStart, selectionEnd, shouldReplaceSelection } = params;
+        const { currentValue, dictatedText, selectionStart, selectionEnd, isReplacingSelection } = params;
         const replaceStart = selectionStart;
-        const replaceEnd = shouldReplaceSelection ? selectionEnd : selectionStart;
+        const replaceEnd = isReplacingSelection ? selectionEnd : selectionStart;
         const prefix = currentValue.slice(0, replaceStart);
         const suffix = currentValue.slice(replaceEnd);
         const previousCharacter = prefix.slice(-1);
@@ -31207,7 +31202,7 @@
                 if (!previousWord || !correctedWord) {
                     continue;
                 }
-                if (previousWord.toLowerCase() !== correctedWord.toLowerCase()) {
+                if (previousWord !== correctedWord) {
                     nextDictionary[previousWord.toLowerCase()] = correctedWord;
                 }
             }
@@ -31701,17 +31696,73 @@
         pendingStopFallbackRef.current = null;
     }
     /**
-     * Captures whether the next finalized chunk should replace the current selection.
+     * Captures where the next finalized chunk should be inserted.
      *
      * @private function of `useChatInputAreaDictation`
      */
-    function captureSelectionReplacementIntent(textareaRef, replaceSelectionOnNextFinalRef) {
+    function captureDictationInsertionSelection(textareaRef, dictationInsertionSelectionRef) {
         const textarea = textareaRef.current;
         if (!textarea) {
             return;
         }
-        const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, 0);
-        replaceSelectionOnNextFinalRef.current = selectionStart !== selectionEnd;
+        const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, textarea.value.length);
+        dictationInsertionSelectionRef.current = {
+            selectionStart,
+            selectionEnd,
+            isReplacingSelection: selectionStart !== selectionEnd,
+        };
+    }
+    /**
+     * Resolves the insertion range for one finalized dictation chunk.
+     *
+     * @private function of `useChatInputAreaDictation`
+     */
+    function resolveDictationInsertionSelection(textareaElement, messageContentLength, dictationInsertionSelection) {
+        if (dictationInsertionSelection) {
+            return dictationInsertionSelection;
+        }
+        const { selectionStart, selectionEnd } = resolveTextareaSelection(textareaElement, messageContentLength);
+        return {
+            selectionStart,
+            selectionEnd,
+            isReplacingSelection: selectionStart !== selectionEnd,
+        };
+    }
+    /**
+     * Removes one tracked dictated chunk from the current composer value.
+     *
+     * @private function of `useChatInputAreaDictation`
+     */
+    function removeTrackedDictationChunk(currentValue, chunk) {
+        const trackedText = currentValue.slice(chunk.start, chunk.start + chunk.finalText.length);
+        if (trackedText === chunk.finalText) {
+            return `${currentValue.slice(0, chunk.start)}${currentValue.slice(chunk.start + chunk.finalText.length)}`;
+        }
+        return replaceLastOccurrence(currentValue, chunk.finalText, '');
+    }
+    /**
+     * Replaces one tracked dictated chunk inside the current composer value.
+     *
+     * @private function of `useChatInputAreaDictation`
+     */
+    function replaceTrackedDictationChunk(currentValue, chunk, correctedChunk) {
+        const trackedText = currentValue.slice(chunk.start, chunk.start + chunk.finalText.length);
+        if (trackedText === chunk.finalText) {
+            return `${currentValue.slice(0, chunk.start)}${correctedChunk}${currentValue.slice(chunk.start + chunk.finalText.length)}`;
+        }
+        return replaceLastOccurrence(currentValue, chunk.finalText, correctedChunk);
+    }
+    /**
+     * Stores the next append position after a programmatic dictation edit.
+     *
+     * @private function of `useChatInputAreaDictation`
+     */
+    function updateDictationInsertionCaret(dictationInsertionSelectionRef, caret) {
+        dictationInsertionSelectionRef.current = {
+            selectionStart: caret,
+            selectionEnd: caret,
+            isReplacingSelection: false,
+        };
     }
     /**
      * Produces the corrected chunk value only when a real correction should be applied.
@@ -31792,7 +31843,7 @@
      *
      * @private function of `useChatInputAreaDictation`
      */
-    function useChatInputAreaDictationFinalResultHandler({ textareaRef, messageContentRef, applyMessageContent, dictationSettings, dictationDictionary, replaceSelectionOnNextFinalRef, focusTextareaSelection, state, }) {
+    function useChatInputAreaDictationFinalResultHandler({ textareaRef, messageContentRef, applyMessageContent, dictationSettings, dictationDictionary, dictationInsertionSelectionRef, focusTextareaSelection, state, }) {
         const { setDictationUiState, setDictationInterimText, setDictationError, setDictationLastFinalChunk, setDictationEditableChunk, setDictationChunks, setIsDictationPanelExpanded, } = state;
         return react.useCallback((rawText) => {
             const textarea = textareaRef.current;
@@ -31804,15 +31855,15 @@
             if (!refinedText) {
                 return;
             }
-            const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, previousMessageContent.length);
+            const { selectionStart, selectionEnd, isReplacingSelection } = resolveDictationInsertionSelection(textarea, previousMessageContent.length, dictationInsertionSelectionRef.current);
             const insertion = insertDictationChunk({
                 currentValue: previousMessageContent,
                 dictatedText: refinedText,
                 selectionStart,
                 selectionEnd,
-                shouldReplaceSelection: replaceSelectionOnNextFinalRef.current,
+                isReplacingSelection,
             });
-            replaceSelectionOnNextFinalRef.current = false;
+            updateDictationInsertionCaret(dictationInsertionSelectionRef, insertion.caret);
             setDictationInterimText('');
             setDictationError(null);
             setDictationUiState('listening');
@@ -31832,10 +31883,10 @@
         }, [
             applyMessageContent,
             dictationDictionary,
+            dictationInsertionSelectionRef,
             dictationSettings,
             focusTextareaSelection,
             messageContentRef,
-            replaceSelectionOnNextFinalRef,
             setDictationChunks,
             setDictationEditableChunk,
             setDictationError,
@@ -31883,7 +31934,7 @@
                     return;
                 case 'STOP':
                     clearPendingStopFallback();
-                    setDictationUiState((currentState) => (currentState === 'disabled' ? currentState : 'idle'));
+                    setDictationUiState((currentState) => currentState === 'disabled' || currentState === 'error' ? currentState : 'idle');
                     setDictationInterimText('');
                     return;
             }
@@ -31924,13 +31975,13 @@
      *
      * @private function of `useChatInputAreaDictation`
      */
-    function useChatInputAreaDictationVoiceInputControls({ speechRecognition, textareaRef, resolvedSpeechRecognitionLanguage, whisperMode, pendingStopFallbackRef, replaceSelectionOnNextFinalRef, clearPendingStopFallback, state, }) {
+    function useChatInputAreaDictationVoiceInputControls({ speechRecognition, textareaRef, resolvedSpeechRecognitionLanguage, whisperMode, pendingStopFallbackRef, dictationInsertionSelectionRef, clearPendingStopFallback, state, }) {
         const { dictationUiState, setDictationUiState, setDictationInterimText, setDictationError } = state;
         const startVoiceInput = react.useCallback(() => {
             if (!speechRecognition) {
                 return;
             }
-            captureSelectionReplacementIntent(textareaRef, replaceSelectionOnNextFinalRef);
+            captureDictationInsertionSelection(textareaRef, dictationInsertionSelectionRef);
             setDictationError(null);
             setDictationInterimText('');
             setDictationUiState('listening');
@@ -31940,7 +31991,7 @@
                 whisperMode,
             });
         }, [
-            replaceSelectionOnNextFinalRef,
+            dictationInsertionSelectionRef,
             resolvedSpeechRecognitionLanguage,
             setDictationError,
             setDictationInterimText,
@@ -31992,7 +32043,7 @@
      *
      * @private function of `useChatInputAreaDictation`
      */
-    function useChatInputAreaDictationCorrectionHandlers({ dictationChunks, dictationLastFinalChunk, dictationEditableChunk, dictationDictionary, messageContentRef, applyMessageContent, focusTextareaSelection, setDictationChunks, setDictationLastFinalChunk, setDictationEditableChunk, setDictationDictionary, }) {
+    function useChatInputAreaDictationCorrectionHandlers({ dictationChunks, dictationLastFinalChunk, dictationEditableChunk, dictationDictionary, dictationInsertionSelectionRef, messageContentRef, applyMessageContent, focusTextareaSelection, setDictationChunks, setDictationLastFinalChunk, setDictationEditableChunk, setDictationDictionary, }) {
         const handleBacktrackLastChunk = react.useCallback(() => {
             var _a;
             const previousChunks = [...dictationChunks];
@@ -32000,35 +32051,51 @@
             if (!lastChunk) {
                 return;
             }
+            const nextMessageContent = removeTrackedDictationChunk(messageContentRef.current, lastChunk);
+            const nextCaret = Math.min(lastChunk.start, nextMessageContent.length);
             setDictationChunks(previousChunks);
-            applyMessageContent(lastChunk.beforeValue);
+            applyMessageContent(nextMessageContent);
             const previousFinalChunk = ((_a = previousChunks[previousChunks.length - 1]) === null || _a === void 0 ? void 0 : _a.finalText) || '';
             setDictationLastFinalChunk(previousFinalChunk);
             setDictationEditableChunk(previousFinalChunk);
-            focusTextareaSelection(lastChunk.start, lastChunk.start);
+            updateDictationInsertionCaret(dictationInsertionSelectionRef, nextCaret);
+            focusTextareaSelection(nextCaret, nextCaret);
         }, [
             applyMessageContent,
+            dictationInsertionSelectionRef,
             dictationChunks,
             focusTextareaSelection,
+            messageContentRef,
             setDictationChunks,
             setDictationEditableChunk,
             setDictationLastFinalChunk,
         ]);
         const handleApplyCorrection = react.useCallback(() => {
+            var _a;
             const correctedChunk = resolveCorrectedDictationChunk(dictationEditableChunk, dictationLastFinalChunk);
             if (!correctedChunk) {
                 return;
             }
-            const nextMessageContent = replaceLastOccurrence(messageContentRef.current, dictationLastFinalChunk, correctedChunk);
+            const lastChunk = dictationChunks[dictationChunks.length - 1];
+            const nextMessageContent = lastChunk
+                ? replaceTrackedDictationChunk(messageContentRef.current, lastChunk, correctedChunk)
+                : replaceLastOccurrence(messageContentRef.current, dictationLastFinalChunk, correctedChunk);
+            const correctionStart = (_a = lastChunk === null || lastChunk === void 0 ? void 0 : lastChunk.start) !== null && _a !== void 0 ? _a : nextMessageContent.length;
+            const correctionCaret = Math.min(correctionStart + correctedChunk.length, nextMessageContent.length);
             applyMessageContent(nextMessageContent);
             setDictationLastFinalChunk(correctedChunk);
             setDictationChunks((previousChunks) => replaceLastDictationChunk(previousChunks, correctedChunk));
             setDictationDictionary(learnDictationDictionary(dictationLastFinalChunk, correctedChunk, dictationDictionary));
+            updateDictationInsertionCaret(dictationInsertionSelectionRef, correctionCaret);
+            focusTextareaSelection(correctionCaret, correctionCaret);
         }, [
             applyMessageContent,
             dictationDictionary,
             dictationEditableChunk,
+            dictationChunks,
+            dictationInsertionSelectionRef,
             dictationLastFinalChunk,
+            focusTextareaSelection,
             messageContentRef,
             setDictationChunks,
             setDictationDictionary,
@@ -32046,7 +32113,7 @@
      */
     function useChatInputAreaDictation({ speechRecognition, speechRecognitionLanguage, textareaRef, messageContentRef, applyMessageContent, }) {
         const pendingStopFallbackRef = react.useRef(null);
-        const replaceSelectionOnNextFinalRef = react.useRef(false);
+        const dictationInsertionSelectionRef = react.useRef(null);
         const [dictationUiState, setDictationUiState] = react.useState('idle');
         const [dictationInterimText, setDictationInterimText] = react.useState('');
         const [dictationError, setDictationError] = react.useState(null);
@@ -32079,7 +32146,7 @@
             applyMessageContent,
             dictationSettings,
             dictationDictionary,
-            replaceSelectionOnNextFinalRef,
+            dictationInsertionSelectionRef,
             focusTextareaSelection,
             state: dictationState,
         });
@@ -32099,7 +32166,7 @@
             resolvedSpeechRecognitionLanguage,
             whisperMode: dictationSettings.whisperMode,
             pendingStopFallbackRef,
-            replaceSelectionOnNextFinalRef,
+            dictationInsertionSelectionRef,
             clearPendingStopFallback,
             state: {
                 dictationUiState,
@@ -32113,6 +32180,7 @@
             dictationLastFinalChunk,
             dictationEditableChunk,
             dictationDictionary,
+            dictationInsertionSelectionRef,
             messageContentRef,
             applyMessageContent,
             focusTextareaSelection,