pi-ui-extend 1.0.42 → 1.0.46

package/dist/app/input/autocomplete-controller.js

@@ -138,57 +138,84 @@ export class AppAutocompleteController {
     }
 }
 export async function completeInputWithPi(runtime, draft, config, signal) {
-    const parsedModel = parseModelRef(config.modelRef);
     const modelRuntime = runtime.services.modelRuntime;
-    let model = modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
-    if (!model) {
-        await modelRuntime.refresh();
-        model = modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
-    }
-    if (!model)
-        throw new Error(`Model not found: ${parsedModel.provider}/${parsedModel.modelId}`);
     const timeoutMs = numberInRange(config.timeoutMs, AUTOCOMPLETE_TIMEOUT_MS, 250, 10_000);
     const maxTokens = numberInRange(config.maxTokens, AUTOCOMPLETE_MAX_TOKENS, 8, 256);
     const maxPromptTokens = numberInRange(config.maxPromptTokens, AUTOCOMPLETE_MAX_PROMPT_TOKENS, 256, 16_000);
     const requestSignal = createTimeoutSignal(signal, timeoutMs);
-    const requestMaxTokens = model.maxTokens > 0 ? Math.min(model.maxTokens, maxTokens) : maxTokens;
-    const requestModel = { ...model, maxTokens: requestMaxTokens };
     const includeRecentMessages = numberInRange(config.includeRecentMessages, AUTOCOMPLETE_INCLUDE_RECENT_MESSAGES, 0, 20);
     const history = includeRecentMessages > 0 ? autocompleteHistoryFromMessages(runtime.session.messages, includeRecentMessages) : [];
     const prompt = buildAutocompletePrompt({ cwd: runtime.cwd, draft, history, maxPromptTokens });
     if (!prompt)
         return "";
-    let output = "";
-    let streamError;
     try {
-        const stream = modelRuntime.streamSimple(requestModel, {
-            systemPrompt: AUTOCOMPLETE_SYSTEM_PROMPT,
-            messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
-        }, {
-            cacheRetention: "none",
-            maxRetryDelayMs: 0,
-            maxRetries: 0,
-            maxTokens: requestModel.maxTokens,
-            ...(parsedModel.thinkingLevel && parsedModel.thinkingLevel !== "off" ? { reasoning: parsedModel.thinkingLevel } : {}),
-            signal: requestSignal.signal,
-            timeoutMs,
-        });
-        for await (const event of stream) {
-            if (event.type === "text_delta")
-                output += event.delta;
-            else if (event.type === "done" && !output)
-                output = assistantMessageText(event.message);
-            else if (event.type === "error")
-                streamError = event.error.errorMessage ?? event.reason;
+        let refreshed = false;
+        let lastError;
+        for (const modelRef of modelRefChain(config.modelRef, config.fallbackModels)) {
+            if (requestSignal.signal.aborted)
+                throw requestSignal.signal.reason ?? new Error("Autocomplete request aborted");
+            let parsedModel;
+            try {
+                parsedModel = parseModelRef(modelRef);
+            }
+            catch (error) {
+                lastError = error;
+                continue;
+            }
+            let model = modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
+            if (!model && !refreshed) {
+                await modelRuntime.refresh();
+                refreshed = true;
+                model = modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
+            }
+            if (!model) {
+                lastError = new Error(`Model not found: ${parsedModel.provider}/${parsedModel.modelId}`);
+                continue;
+            }
+            try {
+                const requestMaxTokens = model.maxTokens > 0 ? Math.min(model.maxTokens, maxTokens) : maxTokens;
+                const requestModel = { ...model, maxTokens: requestMaxTokens };
+                let output = "";
+                let streamError;
+                const stream = modelRuntime.streamSimple(requestModel, {
+                    systemPrompt: AUTOCOMPLETE_SYSTEM_PROMPT,
+                    messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+                }, {
+                    cacheRetention: "none",
+                    maxRetryDelayMs: 0,
+                    maxRetries: 0,
+                    maxTokens: requestModel.maxTokens,
+                    ...(parsedModel.thinkingLevel && parsedModel.thinkingLevel !== "off" ? { reasoning: parsedModel.thinkingLevel } : {}),
+                    signal: requestSignal.signal,
+                    timeoutMs,
+                });
+                for await (const event of stream) {
+                    if (event.type === "text_delta")
+                        output += event.delta;
+                    else if (event.type === "done" && !output)
+                        output = assistantMessageText(event.message);
+                    else if (event.type === "error")
+                        streamError = event.error.errorMessage ?? event.reason;
+                }
+                if (streamError)
+                    throw new Error(streamError);
+                return output;
+            }
+            catch (error) {
+                if (requestSignal.signal.aborted)
+                    throw requestSignal.signal.reason ?? error;
+                lastError = error;
+            }
         }
-        if (streamError)
-            throw new Error(streamError);
-        return output;
+        throw lastError ?? new Error("No autocomplete models are configured");
     }
     finally {
         requestSignal.dispose();
     }
 }
+function modelRefChain(primary, fallbacks) {
+    return [...new Set([primary, ...(fallbacks ?? [])].map((ref) => ref.trim()).filter(Boolean))];
+}
 export function autocompleteHistoryFromMessages(messages, includeRecentMessages) {
     const limit = numberInRange(includeRecentMessages, AUTOCOMPLETE_INCLUDE_RECENT_MESSAGES, 0, 20);
     if (limit <= 0)

package/dist/app/input/input-action-controller.d.ts

@@ -9,6 +9,8 @@ import type { Entry, SessionActivity } from "../types.js";
 export type AppInputActionControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     inputScopeKey?(): string | undefined;
+    isDraftTabActive?(): boolean;
+    materializeDraftSession?(): Promise<AgentSessionRuntime | undefined>;
     isRunning(): boolean;
     isSessionSwitching(): boolean;
     inputEditor(): InputEditor;

package/dist/app/input/input-action-controller.js

@@ -149,7 +149,6 @@ export class AppInputActionController {
         await this.host.stopVoiceInput();
         if (this.host.inputScopeKey && this.host.inputScopeKey() !== inputScopeKey)
             return;
-        const runtime = this.host.runtime();
         const inputEditor = this.host.inputEditor();
         const rawPromptText = inputEditor.promptText;
         const rawDisplayText = inputEditor.expandedText;
@@ -176,6 +175,14 @@ export class AppInputActionController {
             await this.popupActions.submitSlashCommand(promptText);
             return;
         }
+        let runtime = this.host.runtime();
+        if (!runtime && this.host.isDraftTabActive?.()) {
+            runtime = await this.host.materializeDraftSession?.();
+            if (this.host.inputScopeKey && this.host.inputScopeKey() !== inputScopeKey)
+                return;
+            if (!runtime)
+                return;
+        }
         const message = this.queuedMessages.createSubmittedUserMessage(promptText, displayText, images);
         this.host.requestHistory().add(message.displayText);
         inputEditor.clear();

package/dist/app/input/input-controller.d.ts

@@ -16,6 +16,7 @@ export type InputControllerHost = {
     resetInputMenuDismissals(): void;
     render(): void;
     moveActivePopupMenuSelection(delta: number): boolean;
+    moveActiveModelThinkingLevel(delta: number): boolean;
     navigateRequestHistory(delta: number): boolean;
     scrollByLines(delta: number): void;
     scrollByPage(delta: number): void;
@@ -24,8 +25,8 @@ export type InputControllerHost = {
     handleInterrupt(): Promise<void>;
     handleEscape(): Promise<void>;
     handleDirectPopupInput(char: string): boolean;
+    toggleModelVisibilityMode(): boolean;
     autocompleteModel(): boolean;
-    autocompleteThinking(): boolean;
     acceptAutocompleteSuggestion(): boolean;
     autocompleteSlashCommand(): void;
     toggleVoiceRecording(): void;

package/dist/app/input/input-controller.js

@@ -229,6 +229,9 @@ export class AppInputController {
     getEscapeSequences() {
         return [
             ...SHIFT_ENTER_ESCAPE_SEQUENCES.map((sequence) => [sequence, () => this.insertInputNewline()]),
+            ["\x1b[Z", () => { this.host.toggleModelVisibilityMode(); }],
+            ["\x1b[9;2u", () => { this.host.toggleModelVisibilityMode(); }],
+            ["\x1b[27;2;9~", () => { this.host.toggleModelVisibilityMode(); }],
             ["\x1b[13u", () => this.host.handleEnter()],
             ["\x1b[13;1u", () => this.host.handleEnter()],
             ["\x1b[5~", () => this.host.scrollByPage(-1)],
@@ -460,6 +463,8 @@ export class AppInputController {
         this.host.scrollByLines(1);
     }
     handleArrowLeft() {
+        if (this.host.moveActiveModelThinkingLevel(-1))
+            return;
         if (this.host.inputEditor.hasSelection) {
             const [start] = this.orderedEditorSelection();
             this.host.inputEditor.clearSelection();
@@ -473,6 +478,8 @@ export class AppInputController {
         }
     }
     handleArrowRight() {
+        if (this.host.moveActiveModelThinkingLevel(1))
+            return;
         if (this.host.inputEditor.hasSelection) {
             const [, end] = this.orderedEditorSelection();
             this.host.inputEditor.clearSelection();
@@ -554,8 +561,6 @@ export class AppInputController {
                 return;
             if (this.host.autocompleteModel())
                 return;
-            if (this.host.autocompleteThinking())
-                return;
             this.host.autocompleteSlashCommand();
             return;
         }

package/dist/app/input/prompt-enhancer-controller.js

@@ -129,7 +129,6 @@ export function promptEnhancerTextIsSufficient(text) {
     return text.trim().length >= PROMPT_ENHANCER_MIN_TEXT_LENGTH;
 }
 async function enhancePromptWithPi(runtime, draft, config) {
-    const parsedModel = parseModelRef(config.modelRef);
     const services = await promptEnhancerPiDeps.createAgentSessionServices({
         cwd: runtime.cwd,
         agentDir: runtime.services.agentDir,
@@ -145,41 +144,60 @@ async function enhancePromptWithPi(runtime, draft, config) {
         },
     });
     await services.modelRuntime.refresh();
-    const model = services.modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
-    if (!model) {
-        throw new Error(modelNotFoundMessage(parsedModel.provider, parsedModel.modelId, services.modelRuntime.getModels()));
-    }
-    const { session } = await promptEnhancerPiDeps.createAgentSessionFromServices({
-        services,
-        sessionManager: promptEnhancerPiDeps.sessionManagerInMemory(runtime.cwd),
-        model,
-        thinkingLevel: parsedModel.thinkingLevel ?? "minimal",
-        noTools: "all",
-    });
-    let output = "";
-    let streamError;
-    const unsubscribe = session.subscribe((event) => {
-        if (event.type !== "message_update")
-            return;
-        const assistantEvent = event.assistantMessageEvent;
-        if (assistantEvent.type === "text_delta")
-            output += assistantEvent.delta;
-        else if (assistantEvent.type === "error")
-            streamError = assistantEvent.error.errorMessage ?? assistantEvent.reason;
-    });
-    try {
-        await session.prompt(buildEnhancerPrompt(draft), { expandPromptTemplates: false });
-        if (streamError)
-            throw new Error(streamError);
-        const cleaned = cleanupEnhancedPrompt(output);
-        if (cleaned.length === 0)
-            throw new Error("model returned an empty prompt");
-        return cleaned;
-    }
-    finally {
-        unsubscribe();
-        session.dispose();
+    let lastError;
+    for (const modelRef of modelRefChain(config.modelRef, config.fallbackModels)) {
+        let parsedModel;
+        try {
+            parsedModel = parseModelRef(modelRef);
+        }
+        catch (error) {
+            lastError = error;
+            continue;
+        }
+        const model = services.modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
+        if (!model) {
+            lastError = new Error(modelNotFoundMessage(parsedModel.provider, parsedModel.modelId, services.modelRuntime.getModels()));
+            continue;
+        }
+        const { session } = await promptEnhancerPiDeps.createAgentSessionFromServices({
+            services,
+            sessionManager: promptEnhancerPiDeps.sessionManagerInMemory(runtime.cwd),
+            model,
+            thinkingLevel: parsedModel.thinkingLevel ?? "minimal",
+            noTools: "all",
+        });
+        let output = "";
+        let streamError;
+        const unsubscribe = session.subscribe((event) => {
+            if (event.type !== "message_update")
+                return;
+            const assistantEvent = event.assistantMessageEvent;
+            if (assistantEvent.type === "text_delta")
+                output += assistantEvent.delta;
+            else if (assistantEvent.type === "error")
+                streamError = assistantEvent.error.errorMessage ?? assistantEvent.reason;
+        });
+        try {
+            await session.prompt(buildEnhancerPrompt(draft), { expandPromptTemplates: false });
+            if (streamError)
+                throw new Error(streamError);
+            const cleaned = cleanupEnhancedPrompt(output);
+            if (cleaned.length === 0)
+                throw new Error("model returned an empty prompt");
+            return cleaned;
+        }
+        catch (error) {
+            lastError = error;
+        }
+        finally {
+            unsubscribe();
+            session.dispose();
+        }
     }
+    throw lastError ?? new Error("No prompt enhancer models are configured");
+}
+function modelRefChain(primary, fallbacks) {
+    return [...new Set([primary, ...(fallbacks ?? [])].map((ref) => ref.trim()).filter(Boolean))];
 }
 function buildEnhancerPrompt(draft) {
     return [

package/dist/app/input/voice-controller.d.ts

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
-import { savePixDictationLanguage, type DictationConfig, type DictationLanguageModelConfig } from "../../config.js";
+import { savePixDictationLanguage, type DictationConfig } from "../../config.js";
 export type VoiceLanguage = string;
-export type VoiceInputState = "idle" | "installing" | "downloading" | "loading" | "listening";
+export type VoiceInputState = "idle" | "connecting" | "listening";
 export type AppVoiceControllerHost = {
     activeInputScope(): string | undefined;
     insertTranscript(text: string): void;
@@ -10,58 +10,48 @@ export type AppVoiceControllerHost = {
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     render(): void;
 };
-type VoskRecognitionResult = string | {
-    text?: unknown;
-    partial?: unknown;
-};
-type VoskModel = {
-    free?: () => void;
-};
-type VoskRecognizer = {
-    acceptWaveform(buffer: Buffer): boolean;
-    partialResult?: () => VoskRecognitionResult;
-    result(): VoskRecognitionResult;
-    finalResult(): VoskRecognitionResult;
-    free?: () => void;
-};
-type VoskModule = {
-    Model: new (modelPath: string) => VoskModel;
-    Recognizer: new (options: {
-        model: VoskModel;
-        sampleRate: number;
-    }) => VoskRecognizer;
-    setLogLevel?: (level: number) => void;
-};
-type VoskLoadAttempt = {
-    ok: true;
-    module: VoskModule;
-} | {
-    ok: false;
-    error: unknown;
-};
-type VoiceModelDefinition = DictationLanguageModelConfig;
 type RecorderCommand = {
     command: string;
     args: string[];
     description: string;
 };
+type DeepgramSocketEvent = {
+    data?: unknown;
+    code?: number;
+    reason?: string;
+};
+type DeepgramSocketListener = (event: DeepgramSocketEvent) => void;
+type DeepgramSocket = {
+    readyState: number;
+    send(data: unknown): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: string, listener: DeepgramSocketListener): void;
+    removeEventListener(type: string, listener: DeepgramSocketListener): void;
+};
+export type DeepgramTranscript = {
+    text: string;
+    isFinal: boolean;
+};
 type VoiceControllerTestDeps = {
-    tryLoadVosk: typeof tryLoadVosk;
-    ensureModel: typeof ensureModel;
+    deepgramApiKey: () => string | undefined;
+    createDeepgramSocket: typeof createDeepgramSocket;
+    waitForSocketOpen: typeof waitForSocketOpen;
     selectRecorderCommand: typeof selectRecorderCommand;
     spawn: typeof spawn;
     savePixDictationLanguage: typeof savePixDictationLanguage;
+    delay: typeof delay;
 };
 export declare function setVoiceControllerTestDeps(overrides?: Partial<VoiceControllerTestDeps>): void;
 export declare class AppVoiceController {
     private readonly host;
-    private modelDefinitions;
+    private languageDefinitions;
     private languages;
     private language;
+    private deepgramModel;
+    private deepgramApiKey;
     private state;
-    private readonly modelCache;
     private audioProcess;
-    private recognizer;
+    private socket;
     private progressMessage;
     private progressFrame;
     private progressTimer;
@@ -70,6 +60,8 @@ export declare class AppVoiceController {
     private partialTranscriptTimer;
     private startGeneration;
     private recordingScope;
+    private stopPromise;
+    private disposed;
     constructor(host: AppVoiceControllerHost, dictationConfig: DictationConfig);
     updateDictationConfig(dictationConfig: DictationConfig): void;
     statusWidgetText(): string;
@@ -81,27 +73,31 @@ export declare class AppVoiceController {
     stopRecording(): Promise<void>;
     dispose(): Promise<void>;
     private startRecording;
-    private cachedModel;
+    private stopRecordingNow;
+    private bindSocket;
+    private bindAudioProcess;
     private nextLanguage;
     private initialLanguage;
     private saveLanguageSelection;
-    private modelDefinition;
-    private installAndLoadVosk;
-    private bindAudioProcess;
-    private cleanupRecognizer;
+    private languageDefinition;
+    private deepgramLanguage;
     private setProgressMessage;
     private clearProgressMessage;
     private addProgressSystemMessage;
-    private emitTranscript;
     private emitPartialTranscript;
     private clearPartialTranscript;
+    private commitPartialTranscript;
     private schedulePartialTranscriptEmit;
     private isCurrentStart;
     private continueStart;
+    private isCurrentSocket;
     private isCurrentAudioProcess;
     private isScopeActive;
 }
-declare function ensureModel(language: VoiceLanguage, definition: VoiceModelDefinition): Promise<string>;
-declare function tryLoadVosk(): VoskLoadAttempt;
+export declare function buildDeepgramUrl(model: string, language: string, rawLinear16: boolean): string;
+export declare function parseDeepgramTranscript(data: unknown): DeepgramTranscript | undefined;
 declare function selectRecorderCommand(): Promise<RecorderCommand>;
+declare function createDeepgramSocket(url: string, protocols: string[]): DeepgramSocket;
+declare function waitForSocketOpen(socket: DeepgramSocket): Promise<void>;
+declare function delay(ms: number): Promise<void>;
 export {};