@ottocode/web-sdk 0.1.288 → 0.1.290

package/dist/hooks/index.js

@@ -21,20 +21,83 @@ import {
 import { client } from "@ottocode/api";
 
 // src/lib/config.ts
-function computeApiBaseUrl() {
-  const envUrl = import.meta.env?.VITE_API_BASE_URL;
-  if (envUrl) {
-    return envUrl;
+var RUNTIME_API_BASE_URL_STORAGE_KEY = "otto-api-base-url";
+function normalizeApiBaseUrl(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error("Enter an otto tunnel URL.");
+  }
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    throw new Error("Enter a valid URL, including http:// or https://.");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Tunnel URL must start with http:// or https://.");
+  }
+  url.hash = "";
+  url.pathname = url.pathname.replace(/\/+$/, "") || "";
+  return url.toString().replace(/\/+$/, "");
+}
+function getStoredApiBaseUrl() {
+  if (typeof window === "undefined")
+    return;
+  try {
+    return window.localStorage.getItem(RUNTIME_API_BASE_URL_STORAGE_KEY) ?? undefined;
+  } catch {
+    return;
   }
+}
+function getConfiguredRuntimeApiBaseUrl() {
+  if (typeof window === "undefined")
+    return;
+  const params = new URLSearchParams(window.location.search);
+  const urlParam = params.get("url");
+  if (urlParam)
+    return normalizeApiBaseUrl(urlParam);
+  const win = window;
+  if (win.OTTO_SERVER_URL)
+    return normalizeApiBaseUrl(win.OTTO_SERVER_URL);
+  if (win.__OTTO_API_URL__)
+    return normalizeApiBaseUrl(win.__OTTO_API_URL__);
+  const storedUrl = getStoredApiBaseUrl();
+  if (storedUrl)
+    return normalizeApiBaseUrl(storedUrl);
+  return;
+}
+function hasConfiguredRuntimeApiBaseUrl() {
+  return Boolean(getConfiguredRuntimeApiBaseUrl());
+}
+function setRuntimeApiBaseUrl(value) {
+  const baseUrl = normalizeApiBaseUrl(value);
   if (typeof window !== "undefined") {
     const win = window;
-    if (win.OTTO_SERVER_URL) {
-      return win.OTTO_SERVER_URL;
-    }
-    if (win.__OTTO_API_URL__) {
-      return win.__OTTO_API_URL__;
-    }
+    win.OTTO_SERVER_URL = baseUrl;
+    try {
+      window.localStorage.setItem(RUNTIME_API_BASE_URL_STORAGE_KEY, baseUrl);
+    } catch {}
   }
+  return baseUrl;
+}
+function clearRuntimeApiBaseUrl() {
+  if (typeof window === "undefined")
+    return;
+  const win = window;
+  delete win.OTTO_SERVER_URL;
+  delete win.__OTTO_API_URL__;
+  try {
+    window.localStorage.removeItem(RUNTIME_API_BASE_URL_STORAGE_KEY);
+  } catch {}
+}
+function computeApiBaseUrl() {
+  const runtimeUrl = getConfiguredRuntimeApiBaseUrl();
+  if (runtimeUrl) {
+    return runtimeUrl;
+  }
+  const envUrl = import.meta.env?.VITE_API_BASE_URL;
+  if (envUrl)
+    return normalizeApiBaseUrl(envUrl);
   return "http://localhost:9100";
 }
 function getRuntimeApiBaseUrl() {
@@ -77,8 +140,7 @@ function extractErrorMessage(error) {
   return "Unknown error";
 }
 function configureApiClient() {
-  const win = window;
-  const baseURL = win.OTTO_SERVER_URL || API_BASE_URL;
+  const baseURL = getRuntimeApiBaseUrl();
   client.setConfig({
     baseURL,
     adapter: getClientAdapter()
@@ -86,10 +148,7 @@ function configureApiClient() {
 }
 configureApiClient();
 function getBaseUrl() {
-  const win = window;
-  if (win.OTTO_SERVER_URL)
-    return win.OTTO_SERVER_URL;
-  return API_BASE_URL;
+  return getRuntimeApiBaseUrl();
 }
 function convertSession(apiSession) {
   return {
@@ -611,9 +670,9 @@ var approvalMixin = {
 
 // src/lib/api-client/ottorouter.ts
 import {
-  getOttoRouterBalance as apiGetSetuBalance,
-  getOttoRouterWallet as apiGetSetuWallet,
-  getOttoRouterUsdcBalance as apiGetSetuUsdcBalance,
+  getOttoRouterBalance as apiGetOttoRouterBalance,
+  getOttoRouterWallet as apiGetOttoRouterWallet,
+  getOttoRouterUsdcBalance as apiGetOttoRouterUsdcBalance,
   createPolarCheckout as apiCreatePolarCheckout,
   getPolarTopupEstimate as apiGetPolarTopupEstimate,
   getPolarTopupStatus as apiGetPolarTopupStatus,
@@ -627,7 +686,7 @@ import {
 var ottorouterMixin = {
   async getOttoRouterBalance() {
     try {
-      const response = await apiGetSetuBalance();
+      const response = await apiGetOttoRouterBalance();
       if (response.error)
         return null;
       return response.data;
@@ -637,7 +696,7 @@ var ottorouterMixin = {
   },
   async getOttoRouterWallet() {
     try {
-      const response = await apiGetSetuWallet();
+      const response = await apiGetOttoRouterWallet();
       if (response.error)
         return { configured: false };
       return response.data;
@@ -647,7 +706,7 @@ var ottorouterMixin = {
   },
   async getOttoRouterUsdcBalance(network = "mainnet") {
     try {
-      const response = await apiGetSetuUsdcBalance({
+      const response = await apiGetOttoRouterUsdcBalance({
         query: { network }
       });
       if (response.error)
@@ -750,14 +809,16 @@ var ottorouterMixin = {
 // src/lib/api-client/auth.ts
 import {
   getAuthStatus as apiGetAuthStatus,
-  setupOttoRouterWallet as apiSetupSetuWallet,
-  importOttoRouterWallet as apiImportSetuWallet,
-  exportOttoRouterWallet as apiExportSetuWallet,
+  setupOttoRouterWallet as apiSetupOttoRouterWallet,
+  importOttoRouterWallet as apiImportOttoRouterWallet,
+  exportOttoRouterWallet as apiExportOttoRouterWallet,
   addProviderApiKey as apiAddProviderApiKey,
   removeProvider as apiRemoveProvider,
   completeOnboarding as apiCompleteOnboarding,
   getOAuthUrl as apiGetOAuthUrl,
   exchangeOAuthCode as apiExchangeOAuthCode,
+  startOpenAiDeviceFlow as apiStartOpenAiDeviceFlow,
+  pollOpenAiDeviceFlow as apiPollOpenAiDeviceFlow,
   startCopilotDeviceFlow as apiStartCopilotDeviceFlow,
   pollCopilotDeviceFlow as apiPollCopilotDeviceFlow,
   getCopilotAuthMethods as apiGetCopilotAuthMethods,
@@ -774,13 +835,13 @@ var authMixin = {
     return response.data;
   },
   async setupOttoRouterWallet() {
-    const response = await apiSetupSetuWallet();
+    const response = await apiSetupOttoRouterWallet();
     if (response.error)
       throw new Error(extractErrorMessage(response.error));
     return response.data;
   },
   async importOttoRouterWallet(privateKey) {
-    const response = await apiImportSetuWallet({
+    const response = await apiImportOttoRouterWallet({
       body: { privateKey }
     });
     if (response.error)
@@ -788,7 +849,7 @@ var authMixin = {
     return response.data;
   },
   async exportOttoRouterWallet() {
-    const response = await apiExportSetuWallet();
+    const response = await apiExportOttoRouterWallet();
     if (response.error)
       throw new Error(extractErrorMessage(response.error));
     return response.data;
@@ -838,6 +899,20 @@ var authMixin = {
       throw new Error(extractErrorMessage(response.error));
     return response.data;
   },
+  async startOpenAIDeviceFlow() {
+    const response = await apiStartOpenAiDeviceFlow();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async pollOpenAIDeviceFlow(sessionId) {
+    const response = await apiPollOpenAiDeviceFlow({
+      body: { sessionId }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
   async startCopilotDeviceFlow() {
     const response = await apiStartCopilotDeviceFlow();
     if (response.error)
@@ -960,6 +1035,74 @@ var usageMixin = {
   }
 };
 
+// src/lib/api-client/dictation.ts
+import {
+  getDictationStatus as apiGetDictationStatus,
+  installDictationModel as apiInstallDictationModel,
+  listDictationModels as apiListDictationModels,
+  removeDictationModel as apiRemoveDictationModel,
+  createDictationSession as apiCreateDictationSession
+} from "@ottocode/api";
+function coerceModelState(value) {
+  return value;
+}
+function coerceModels(value) {
+  return Array.isArray(value) ? value.map(coerceModelState) : [];
+}
+function buildInstallEventsUrl(model) {
+  const baseUrl = getBaseUrl().replace(/\/+$/, "");
+  return `${baseUrl}/v1/dictation/models/${encodeURIComponent(model)}/install/events`;
+}
+var dictationMixin = {
+  async getDictationStatus() {
+    const response = await apiGetDictationStatus();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    const data = response.data;
+    return {
+      ...data,
+      models: coerceModels(data.models)
+    };
+  },
+  async listDictationModels() {
+    const response = await apiListDictationModels();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    const data = response.data;
+    return { models: coerceModels(data.models) };
+  },
+  async installDictationModel({
+    model,
+    force
+  }) {
+    const response = await apiInstallDictationModel({
+      path: { model },
+      body: { force }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    const data = response.data;
+    return { model: coerceModelState(data.model) };
+  },
+  async removeDictationModel(model) {
+    const response = await apiRemoveDictationModel({ path: { model } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    const data = response.data;
+    return {
+      removed: data.removed,
+      model: coerceModelState(data.model)
+    };
+  },
+  async createDictationSession(input = {}) {
+    const response = await apiCreateDictationSession({ body: input });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  getDictationModelInstallEventsUrl: buildInstallEventsUrl
+};
+
 // src/lib/api-client/index.ts
 class ApiClient {
   getSessions = sessionsMixin.getSessions;
@@ -1040,6 +1183,8 @@ class ApiClient {
   getOAuthStartUrl = authMixin.getOAuthStartUrl;
   getOAuthUrl = authMixin.getOAuthUrl;
   exchangeOAuthCode = authMixin.exchangeOAuthCode;
+  startOpenAIDeviceFlow = authMixin.startOpenAIDeviceFlow;
+  pollOpenAIDeviceFlow = authMixin.pollOpenAIDeviceFlow;
   startCopilotDeviceFlow = authMixin.startCopilotDeviceFlow;
   pollCopilotDeviceFlow = authMixin.pollCopilotDeviceFlow;
   getCopilotAuthMethods = authMixin.getCopilotAuthMethods;
@@ -1055,6 +1200,12 @@ class ApiClient {
   updateSkillsConfig = skillsMixin.updateSkillsConfig;
   getUsageStats = usageMixin.getUsageStats;
   getGlobalUsageStats = usageMixin.getGlobalUsageStats;
+  getDictationStatus = dictationMixin.getDictationStatus;
+  listDictationModels = dictationMixin.listDictationModels;
+  installDictationModel = dictationMixin.installDictationModel;
+  removeDictationModel = dictationMixin.removeDictationModel;
+  createDictationSession = dictationMixin.createDictationSession;
+  getDictationModelInstallEventsUrl = dictationMixin.getDictationModelInstallEventsUrl;
 }
 var apiClient = new ApiClient;
 
@@ -1109,7 +1260,7 @@ function useUpdateDefaults() {
   });
 }
 // src/hooks/usePreferences.ts
-import { useCallback, useMemo, useSyncExternalStore } from "react";
+import { useCallback, useEffect, useMemo } from "react";
 
 // src/lib/platform.ts
 function getPlatformWindow() {
@@ -1174,13 +1325,14 @@ function isPlatformDesktop() {
 }
 
 // src/hooks/usePreferences.ts
-var STORAGE_KEY = "otto-preferences";
 var DEFAULT_FONT_FAMILY = "IBM Plex Mono";
-var DEFAULT_STORED_PREFERENCES = {
+var DEFAULT_PREFERENCES = {
   vimMode: false,
   compactThread: true,
   fontFamily: DEFAULT_FONT_FAMILY,
-  smartEdges: true
+  smartEdges: true,
+  releaseToSend: false,
+  fullWidthContent: false
 };
 function cssFontFamily(fontFamily) {
   const trimmed = fontFamily.trim();
@@ -1202,90 +1354,52 @@ function applyFontFamily(fontFamily) {
     window.parent.postMessage({ type: "otto-font-family-changed", fontFamily }, "*");
   }
 }
-function resolveInitialPreferences() {
-  if (typeof window === "undefined") {
-    return DEFAULT_STORED_PREFERENCES;
-  }
-  try {
-    const stored = window.localStorage.getItem(STORAGE_KEY);
-    if (stored) {
-      const parsed = JSON.parse(stored);
-      return {
-        vimMode: typeof parsed.vimMode === "boolean" ? parsed.vimMode : DEFAULT_STORED_PREFERENCES.vimMode,
-        compactThread: typeof parsed.compactThread === "boolean" ? parsed.compactThread : DEFAULT_STORED_PREFERENCES.compactThread,
-        fontFamily: typeof parsed.fontFamily === "string" && parsed.fontFamily.trim() ? parsed.fontFamily.trim() : DEFAULT_STORED_PREFERENCES.fontFamily,
-        smartEdges: typeof parsed.smartEdges === "boolean" ? parsed.smartEdges : DEFAULT_STORED_PREFERENCES.smartEdges
-      };
-    }
-  } catch (error) {
-    console.warn("Failed to load preferences", error);
-  }
-  return DEFAULT_STORED_PREFERENCES;
-}
-var preferences = resolveInitialPreferences();
-applyFontFamily(preferences.fontFamily);
-var listeners = new Set;
-function getSnapshot() {
-  return preferences;
-}
-function getServerSnapshot() {
-  return DEFAULT_STORED_PREFERENCES;
-}
-function subscribe(listener) {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
-}
-function notifyListeners() {
-  for (const listener of listeners) {
-    listener();
-  }
-}
-function updateStore(updates) {
-  preferences = { ...preferences, ...updates };
-  if (updates.fontFamily !== undefined) {
-    applyFontFamily(preferences.fontFamily);
-  }
-  if (typeof window !== "undefined") {
-    try {
-      window.localStorage.setItem(STORAGE_KEY, JSON.stringify(preferences));
-    } catch (error) {
-      console.warn("Failed to persist preferences", error);
-    }
-  }
-  notifyListeners();
-}
 function usePreferences() {
-  const currentPreferences = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
   const { data: config2 } = useConfig();
   const updateDefaults = useUpdateDefaults();
+  const resolvedPreferences = useMemo(() => ({
+    vimMode: config2?.defaults?.vimMode ?? DEFAULT_PREFERENCES.vimMode,
+    compactThread: config2?.defaults?.compactThread ?? DEFAULT_PREFERENCES.compactThread,
+    fontFamily: config2?.defaults?.fontFamily?.trim() || DEFAULT_PREFERENCES.fontFamily,
+    smartEdges: config2?.defaults?.smartEdges ?? DEFAULT_PREFERENCES.smartEdges,
+    releaseToSend: config2?.defaults?.releaseToSend ?? DEFAULT_PREFERENCES.releaseToSend,
+    fullWidthContent: config2?.defaults?.fullWidthContent ?? DEFAULT_PREFERENCES.fullWidthContent
+  }), [
+    config2?.defaults?.vimMode,
+    config2?.defaults?.compactThread,
+    config2?.defaults?.fontFamily,
+    config2?.defaults?.smartEdges,
+    config2?.defaults?.releaseToSend,
+    config2?.defaults?.fullWidthContent
+  ]);
+  useEffect(() => {
+    applyFontFamily(resolvedPreferences.fontFamily);
+  }, [resolvedPreferences.fontFamily]);
   const updatePreferences = useCallback((updates) => {
-    const localUpdates = {};
+    const nextUpdates = {};
     if (updates.vimMode !== undefined) {
-      localUpdates.vimMode = updates.vimMode;
+      nextUpdates.vimMode = updates.vimMode;
     }
     if (updates.compactThread !== undefined) {
-      localUpdates.compactThread = updates.compactThread;
+      nextUpdates.compactThread = updates.compactThread;
     }
     if (updates.fontFamily !== undefined) {
-      localUpdates.fontFamily = updates.fontFamily.trim() || DEFAULT_FONT_FAMILY;
+      nextUpdates.fontFamily = updates.fontFamily.trim() || DEFAULT_FONT_FAMILY;
     }
     if (updates.smartEdges !== undefined) {
-      localUpdates.smartEdges = updates.smartEdges;
+      nextUpdates.smartEdges = updates.smartEdges;
     }
-    if (Object.keys(localUpdates).length > 0) {
-      updateStore(localUpdates);
+    if (updates.releaseToSend !== undefined) {
+      nextUpdates.releaseToSend = updates.releaseToSend;
     }
-    if (updates.fullWidthContent !== undefined && updates.fullWidthContent !== config2?.defaults?.fullWidthContent) {
-      updateDefaults.mutate({
-        fullWidthContent: updates.fullWidthContent,
-        scope: "global"
-      });
+    if (updates.fullWidthContent !== undefined) {
+      nextUpdates.fullWidthContent = updates.fullWidthContent;
     }
-  }, [config2?.defaults?.fullWidthContent, updateDefaults]);
-  const resolvedPreferences = useMemo(() => ({
-    ...currentPreferences,
-    fullWidthContent: config2?.defaults?.fullWidthContent ?? false
-  }), [currentPreferences, config2?.defaults?.fullWidthContent]);
+    if (Object.keys(nextUpdates).length === 0) {
+      return;
+    }
+    updateDefaults.mutate({ ...nextUpdates, scope: "global" });
+  }, [updateDefaults]);
   return useMemo(() => ({ preferences: resolvedPreferences, updatePreferences }), [resolvedPreferences, updatePreferences]);
 }
 // src/hooks/useFiles.ts
@@ -1770,7 +1884,14 @@ var useSkillsStore = create2((set, get) => ({
   collapseSidebar: () => set({ isExpanded: false }),
   setSkills: (skills) => set({ skills }),
   setSkillsConfig: ({ skills, globalEnabled, totalCount, enabledCount }) => set({ skills, globalEnabled, totalCount, enabledCount }),
-  selectSkill: (name) => set({ selectedSkill: name, isViewerOpen: false, viewingFile: null }),
+  selectSkill: (name) => {
+    if (name) {
+      useViewerTabsStore.getState().openSkillFileTab(name, null);
+      set({ selectedSkill: name, isViewerOpen: true, viewingFile: null });
+      return;
+    }
+    set({ selectedSkill: null, isViewerOpen: false, viewingFile: null });
+  },
   openViewer: (file) => {
     const selectedSkill = get().selectedSkill;
     if (selectedSkill) {
@@ -2562,7 +2683,7 @@ function useSendMessage(sessionId) {
   });
 }
 // src/hooks/useSessionStream.ts
-import { useEffect, useRef } from "react";
+import { useEffect as useEffect2, useRef } from "react";
 import { useQueryClient as useQueryClient5 } from "@tanstack/react-query";
 
 // src/lib/sse-client.ts
@@ -2717,7 +2838,7 @@ function useSessionStream(sessionId, enabled = true) {
     updatePendingApproval,
     setPendingApprovals
   } = useToolApprovalStore();
-  useEffect(() => {
+  useEffect2(() => {
     if (!sessionId || !enabled) {
       return;
     }
@@ -4048,7 +4169,7 @@ ${bestEffortUnescapeJsonString(rawTail)}`;
   ]);
 }
 // src/hooks/useClientEvents.ts
-import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { useEffect as useEffect3, useRef as useRef2 } from "react";
 import { useQueryClient as useQueryClient6 } from "@tanstack/react-query";
 import {
   buildClientEventsStreamUrl,
@@ -4298,10 +4419,10 @@ async function maybeShowLocalAccessToast(baseUrl) {
 function useClientEvents(activeSessionId) {
   const queryClient = useQueryClient6();
   const activeSessionIdRef = useRef2(activeSessionId);
-  useEffect2(() => {
+  useEffect3(() => {
     activeSessionIdRef.current = activeSessionId;
   }, [activeSessionId]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (typeof window === "undefined" || window.parent !== window)
       return;
     if (!("Notification" in window))
@@ -4330,7 +4451,7 @@ function useClientEvents(activeSessionId) {
       }
     });
   }, []);
-  useEffect2(() => {
+  useEffect3(() => {
     const controller = new AbortController;
     const baseUrl = getBaseUrl();
     createClientEventsStream({
@@ -4380,24 +4501,15 @@ function useClientEvents(activeSessionId) {
   return buildClientEventsStreamUrl({ baseUrl: getBaseUrl() });
 }
 // src/hooks/useTheme.ts
-import { useEffect as useEffect3, useState, useCallback as useCallback2, useMemo as useMemo3 } from "react";
-var STORAGE_KEY2 = "otto-theme";
-function resolveInitialTheme() {
-  if (typeof window === "undefined") {
-    return "dark";
-  }
-  const stored = window.localStorage.getItem(STORAGE_KEY2);
-  if (stored === "light" || stored === "dark") {
-    return stored;
-  }
-  if (window.matchMedia?.("(prefers-color-scheme: light)").matches) {
-    return "light";
-  }
-  return "dark";
+import { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo3 } from "react";
+function normalizeTheme(theme) {
+  return theme === "light" ? "light" : "dark";
 }
 function useTheme() {
-  const [theme, setTheme] = useState(() => resolveInitialTheme());
-  useEffect3(() => {
+  const { data: config2 } = useConfig();
+  const updateDefaults = useUpdateDefaults();
+  const theme = normalizeTheme(config2?.defaults?.theme);
+  useEffect4(() => {
     if (typeof document === "undefined")
       return;
     const root = document.documentElement;
@@ -4406,37 +4518,24 @@ function useTheme() {
     } else {
       root.classList.remove("dark");
     }
-    try {
-      window.localStorage.setItem(STORAGE_KEY2, theme);
-    } catch (error) {
-      console.warn("Failed to persist theme preference", error);
-    }
     if (window.parent && window.parent !== window) {
       window.parent.postMessage({ type: "otto-set-theme", theme }, "*");
     }
   }, [theme]);
-  useEffect3(() => {
-    if (typeof window === "undefined")
-      return;
-    const handler = (e) => {
-      if (e.data?.type === "otto-set-theme" && (e.data.theme === "light" || e.data.theme === "dark")) {
-        setTheme(e.data.theme);
-      }
-    };
-    window.addEventListener("message", handler);
-    return () => window.removeEventListener("message", handler);
-  }, []);
+  const setTheme = useCallback2((nextTheme) => {
+    updateDefaults.mutate({ theme: nextTheme, scope: "global" });
+  }, [updateDefaults]);
   const toggleTheme = useCallback2(() => {
-    setTheme((prev) => prev === "dark" ? "light" : "dark");
-  }, []);
-  return useMemo3(() => ({ theme, setTheme, toggleTheme }), [theme, toggleTheme]);
+    setTheme(theme === "dark" ? "light" : "dark");
+  }, [setTheme, theme]);
+  return useMemo3(() => ({ theme, setTheme, toggleTheme }), [theme, setTheme, toggleTheme]);
 }
 // src/hooks/useWorkingDirectory.ts
-import { useEffect as useEffect4, useState as useState2 } from "react";
+import { useEffect as useEffect5, useState } from "react";
 import { getCwd } from "@ottocode/api";
 function useWorkingDirectory() {
-  const [dirName, setDirName] = useState2(null);
-  useEffect4(() => {
+  const [dirName, setDirName] = useState(null);
+  useEffect5(() => {
     const fetchWorkingDirectory = async () => {
       try {
         const response = await getCwd({ baseURL: getBaseUrl() });
@@ -4460,7 +4559,7 @@ function useWorkingDirectory() {
   return dirName;
 }
 // src/hooks/useKeyboardShortcuts.ts
-import { useEffect as useEffect5, useCallback as useCallback3 } from "react";
+import { useEffect as useEffect6, useCallback as useCallback3 } from "react";
 
 // src/stores/focusStore.ts
 import { create as create12 } from "zustand";
@@ -4821,7 +4920,7 @@ function useKeyboardShortcuts({
     onReturnToInput,
     closeDiff
   ]);
-  useEffect5(() => {
+  useEffect6(() => {
     window.addEventListener("keydown", handleKeyDown, true);
     return () => window.removeEventListener("keydown", handleKeyDown, true);
   }, [handleKeyDown]);
@@ -4833,9 +4932,9 @@ function useKeyboardShortcuts({
 }
 // src/hooks/useImageUpload.ts
 import {
-  useState as useState3,
+  useState as useState2,
   useCallback as useCallback4,
-  useEffect as useEffect6
+  useEffect as useEffect7
 } from "react";
 var SUPPORTED_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
 function generateId() {
@@ -4863,9 +4962,9 @@ async function fileToPreview(file) {
 }
 function useImageUpload(options = {}) {
   const { maxImages = 5, maxSizeMB = 5, pageWide = true } = options;
-  const [images, setImages] = useState3([]);
-  const [isDragging, setIsDragging] = useState3(false);
-  const [error, setError] = useState3(null);
+  const [images, setImages] = useState2([]);
+  const [isDragging, setIsDragging] = useState2(false);
+  const [error, setError] = useState2(null);
   const maxSizeBytes = maxSizeMB * 1024 * 1024;
   const validateFile = useCallback4((file) => {
     if (!SUPPORTED_TYPES.includes(file.type)) {
@@ -4971,7 +5070,7 @@ function useImageUpload(options = {}) {
       addImages(imageFiles);
     }
   }, [addImages]);
-  useEffect6(() => {
+  useEffect7(() => {
     if (!pageWide)
       return;
     let dragCounter = 0;
@@ -5033,9 +5132,9 @@ function useImageUpload(options = {}) {
 }
 // src/hooks/useFileUpload.ts
 import {
-  useState as useState4,
+  useState as useState3,
   useCallback as useCallback5,
-  useEffect as useEffect7
+  useEffect as useEffect8
 } from "react";
 var IMAGE_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
 var PDF_TYPES = ["application/pdf"];
@@ -5165,9 +5264,9 @@ function useFileUpload(options = {}) {
     sessionId,
     onError
   } = options;
-  const [files, setFiles] = useState4([]);
-  const [isDragging, setIsDragging] = useState4(false);
-  const [error, setError] = useState4(null);
+  const [files, setFiles] = useState3([]);
+  const [isDragging, setIsDragging] = useState3(false);
+  const [error, setError] = useState3(null);
   const maxSizeBytes = maxSizeMB * 1024 * 1024;
   const validateFile = useCallback5((file) => {
     if (file.size > maxSizeBytes) {
@@ -5326,7 +5425,7 @@ function useFileUpload(options = {}) {
       addFiles(pastedFiles);
     }
   }, [addFiles]);
-  useEffect7(() => {
+  useEffect8(() => {
     if (!pageWide)
       return;
     let dragCounter = 0;
@@ -5599,8 +5698,8 @@ function useExportToSession() {
     }
   });
 }
-// src/hooks/useSetuPayments.ts
-import { useEffect as useEffect8, useRef as useRef3 } from "react";
+// src/hooks/useOttoRouterPayments.ts
+import { useEffect as useEffect9, useRef as useRef3 } from "react";
 
 // src/stores/ottorouterStore.ts
 import { create as create17 } from "zustand";
@@ -5644,8 +5743,8 @@ var useTopupApprovalStore = create18((set) => ({
   clearPendingTopup: () => set({ pendingTopup: null, isProcessing: false, selectedMethod: null })
 }));
 
-// src/hooks/useSetuPayments.ts
-function useSetuPayments(sessionId) {
+// src/hooks/useOttoRouterPayments.ts
+function useOttoRouterPayments(sessionId) {
   const clientRef = useRef3(null);
   const loadingToastIdRef = useRef3(null);
   const setBalance = useOttoRouterStore((s) => s.setBalance);
@@ -5654,7 +5753,7 @@ function useSetuPayments(sessionId) {
   const updateToast = useToastStore((s) => s.updateToast);
   const setPendingTopup = useTopupApprovalStore((s) => s.setPendingTopup);
   const clearPendingTopup = useTopupApprovalStore((s) => s.clearPendingTopup);
-  useEffect8(() => {
+  useEffect9(() => {
     if (!sessionId)
       return;
     const client2 = new SSEClient;
@@ -5784,7 +5883,7 @@ function useSetuPayments(sessionId) {
   ]);
 }
 // src/hooks/useOttoRouterBalance.ts
-import { useEffect as useEffect9, useCallback as useCallback6 } from "react";
+import { useEffect as useEffect10, useCallback as useCallback6 } from "react";
 
 // src/stores/usageStore.ts
 import { create as create19 } from "zustand";
@@ -5822,19 +5921,19 @@ function useOttoRouterBalance(providerName) {
     }
     setLoading(true);
     try {
-      const [setuData, usdcData, walletData] = await Promise.all([
+      const [ottorouterData, usdcData, walletData] = await Promise.all([
         apiClient.getOttoRouterBalance(),
         apiClient.getOttoRouterUsdcBalance(network),
         apiClient.getOttoRouterWallet()
       ]);
-      if (setuData) {
-        setBalance(setuData.balance);
-        setWalletAddress(setuData.walletAddress);
-        setScope(setuData.scope ?? null);
-        setPayg(setuData.payg ?? null);
-        setSubscription(setuData.subscription ?? null);
-        setLimits(setuData.limits ?? null);
-        const sub = setuData.subscription;
+      if (ottorouterData) {
+        setBalance(ottorouterData.balance);
+        setWalletAddress(ottorouterData.walletAddress);
+        setScope(ottorouterData.scope ?? null);
+        setPayg(ottorouterData.payg ?? null);
+        setSubscription(ottorouterData.subscription ?? null);
+        setLimits(ottorouterData.limits ?? null);
+        const sub = ottorouterData.subscription;
         if (sub?.active && sub.usageWindows) {
           setUsage("ottorouter", {
             provider: "ottorouter",
@@ -5857,7 +5956,7 @@ function useOttoRouterBalance(providerName) {
       }
       if (usdcData) {
         setUsdcBalance(usdcData.usdcBalance);
-        if (!setuData && usdcData.walletAddress) {
+        if (!ottorouterData && usdcData.walletAddress) {
           setWalletAddress(usdcData.walletAddress);
         }
       }
@@ -5878,7 +5977,7 @@ function useOttoRouterBalance(providerName) {
     setUsage
   ]);
   const needsUsageWindows = subscription?.active && !subscription.usageWindows;
-  useEffect9(() => {
+  useEffect10(() => {
     if (providerName === "ottorouter" && (balance === null || usdcBalance === null || needsUsageWindows)) {
       fetchBalance();
     }
@@ -5899,7 +5998,7 @@ function useShareStatus(sessionId) {
   return { data, isLoading, error };
 }
 // src/hooks/useToolApprovalShortcuts.ts
-import { useEffect as useEffect10, useCallback as useCallback7 } from "react";
+import { useEffect as useEffect11, useCallback as useCallback7 } from "react";
 function useToolApprovalShortcuts(sessionId) {
   const { pendingApprovals, removePendingApproval } = useToolApprovalStore();
   const sessionPendingApprovals = pendingApprovals;
@@ -5935,7 +6034,7 @@ function useToolApprovalShortcuts(sessionId) {
       console.error("Failed to approve all tool calls:", error);
     }
   }, [sessionId, sessionPendingApprovals, removePendingApproval]);
-  useEffect10(() => {
+  useEffect11(() => {
     if (!sessionId || sessionPendingApprovals.length === 0)
       return;
     const handleKeyDown = (e) => {
@@ -5965,19 +6064,19 @@ function useToolApprovalShortcuts(sessionId) {
   ]);
 }
 // src/hooks/useTopupCallback.ts
-import { useEffect as useEffect11, useRef as useRef4 } from "react";
-var STORAGE_KEY3 = "pendingPolarCheckout";
+import { useEffect as useEffect12, useRef as useRef4 } from "react";
+var STORAGE_KEY = "pendingPolarCheckout";
 function useTopupCallback() {
   const hasHandled = useRef4(false);
   const loadingToastId = useRef4(null);
   const setBalance = useOttoRouterStore((s) => s.setBalance);
   const removeToast = useToastStore((s) => s.removeToast);
-  useEffect11(() => {
+  useEffect12(() => {
     if (hasHandled.current)
       return;
     const params = new URLSearchParams(window.location.search);
     const topupStatus = params.get("topup");
-    const pendingCheckoutId = localStorage.getItem(STORAGE_KEY3);
+    const pendingCheckoutId = localStorage.getItem(STORAGE_KEY);
     if (topupStatus === "pending" || pendingCheckoutId) {
       hasHandled.current = true;
       const url = new URL(window.location.href);
@@ -6002,7 +6101,7 @@ function useTopupCallback() {
         try {
           const status = await apiClient.getPolarTopupStatus(pendingCheckoutId);
           if (status?.confirmed) {
-            localStorage.removeItem(STORAGE_KEY3);
+            localStorage.removeItem(STORAGE_KEY);
             dismissLoading();
             const balanceData = await apiClient.getOttoRouterBalance();
             if (balanceData?.balance !== undefined) {
@@ -6014,7 +6113,7 @@ function useTopupCallback() {
           if (attempts < maxAttempts) {
             setTimeout(checkStatus, delayMs);
           } else {
-            localStorage.removeItem(STORAGE_KEY3);
+            localStorage.removeItem(STORAGE_KEY);
             dismissLoading();
             toast.info("Top-up is still processing. Balance will update automatically.");
           }
@@ -6022,7 +6121,7 @@ function useTopupCallback() {
           if (attempts < maxAttempts) {
             setTimeout(checkStatus, delayMs);
           } else {
-            localStorage.removeItem(STORAGE_KEY3);
+            localStorage.removeItem(STORAGE_KEY);
             dismissLoading();
             toast.error("Could not verify top-up. Please check your balance.");
           }
@@ -6033,7 +6132,7 @@ function useTopupCallback() {
   }, [setBalance, removeToast]);
 }
 // src/hooks/useAuthStatus.ts
-import { useEffect as useEffect12, useCallback as useCallback8, useState as useState5, useRef as useRef5 } from "react";
+import { useEffect as useEffect13, useCallback as useCallback8, useState as useState4, useRef as useRef5 } from "react";
 import { useQueryClient as useQueryClient9 } from "@tanstack/react-query";
 
 // src/stores/onboardingStore.ts
@@ -6085,8 +6184,8 @@ function useAuthStatus() {
   const authStatus = useOnboardingStore((s) => s.authStatus);
   const isOpen = useOnboardingStore((s) => s.isOpen);
   const queryClient = useQueryClient9();
-  const [initialized, setInitialized] = useState5(false);
-  const [oauthPolling, setOauthPolling] = useState5(false);
+  const [initialized, setInitialized] = useState4(false);
+  const [oauthPolling, setOauthPolling] = useState4(false);
   const oauthPollingRef = useRef5(null);
   const preOauthProvidersRef = useRef5(new Set);
   const fetchAuthStatus = useCallback8(async () => {
@@ -6278,7 +6377,7 @@ function useAuthStatus() {
       setLoading(false);
     }
   }, [fetchAuthStatus, setLoading, setError]);
-  useEffect12(() => {
+  useEffect13(() => {
     if (!oauthPolling || !isInIframe)
       return;
     oauthPollingRef.current = setInterval(() => {
@@ -6292,7 +6391,7 @@ function useAuthStatus() {
       clearTimeout(timeout);
     };
   }, [oauthPolling, fetchAuthStatus]);
-  useEffect12(() => {
+  useEffect13(() => {
     if (!oauthPolling || !authStatus)
       return;
     const currentConfigured = Object.entries(authStatus.providers).filter(([, p]) => p.configured);
@@ -6301,7 +6400,7 @@ function useAuthStatus() {
       setOauthPolling(false);
     }
   }, [authStatus, oauthPolling]);
-  useEffect12(() => {
+  useEffect13(() => {
     const handleOAuthMessage = (event) => {
       if (event.data?.type === "oauth-success") {
         fetchAuthStatus();
@@ -6317,6 +6416,13 @@ function useAuthStatus() {
     }
     return result;
   }, [fetchAuthStatus]);
+  const pollOpenAIDeviceFlow = useCallback8(async (sessionId) => {
+    const result = await apiClient.pollOpenAIDeviceFlow(sessionId);
+    if (result.status === "complete") {
+      await fetchAuthStatus();
+    }
+    return result;
+  }, [fetchAuthStatus]);
   const saveCopilotToken = useCallback8(async (token) => {
     setLoading(true);
     setError(null);
@@ -6362,6 +6468,8 @@ function useAuthStatus() {
     startOAuth,
     startOAuthManual,
     exchangeOAuthCode,
+    startOpenAIDeviceFlow: apiClient.startOpenAIDeviceFlow.bind(apiClient),
+    pollOpenAIDeviceFlow,
     startCopilotDeviceFlow: apiClient.startCopilotDeviceFlow.bind(apiClient),
     pollCopilotDeviceFlow,
     getCopilotAuthMethods: apiClient.getCopilotAuthMethods.bind(apiClient),
@@ -6372,7 +6480,7 @@ function useAuthStatus() {
 }
 // src/hooks/useTunnel.ts
 import { useQuery as useQuery10, useMutation as useMutation7, useQueryClient as useQueryClient10 } from "@tanstack/react-query";
-import { useEffect as useEffect13, useCallback as useCallback9, useRef as useRef6 } from "react";
+import { useEffect as useEffect14, useCallback as useCallback9, useRef as useRef6 } from "react";
 import {
   client as client2,
   getTunnelQr,
@@ -6415,7 +6523,7 @@ function useTunnelStatus() {
     queryFn: fetchTunnelStatus,
     refetchInterval: 3000
   });
-  useEffect13(() => {
+  useEffect14(() => {
     if (query.data) {
       setStatus(query.data.status);
       setUrl(query.data.url);
@@ -6475,7 +6583,7 @@ function useTunnelQr() {
     queryFn: fetchTunnelQr,
     enabled: !!url
   });
-  useEffect13(() => {
+  useEffect14(() => {
     if (query.data?.ok && query.data.qrCode) {
       setQrCode(query.data.qrCode);
     }
@@ -6515,7 +6623,7 @@ function useTunnelStream() {
       eventSourceRef.current = null;
     };
   }, [setStatus, setUrl, setError, setProgress]);
-  useEffect13(() => {
+  useEffect14(() => {
     if (isExpanded) {
       const cleanup = connect();
       return cleanup;
@@ -6530,7 +6638,7 @@ function useTunnelStream() {
   return { connect };
 }
 // src/hooks/useProviderUsage.ts
-import { useEffect as useEffect14, useCallback as useCallback10, useRef as useRef7 } from "react";
+import { useEffect as useEffect15, useCallback as useCallback10, useRef as useRef7 } from "react";
 var POLL_INTERVAL = 60000;
 var STALE_THRESHOLD = 60000;
 var inflight = new Set;
@@ -6563,12 +6671,12 @@ function useProviderUsage(provider, authType) {
   }, [provider, isOAuthProvider, setUsage, setLoading, setLastFetched]);
   const fetchRef = useRef7(fetchUsage);
   fetchRef.current = fetchUsage;
-  useEffect14(() => {
+  useEffect15(() => {
     if (!provider || !isOAuthProvider)
       return;
     fetchRef.current();
   }, [isOAuthProvider, provider]);
-  useEffect14(() => {
+  useEffect15(() => {
     if (!provider || !isOAuthProvider || !isModalOpen || modalProvider !== provider) {
       return;
     }
@@ -6613,7 +6721,7 @@ function useGitDiffFullFile(file, staged = false, enabled = false) {
 }
 // src/hooks/useMCP.ts
 import { useQuery as useQuery12, useMutation as useMutation8, useQueryClient as useQueryClient11 } from "@tanstack/react-query";
-import { useEffect as useEffect15, useRef as useRef8, useCallback as useCallback11 } from "react";
+import { useEffect as useEffect16, useRef as useRef8, useCallback as useCallback11 } from "react";
 import {
   listMcpServers,
   startMcpServer,
@@ -6635,7 +6743,7 @@ function useMCPServers() {
     },
     refetchInterval: 1e4
   });
-  useEffect15(() => {
+  useEffect16(() => {
     if (query.data?.servers) {
       setServers(query.data.servers);
     }
@@ -6786,7 +6894,7 @@ function useCopilotDevicePoller() {
       timerRef.current = null;
     }
   }, []);
-  useEffect15(() => {
+  useEffect16(() => {
     if (!copilotDevice) {
       stopPolling();
       return;
@@ -6822,7 +6930,7 @@ function useCopilotDevicePoller() {
 }
 // src/hooks/useSkills.ts
 import { useMutation as useMutation9, useQuery as useQuery13, useQueryClient as useQueryClient12 } from "@tanstack/react-query";
-import { useEffect as useEffect16 } from "react";
+import { useEffect as useEffect17 } from "react";
 function useSkills() {
   const setSkillsConfig = useSkillsStore((s) => s.setSkillsConfig);
   const query = useQuery13({
@@ -6832,7 +6940,7 @@ function useSkills() {
     },
     refetchInterval: 30000
   });
-  useEffect16(() => {
+  useEffect17(() => {
     if (query.data?.items) {
       setSkillsConfig({
         skills: query.data.items,
@@ -6894,10 +7002,10 @@ function useSkillFileContent(name, filePath) {
   });
 }
 // src/hooks/useContainerWidth.ts
-import { useEffect as useEffect17, useState as useState6 } from "react";
+import { useEffect as useEffect18, useState as useState5 } from "react";
 function useContainerWidth(ref) {
-  const [width, setWidth] = useState6(0);
-  useEffect17(() => {
+  const [width, setWidth] = useState5(0);
+  useEffect18(() => {
     const el = ref.current;
     if (!el)
       return;
@@ -6909,8 +7017,402 @@ function useContainerWidth(ref) {
   }, [ref]);
   return width;
 }
+// src/hooks/useVoiceInput.ts
+import { useCallback as useCallback12, useEffect as useEffect19, useRef as useRef9, useState as useState6 } from "react";
+var TARGET_SAMPLE_RATE = 16000;
+var PCM_FRAME_BYTES = 3200;
+function getAudioContextConstructor() {
+  if (typeof window === "undefined")
+    return null;
+  return window.AudioContext || window.webkitAudioContext || null;
+}
+function toLanguageCode(lang) {
+  return lang.split("-", 1)[0]?.toLowerCase() || "en";
+}
+function parseServerEvent(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (!value || typeof value.type !== "string")
+      return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function resampleLinear(input, inputSampleRate, outputSampleRate) {
+  if (inputSampleRate === outputSampleRate)
+    return input;
+  const ratio = inputSampleRate / outputSampleRate;
+  const outputLength = Math.max(1, Math.floor(input.length / ratio));
+  const output = new Float32Array(outputLength);
+  for (let i = 0;i < outputLength; i++) {
+    const inputIndex = i * ratio;
+    const before = Math.floor(inputIndex);
+    const after = Math.min(before + 1, input.length - 1);
+    const weight = inputIndex - before;
+    output[i] = input[before] * (1 - weight) + input[after] * weight;
+  }
+  return output;
+}
+function floatToPcm16(samples) {
+  const buffer = new ArrayBuffer(samples.length * 2);
+  const view = new DataView(buffer);
+  for (let i = 0;i < samples.length; i++) {
+    const sample = Math.max(-1, Math.min(1, samples[i]));
+    view.setInt16(i * 2, sample < 0 ? sample * 32768 : sample * 32767, true);
+  }
+  return buffer;
+}
+function appendBuffer(a, b) {
+  const next = new Uint8Array(a.byteLength + b.byteLength);
+  next.set(a, 0);
+  next.set(b, a.byteLength);
+  return next;
+}
+function useVoiceInput({
+  onTranscript,
+  onError,
+  lang = "en-US"
+} = {}) {
+  const [isListening, setIsListening] = useState6(false);
+  const [isTranscribing, setIsTranscribing] = useState6(false);
+  const [analyser, setAnalyser] = useState6(null);
+  const [error, setError] = useState6(null);
+  const streamRef = useRef9(null);
+  const audioContextRef = useRef9(null);
+  const processorRef = useRef9(null);
+  const sourceRef = useRef9(null);
+  const socketRef = useRef9(null);
+  const frameBufferRef = useRef9(new Uint8Array(0));
+  const stoppingRef = useRef9(false);
+  const sessionIdRef = useRef9(null);
+  const onTranscriptRef = useRef9(onTranscript);
+  const onErrorRef = useRef9(onError);
+  useEffect19(() => {
+    onTranscriptRef.current = onTranscript;
+    onErrorRef.current = onError;
+  }, [onTranscript, onError]);
+  const isSupported = typeof window !== "undefined" && !!navigator.mediaDevices?.getUserMedia && !!getAudioContextConstructor() && typeof WebSocket !== "undefined";
+  const emitError = useCallback12((message) => {
+    setError(message);
+    onErrorRef.current?.(message);
+  }, []);
+  const cleanupAudio = useCallback12(() => {
+    if (processorRef.current) {
+      processorRef.current.onaudioprocess = null;
+      processorRef.current.disconnect();
+      processorRef.current = null;
+    }
+    if (sourceRef.current) {
+      sourceRef.current.disconnect();
+      sourceRef.current = null;
+    }
+    if (streamRef.current) {
+      for (const track of streamRef.current.getTracks())
+        track.stop();
+      streamRef.current = null;
+    }
+    if (audioContextRef.current && audioContextRef.current.state !== "closed") {
+      audioContextRef.current.close().catch(() => {});
+    }
+    audioContextRef.current = null;
+    frameBufferRef.current = new Uint8Array(0);
+    setAnalyser(null);
+  }, []);
+  const cleanup = useCallback12(() => {
+    cleanupAudio();
+    if (socketRef.current) {
+      const socket = socketRef.current;
+      socket.onopen = null;
+      socket.onmessage = null;
+      socket.onerror = null;
+      socket.onclose = null;
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.close(1000, "Dictation cleanup");
+      }
+      socketRef.current = null;
+    }
+    sessionIdRef.current = null;
+    stoppingRef.current = false;
+    setIsListening(false);
+    setIsTranscribing(false);
+  }, [cleanupAudio]);
+  const flushFrameBuffer = useCallback12((force = false) => {
+    const socket = socketRef.current;
+    if (!socket || socket.readyState !== WebSocket.OPEN)
+      return;
+    let buffer = frameBufferRef.current;
+    while (buffer.byteLength >= PCM_FRAME_BYTES) {
+      const frame = buffer.slice(0, PCM_FRAME_BYTES);
+      socket.send(frame);
+      buffer = buffer.slice(PCM_FRAME_BYTES);
+    }
+    if (force && buffer.byteLength > 0) {
+      socket.send(buffer);
+      buffer = new Uint8Array(0);
+    }
+    frameBufferRef.current = buffer;
+  }, []);
+  const handleAudioProcess = useCallback12((event) => {
+    const audioContext = audioContextRef.current;
+    const socket = socketRef.current;
+    if (!audioContext || !socket || socket.readyState !== WebSocket.OPEN || stoppingRef.current) {
+      return;
+    }
+    const input = event.inputBuffer.getChannelData(0);
+    const resampled = resampleLinear(input, audioContext.sampleRate, TARGET_SAMPLE_RATE);
+    frameBufferRef.current = appendBuffer(frameBufferRef.current, new Uint8Array(floatToPcm16(resampled)));
+    flushFrameBuffer(false);
+  }, [flushFrameBuffer]);
+  const stop = useCallback12(() => {
+    stoppingRef.current = true;
+    flushFrameBuffer(true);
+    cleanupAudio();
+    const socket = socketRef.current;
+    if (socket?.readyState === WebSocket.OPEN) {
+      setIsListening(false);
+      setIsTranscribing(true);
+      socket.send(JSON.stringify({ type: "stop" }));
+    } else {
+      setIsListening(false);
+      setIsTranscribing(false);
+    }
+  }, [cleanupAudio, flushFrameBuffer]);
+  const start = useCallback12(async () => {
+    if (!isSupported) {
+      emitError("Voice input is not supported in this browser");
+      return;
+    }
+    cleanup();
+    setError(null);
+    setIsTranscribing(false);
+    stoppingRef.current = false;
+    try {
+      const status = await apiClient.getDictationStatus();
+      const model = status.models.find((item) => item.id === status.defaultModel);
+      if (!model?.installed) {
+        emitError("Install a local dictation model from Settings before recording.");
+        return;
+      }
+      const session = await apiClient.createDictationSession({
+        model: status.defaultModel,
+        language: toLanguageCode(lang)
+      });
+      if (!session.modelInstalled) {
+        emitError("Install a local dictation model from Settings before recording.");
+        return;
+      }
+      const socket = new WebSocket(session.wsUrl);
+      socket.binaryType = "arraybuffer";
+      socketRef.current = socket;
+      sessionIdRef.current = session.id;
+      await new Promise((resolve, reject) => {
+        const timeout = window.setTimeout(() => {
+          reject(new Error("Timed out connecting to local dictation"));
+        }, 5000);
+        socket.onopen = () => {
+          window.clearTimeout(timeout);
+          socket.send(JSON.stringify({
+            type: "start",
+            model: session.model,
+            language: toLanguageCode(lang),
+            format: {
+              encoding: "pcm_s16le",
+              sampleRate: TARGET_SAMPLE_RATE,
+              channels: 1
+            },
+            partialResults: false
+          }));
+          resolve();
+        };
+        socket.onerror = () => {
+          window.clearTimeout(timeout);
+          reject(new Error("Could not connect to local dictation"));
+        };
+      });
+      socket.onmessage = (event) => {
+        if (typeof event.data !== "string")
+          return;
+        const payload = parseServerEvent(event.data);
+        if (!payload)
+          return;
+        if (payload.type === "final") {
+          onTranscriptRef.current?.(payload.text.trim(), true);
+          cleanup();
+          return;
+        }
+        if (payload.type === "error") {
+          emitError(payload.message);
+          cleanup();
+        }
+      };
+      socket.onclose = () => {
+        if (!stoppingRef.current)
+          setIsListening(false);
+        setIsTranscribing(false);
+      };
+      const stream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true
+        }
+      });
+      streamRef.current = stream;
+      const AudioContextCtor = getAudioContextConstructor();
+      if (!AudioContextCtor)
+        throw new Error("AudioContext is unavailable");
+      const audioContext = new AudioContextCtor;
+      const source = audioContext.createMediaStreamSource(stream);
+      const analyserNode = audioContext.createAnalyser();
+      analyserNode.fftSize = 256;
+      analyserNode.smoothingTimeConstant = 0.55;
+      const processor = audioContext.createScriptProcessor(4096, 1, 1);
+      processor.onaudioprocess = handleAudioProcess;
+      source.connect(analyserNode);
+      source.connect(processor);
+      processor.connect(audioContext.destination);
+      audioContextRef.current = audioContext;
+      sourceRef.current = source;
+      processorRef.current = processor;
+      setAnalyser(analyserNode);
+      setIsListening(true);
+    } catch (err) {
+      const name = err instanceof Error ? err.name : "";
+      const msg = name === "NotAllowedError" ? "Microphone permission denied" : err instanceof Error ? err.message : "Could not start voice input";
+      emitError(msg);
+      cleanup();
+    }
+  }, [cleanup, emitError, handleAudioProcess, isSupported, lang]);
+  useEffect19(() => cleanup, [cleanup]);
+  return {
+    isListening,
+    isTranscribing,
+    isSupported,
+    analyser,
+    error,
+    start,
+    stop
+  };
+}
+// src/hooks/useDictationModels.ts
+import { useCallback as useCallback13, useEffect as useEffect20, useRef as useRef10, useState as useState7 } from "react";
+import { useMutation as useMutation10, useQuery as useQuery14, useQueryClient as useQueryClient13 } from "@tanstack/react-query";
+var DICTATION_STATUS_QUERY_KEY = ["dictation", "status"];
+function mergeModelState(current, model) {
+  if (!current)
+    return current;
+  return {
+    ...current,
+    models: current.models.map((item) => item.id === model.id ? model : item)
+  };
+}
+function parseInstallEvent(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (value.type !== "model" || !value.model)
+      return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function useDictationModels() {
+  const queryClient = useQueryClient13();
+  const eventSourceRef = useRef10(null);
+  const [activeInstallModelId, setActiveInstallModelId] = useState7(null);
+  const [installProgress, setInstallProgress] = useState7(null);
+  const [installStreamError, setInstallStreamError] = useState7(null);
+  const statusQuery = useQuery14({
+    queryKey: DICTATION_STATUS_QUERY_KEY,
+    queryFn: () => apiClient.getDictationStatus(),
+    refetchInterval: (query) => query.state.data?.models.some((model) => model.installing) ? 1000 : 30000
+  });
+  const closeInstallStream = useCallback13(() => {
+    if (eventSourceRef.current) {
+      eventSourceRef.current.close();
+      eventSourceRef.current = null;
+    }
+  }, []);
+  const openInstallStream = useCallback13((modelId) => {
+    if (typeof EventSource === "undefined")
+      return;
+    closeInstallStream();
+    setActiveInstallModelId(modelId);
+    setInstallStreamError(null);
+    const eventSource = new EventSource(apiClient.getDictationModelInstallEventsUrl(modelId));
+    eventSourceRef.current = eventSource;
+    eventSource.onmessage = (event) => {
+      const payload = parseInstallEvent(event.data);
+      if (!payload)
+        return;
+      setInstallProgress(payload.model);
+      queryClient.setQueryData(DICTATION_STATUS_QUERY_KEY, (current) => mergeModelState(current, payload.model));
+      if (!payload.model.installing) {
+        closeInstallStream();
+        setActiveInstallModelId(null);
+        queryClient.invalidateQueries({
+          queryKey: DICTATION_STATUS_QUERY_KEY
+        });
+      }
+    };
+    eventSource.onerror = () => {
+      setInstallStreamError("Lost dictation model install progress stream");
+      closeInstallStream();
+      setActiveInstallModelId(null);
+      queryClient.invalidateQueries({
+        queryKey: DICTATION_STATUS_QUERY_KEY
+      });
+    };
+  }, [closeInstallStream, queryClient]);
+  useEffect20(() => closeInstallStream, [closeInstallStream]);
+  const installMutation = useMutation10({
+    mutationFn: (input) => apiClient.installDictationModel(input),
+    onSuccess: (data) => {
+      setInstallProgress(data.model);
+      queryClient.setQueryData(DICTATION_STATUS_QUERY_KEY, (current) => mergeModelState(current, data.model));
+      if (data.model.installing) {
+        openInstallStream(data.model.id);
+      } else {
+        closeInstallStream();
+        setActiveInstallModelId(null);
+        queryClient.invalidateQueries({
+          queryKey: DICTATION_STATUS_QUERY_KEY
+        });
+      }
+    }
+  });
+  const removeMutation = useMutation10({
+    mutationFn: (model) => apiClient.removeDictationModel(model),
+    onSuccess: (data) => {
+      queryClient.setQueryData(DICTATION_STATUS_QUERY_KEY, (current) => mergeModelState(current, data.model));
+      queryClient.invalidateQueries({
+        queryKey: DICTATION_STATUS_QUERY_KEY
+      });
+    }
+  });
+  const installModel = useCallback13((model, options = {}) => installMutation.mutateAsync({ model, force: options.force }), [installMutation]);
+  const removeModel = useCallback13((model) => removeMutation.mutateAsync(model), [removeMutation]);
+  return {
+    statusQuery,
+    status: statusQuery.data,
+    models: statusQuery.data?.models ?? [],
+    defaultModel: statusQuery.data?.defaultModel ?? null,
+    isAvailable: statusQuery.data?.available ?? false,
+    activeInstallModelId,
+    installProgress,
+    installStreamError,
+    installModel,
+    removeModel,
+    installMutation,
+    removeMutation,
+    openInstallStream,
+    closeInstallStream
+  };
+}
 export {
   useWorkingDirectory,
+  useVoiceInput,
   useUpdateSkillsConfig,
   useUpdateSession,
   useUpdateDefaults,
@@ -6931,7 +7433,6 @@ export {
   useSkillFileContent,
   useSkillDetail,
   useShareStatus,
-  useSetuPayments,
   useSessionsInfinite,
   useSessions,
   useSessionStream,
@@ -6949,6 +7450,7 @@ export {
   useProviderUsage,
   usePreferences,
   useParentSession,
+  useOttoRouterPayments,
   useOttoRouterBalance,
   useModels,
   useMessages,
@@ -6973,6 +7475,7 @@ export {
   useFileTree,
   useFileContent,
   useExportToSession,
+  useDictationModels,
   useDeleteSession,
   useDeleteResearchSession,
   useDeleteFiles,
@@ -6997,4 +7500,4 @@ export {
   normalizeQueueState
 };
 
-//# debugId=C8B7C4D04F69D1E164756E2164756E21
+//# debugId=6E5B9890DD6BFD3564756E2164756E21