@ottocode/web-sdk 0.1.226 → 0.1.228

package/dist/hooks/index.js

@@ -1,29 +1,4821 @@
-// Export all hooks
-export * from './useConfig';
-export * from './usePreferences';
-export * from './useFiles';
-export * from './useGit';
-export * from './useMessages';
-export * from './useSessions';
-export * from './useSessionStream';
-export * from './useTheme';
-export * from './useWorkingDirectory';
-export * from './useKeyboardShortcuts';
-export * from './useImageUpload';
-export * from './useFileUpload';
-export * from './useSessionFiles';
-export * from './useQueueState';
-export * from './useBranch';
-export * from './useResearch';
-export * from './useSetuPayments';
-export * from './useSetuBalance';
-export * from './useShareStatus';
-export * from './useToolApprovalShortcuts';
-export * from './useTopupCallback';
-export * from './useAuthStatus';
-export * from './useTunnel';
-export * from './useProviderUsage';
-export * from './useFileBrowser';
-export * from './useMCP';
-export * from './useSkills';
-//# sourceMappingURL=index.js.map
+// src/hooks/useConfig.ts
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+
+// src/lib/api-client/sessions.ts
+import {
+  createSession as apiCreateSession,
+  listSessions as apiListSessions,
+  listMessages as apiListMessages,
+  createMessage as apiCreateMessage,
+  abortSession as apiAbortSession,
+  deleteSession as apiDeleteSession,
+  updateSession as apiUpdateSession,
+  getSessionQueue as apiGetSessionQueue,
+  removeFromQueue as apiRemoveFromQueue,
+  retryMessage as apiRetryMessage
+} from "@ottocode/api";
+
+// src/lib/api-client/utils.ts
+import { client } from "@ottocode/api";
+
+// src/lib/config.ts
+function computeApiBaseUrl() {
+  const envUrl = import.meta.env?.VITE_API_BASE_URL;
+  if (envUrl) {
+    return envUrl;
+  }
+  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__;
+    }
+  }
+  return "http://localhost:9100";
+}
+function getRuntimeApiBaseUrl() {
+  return computeApiBaseUrl();
+}
+var API_BASE_URL = computeApiBaseUrl();
+var config = {
+  apiBaseUrl: API_BASE_URL
+};
+
+// src/lib/api-client/utils.ts
+function getClientAdapter() {
+  if (typeof window !== "undefined" && typeof window.fetch === "function") {
+    return "fetch";
+  }
+  return;
+}
+function extractErrorMessage(error) {
+  if (!error)
+    return "Unknown error";
+  if (typeof error === "string")
+    return error;
+  if (error && typeof error === "object") {
+    const errObj = error;
+    if (errObj.error && typeof errObj.error === "object") {
+      const innerError = errObj.error;
+      if (typeof innerError.message === "string")
+        return innerError.message;
+    }
+    if (typeof errObj.error === "string")
+      return errObj.error;
+    if (typeof errObj.message === "string")
+      return errObj.message;
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return "Error occurred (unable to parse)";
+    }
+  }
+  return "Unknown error";
+}
+function configureApiClient() {
+  const win = window;
+  const baseURL = win.OTTO_SERVER_URL || API_BASE_URL;
+  client.setConfig({
+    baseURL,
+    adapter: getClientAdapter()
+  });
+}
+configureApiClient();
+function getBaseUrl() {
+  const win = window;
+  if (win.OTTO_SERVER_URL)
+    return win.OTTO_SERVER_URL;
+  return API_BASE_URL;
+}
+function convertSession(apiSession) {
+  return {
+    ...apiSession,
+    title: apiSession.title ?? null,
+    createdAt: typeof apiSession.createdAt === "string" ? new Date(apiSession.createdAt).getTime() : apiSession.createdAt,
+    lastActiveAt: typeof apiSession.lastActiveAt === "string" ? new Date(apiSession.lastActiveAt).getTime() : apiSession.lastActiveAt
+  };
+}
+function convertMessage(apiMessage) {
+  return {
+    ...apiMessage,
+    createdAt: typeof apiMessage.createdAt === "string" ? new Date(apiMessage.createdAt).getTime() : apiMessage.createdAt,
+    completedAt: apiMessage.completedAt ? typeof apiMessage.completedAt === "string" ? new Date(apiMessage.completedAt).getTime() : apiMessage.completedAt : null
+  };
+}
+
+// src/lib/api-client/sessions.ts
+var sessionsMixin = {
+  async getSessions() {
+    const page = await this.getSessionsPage({ limit: 200 });
+    return page.items;
+  },
+  async getSessionsPage(params = {}) {
+    const { limit = 50, offset = 0 } = params;
+    const response = await apiListSessions({
+      query: { limit, offset }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    const data = response.data;
+    return {
+      items: (data?.items ?? []).map((s) => convertSession(s)),
+      hasMore: data?.hasMore ?? false,
+      nextOffset: data?.nextOffset ?? null
+    };
+  },
+  async createSession(data) {
+    const response = await apiCreateSession({
+      body: data
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    if (!response.data)
+      throw new Error("No data returned from create session");
+    return convertSession(response.data);
+  },
+  async updateSession(sessionId, data) {
+    const response = await apiUpdateSession({
+      path: { sessionId },
+      body: data
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return convertSession(response.data);
+  },
+  async deleteSession(sessionId) {
+    const response = await apiDeleteSession({ path: { sessionId } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async abortSession(sessionId) {
+    const response = await apiAbortSession({ path: { sessionId } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async abortMessage(sessionId, _messageId) {
+    const response = await apiAbortSession({
+      path: { sessionId }
+    });
+    if (response.error)
+      throw new Error("Failed to abort message");
+    return response.data;
+  },
+  async getQueueState(sessionId) {
+    const response = await apiGetSessionQueue({ path: { sessionId } });
+    if (response.error)
+      throw new Error("Failed to get queue state");
+    return response.data;
+  },
+  async removeFromQueue(sessionId, messageId) {
+    const response = await apiRemoveFromQueue({
+      path: { sessionId, messageId }
+    });
+    if (response.error)
+      throw new Error("Failed to remove from queue");
+    return response.data;
+  },
+  async getMessages(sessionId) {
+    const response = await apiListMessages({ path: { id: sessionId } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return (response.data || []).map(convertMessage);
+  },
+  async sendMessage(sessionId, data) {
+    const response = await apiCreateMessage({
+      path: { id: sessionId },
+      body: data
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  getStreamUrl(sessionId) {
+    return `${getBaseUrl()}/v1/sessions/${sessionId}/stream`;
+  },
+  async retryMessage(sessionId, messageId) {
+    const response = await apiRetryMessage({
+      path: { sessionId, messageId }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  }
+};
+
+// src/lib/api-client/git.ts
+import {
+  getGitStatus as apiGetGitStatus,
+  getGitDiff as apiGetGitDiff,
+  getGitBranch as apiGetGitBranch,
+  stageFiles as apiStageFiles,
+  unstageFiles as apiUnstageFiles,
+  restoreFiles as apiRestoreFiles,
+  deleteFiles as apiDeleteFiles,
+  commitChanges as apiCommitChanges,
+  generateCommitMessage as apiGenerateCommitMessage,
+  pushCommits as apiPushCommits,
+  pullChanges as apiPullChanges,
+  initGitRepo as apiInitGitRepo,
+  getGitRemotes as apiGetGitRemotes,
+  addGitRemote as apiAddGitRemote,
+  removeGitRemote as apiRemoveGitRemote
+} from "@ottocode/api";
+var gitMixin = {
+  async initGitRepo() {
+    const response = await apiInitGitRepo();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async getGitStatus() {
+    const response = await apiGetGitStatus();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async getGitDiff(file, staged = false) {
+    const response = await apiGetGitDiff({
+      query: { file, staged: staged ? "true" : "false" }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async getGitDiffFullFile(file, staged = false) {
+    const response = await apiGetGitDiff({
+      query: {
+        file,
+        staged: staged ? "true" : "false",
+        fullFile: "true"
+      }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async generateCommitMessage(sessionId) {
+    const response = await apiGenerateCommitMessage({
+      body: sessionId ? { sessionId } : {}
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async stageFiles(files) {
+    const response = await apiStageFiles({
+      body: { files }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async unstageFiles(files) {
+    const response = await apiUnstageFiles({
+      body: { files }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async restoreFiles(files) {
+    const response = await apiRestoreFiles({
+      body: { files }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async deleteFiles(files) {
+    const response = await apiDeleteFiles({
+      body: { files }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async commitChanges(message) {
+    const response = await apiCommitChanges({
+      body: { message }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async getGitBranch() {
+    const response = await apiGetGitBranch();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async pushCommits() {
+    const response = await apiPushCommits({
+      body: {}
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async pullChanges() {
+    const response = await apiPullChanges({
+      body: {}
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async getRemotes() {
+    const response = await apiGetGitRemotes();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data?.remotes;
+  },
+  async addRemote(name, url) {
+    const response = await apiAddGitRemote({
+      body: { name, url }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
+  async removeRemote(name) {
+    const response = await apiRemoveGitRemote({
+      body: { name }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  }
+};
+
+// src/lib/api-client/config.ts
+import {
+  getConfig as apiGetConfig,
+  getProviderModels as apiGetProviderModels,
+  getAllModels as apiGetAllModels,
+  updateDefaults as apiUpdateDefaults
+} from "@ottocode/api";
+var configMixin = {
+  async getConfig() {
+    const response = await apiGetConfig();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getModels(providerId) {
+    const response = await apiGetProviderModels({
+      path: { provider: providerId }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getAllModels() {
+    const response = await apiGetAllModels();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async updateDefaults(data) {
+    const response = await apiUpdateDefaults({
+      body: data
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  }
+};
+
+// src/lib/api-client/files.ts
+import {
+  listFiles as apiListFiles,
+  getFileTree as apiGetFileTree,
+  readFile as apiReadFile,
+  getSessionFiles as apiGetSessionFiles
+} from "@ottocode/api";
+var filesMixin = {
+  async listFiles() {
+    const response = await apiListFiles();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getFileTree(dirPath = ".") {
+    const response = await apiGetFileTree({
+      query: { path: dirPath }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async readFileContent(filePath) {
+    const response = await apiReadFile({
+      query: { path: filePath }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getSessionFiles(sessionId) {
+    const response = await apiGetSessionFiles({ path: { sessionId } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  }
+};
+
+// src/lib/api-client/branches.ts
+import {
+  createBranch as apiCreateBranch,
+  listBranches as apiListBranches,
+  getParentSession as apiGetParentSession,
+  getShareStatus as apiGetShareStatus,
+  shareSession as apiShareSession,
+  syncShare as apiSyncShare
+} from "@ottocode/api";
+var branchesMixin = {
+  async createBranch(sessionId, data) {
+    const response = await apiCreateBranch({
+      path: { sessionId },
+      body: data
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async listBranches(sessionId) {
+    const response = await apiListBranches({ path: { sessionId } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getParentSession(sessionId) {
+    const response = await apiGetParentSession({ path: { sessionId } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getShareStatus(sessionId) {
+    const response = await apiGetShareStatus({ path: { sessionId } });
+    if (response.error)
+      return { shared: false };
+    return response.data;
+  },
+  async shareSession(sessionId) {
+    const response = await apiShareSession({ path: { sessionId } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async syncSession(sessionId) {
+    const response = await apiSyncShare({ path: { sessionId } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  }
+};
+
+// src/lib/api-client/approval.ts
+import {
+  resolveApproval as apiResolveApproval,
+  getPendingApprovals as apiGetPendingApprovals
+} from "@ottocode/api";
+var approvalMixin = {
+  async approveToolCall(sessionId, callId, approved) {
+    const response = await apiResolveApproval({
+      path: { id: sessionId },
+      body: { callId, approved, sessionId }
+    });
+    if (response.error)
+      throw new Error("Failed to send tool approval");
+    return response.data;
+  },
+  async getPendingApprovals(sessionId) {
+    const response = await apiGetPendingApprovals({
+      path: { id: sessionId }
+    });
+    if (response.error)
+      return { ok: false, pending: [] };
+    return response.data;
+  }
+};
+
+// src/lib/api-client/setu.ts
+import {
+  getSetuBalance as apiGetSetuBalance,
+  getSetuWallet as apiGetSetuWallet,
+  getSetuUsdcBalance as apiGetSetuUsdcBalance,
+  createPolarCheckout as apiCreatePolarCheckout,
+  getPolarTopupEstimate as apiGetPolarTopupEstimate,
+  getPolarTopupStatus as apiGetPolarTopupStatus,
+  getRazorpayTopupEstimate as apiGetRazorpayTopupEstimate,
+  createRazorpayOrder as apiCreateRazorpayOrder,
+  verifyRazorpayPayment as apiVerifyRazorpayPayment,
+  selectTopupMethod as apiSelectTopupMethod,
+  cancelTopup as apiCancelTopup,
+  getPendingTopup as apiGetPendingTopup
+} from "@ottocode/api";
+var setuMixin = {
+  async getSetuBalance() {
+    try {
+      const response = await apiGetSetuBalance();
+      if (response.error)
+        return null;
+      return response.data;
+    } catch {
+      return null;
+    }
+  },
+  async getSetuWallet() {
+    try {
+      const response = await apiGetSetuWallet();
+      if (response.error)
+        return { configured: false };
+      return response.data;
+    } catch {
+      return { configured: false };
+    }
+  },
+  async getSetuUsdcBalance(network = "mainnet") {
+    try {
+      const response = await apiGetSetuUsdcBalance({
+        query: { network }
+      });
+      if (response.error)
+        return null;
+      return response.data;
+    } catch {
+      return null;
+    }
+  },
+  async getPolarTopupEstimate(amount) {
+    try {
+      const response = await apiGetPolarTopupEstimate({
+        query: { amount }
+      });
+      if (response.error)
+        return null;
+      return response.data;
+    } catch {
+      return null;
+    }
+  },
+  async createPolarCheckout(amount, successUrl) {
+    const response = await apiCreatePolarCheckout({
+      body: { amount, successUrl }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async selectTopupMethod(sessionId, method) {
+    const response = await apiSelectTopupMethod({
+      body: { sessionId, method }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async cancelTopup(sessionId, reason) {
+    const response = await apiCancelTopup({
+      body: { sessionId, reason }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getPendingTopup(sessionId) {
+    try {
+      const response = await apiGetPendingTopup({
+        query: { sessionId }
+      });
+      if (response.error)
+        return { hasPending: false };
+      return response.data;
+    } catch {
+      return { hasPending: false };
+    }
+  },
+  async getPolarTopupStatus(checkoutId) {
+    try {
+      const response = await apiGetPolarTopupStatus({
+        query: { checkoutId }
+      });
+      if (response.error)
+        return null;
+      return response.data;
+    } catch {
+      return null;
+    }
+  },
+  async getRazorpayTopupEstimate(amount) {
+    try {
+      const response = await apiGetRazorpayTopupEstimate({
+        query: { amount }
+      });
+      if (response.error)
+        return null;
+      return response.data;
+    } catch {
+      return null;
+    }
+  },
+  async createRazorpayOrder(amount) {
+    const response = await apiCreateRazorpayOrder({
+      body: { amount }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async verifyRazorpayPayment(params) {
+    const response = await apiVerifyRazorpayPayment({
+      body: params
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  }
+};
+
+// src/lib/api-client/auth.ts
+import {
+  getAuthStatus as apiGetAuthStatus,
+  setupSetuWallet as apiSetupSetuWallet,
+  importSetuWallet as apiImportSetuWallet,
+  exportSetuWallet as apiExportSetuWallet,
+  addProviderApiKey as apiAddProviderApiKey,
+  removeProvider as apiRemoveProvider,
+  completeOnboarding as apiCompleteOnboarding,
+  getOAuthUrl as apiGetOAuthUrl,
+  exchangeOAuthCode as apiExchangeOAuthCode,
+  startCopilotDeviceFlow as apiStartCopilotDeviceFlow,
+  pollCopilotDeviceFlow as apiPollCopilotDeviceFlow,
+  getCopilotAuthMethods as apiGetCopilotAuthMethods,
+  saveCopilotToken as apiSaveCopilotToken,
+  importCopilotTokenFromGh as apiImportCopilotTokenFromGh,
+  getCopilotDiagnostics as apiGetCopilotDiagnostics,
+  getProviderUsage as apiGetProviderUsage
+} from "@ottocode/api";
+var authMixin = {
+  async getAuthStatus() {
+    const response = await apiGetAuthStatus();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async setupSetuWallet() {
+    const response = await apiSetupSetuWallet();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async importSetuWallet(privateKey) {
+    const response = await apiImportSetuWallet({
+      body: { privateKey }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async exportSetuWallet() {
+    const response = await apiExportSetuWallet();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async addProvider(provider, apiKey) {
+    const response = await apiAddProviderApiKey({
+      path: { provider },
+      body: { apiKey }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async removeProvider(provider) {
+    const response = await apiRemoveProvider({ path: { provider } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async completeOnboarding() {
+    const response = await apiCompleteOnboarding();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  getOAuthStartUrl(provider, mode) {
+    const baseUrl = `${getBaseUrl()}/v1/auth/${provider}/oauth/start`;
+    if (mode)
+      return `${baseUrl}?mode=${mode}`;
+    return baseUrl;
+  },
+  async getOAuthUrl(provider, mode) {
+    const response = await apiGetOAuthUrl({
+      path: { provider },
+      body: { mode }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async exchangeOAuthCode(provider, code, sessionId) {
+    const response = await apiExchangeOAuthCode({
+      path: { provider },
+      body: { code, sessionId }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async startCopilotDeviceFlow() {
+    const response = await apiStartCopilotDeviceFlow();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async pollCopilotDeviceFlow(sessionId) {
+    const response = await apiPollCopilotDeviceFlow({
+      body: { sessionId }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getCopilotAuthMethods() {
+    const response = await apiGetCopilotAuthMethods();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async saveCopilotToken(token) {
+    const response = await apiSaveCopilotToken({ body: { token } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async importCopilotTokenFromGh() {
+    const response = await apiImportCopilotTokenFromGh();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getCopilotDiagnostics() {
+    const response = await apiGetCopilotDiagnostics();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getProviderUsage(provider) {
+    const response = await apiGetProviderUsage({
+      path: { provider }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  }
+};
+
+// src/lib/api-client/skills.ts
+import {
+  listSkills as apiListSkills,
+  getSkill as apiGetSkill,
+  listSkillFiles as apiListSkillFiles,
+  getSkillFile as apiGetSkillFile
+} from "@ottocode/api";
+var skillsMixin = {
+  async listSkills() {
+    const response = await apiListSkills();
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getSkill(name) {
+    const response = await apiGetSkill({ path: { name } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getSkillFiles(name) {
+    const response = await apiListSkillFiles({ path: { name } });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  },
+  async getSkillFileContent(name, filePath) {
+    const response = await apiGetSkillFile({
+      path: { name, filePath }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data;
+  }
+};
+
+// src/lib/api-client/index.ts
+class ApiClient {
+  getSessions = sessionsMixin.getSessions;
+  getSessionsPage = sessionsMixin.getSessionsPage;
+  createSession = sessionsMixin.createSession;
+  updateSession = sessionsMixin.updateSession;
+  deleteSession = sessionsMixin.deleteSession;
+  abortSession = sessionsMixin.abortSession;
+  abortMessage = sessionsMixin.abortMessage;
+  getQueueState = sessionsMixin.getQueueState;
+  removeFromQueue = sessionsMixin.removeFromQueue;
+  getMessages = sessionsMixin.getMessages;
+  sendMessage = sessionsMixin.sendMessage;
+  getStreamUrl = sessionsMixin.getStreamUrl;
+  retryMessage = sessionsMixin.retryMessage;
+  initGitRepo = gitMixin.initGitRepo;
+  getGitStatus = gitMixin.getGitStatus;
+  getGitDiff = gitMixin.getGitDiff;
+  getGitDiffFullFile = gitMixin.getGitDiffFullFile;
+  generateCommitMessage = gitMixin.generateCommitMessage;
+  stageFiles = gitMixin.stageFiles;
+  unstageFiles = gitMixin.unstageFiles;
+  restoreFiles = gitMixin.restoreFiles;
+  deleteFiles = gitMixin.deleteFiles;
+  commitChanges = gitMixin.commitChanges;
+  getGitBranch = gitMixin.getGitBranch;
+  pushCommits = gitMixin.pushCommits;
+  pullChanges = gitMixin.pullChanges;
+  getRemotes = gitMixin.getRemotes;
+  addRemote = gitMixin.addRemote;
+  removeRemote = gitMixin.removeRemote;
+  getConfig = configMixin.getConfig;
+  getModels = configMixin.getModels;
+  getAllModels = configMixin.getAllModels;
+  updateDefaults = configMixin.updateDefaults;
+  listFiles = filesMixin.listFiles;
+  getFileTree = filesMixin.getFileTree;
+  readFileContent = filesMixin.readFileContent;
+  getSessionFiles = filesMixin.getSessionFiles;
+  createBranch = branchesMixin.createBranch;
+  listBranches = branchesMixin.listBranches;
+  getParentSession = branchesMixin.getParentSession;
+  getShareStatus = branchesMixin.getShareStatus;
+  shareSession = branchesMixin.shareSession;
+  syncSession = branchesMixin.syncSession;
+  approveToolCall = approvalMixin.approveToolCall;
+  getPendingApprovals = approvalMixin.getPendingApprovals;
+  getSetuBalance = setuMixin.getSetuBalance;
+  getSetuWallet = setuMixin.getSetuWallet;
+  getSetuUsdcBalance = setuMixin.getSetuUsdcBalance;
+  getPolarTopupEstimate = setuMixin.getPolarTopupEstimate;
+  createPolarCheckout = setuMixin.createPolarCheckout;
+  selectTopupMethod = setuMixin.selectTopupMethod;
+  cancelTopup = setuMixin.cancelTopup;
+  getPendingTopup = setuMixin.getPendingTopup;
+  getPolarTopupStatus = setuMixin.getPolarTopupStatus;
+  getRazorpayTopupEstimate = setuMixin.getRazorpayTopupEstimate;
+  createRazorpayOrder = setuMixin.createRazorpayOrder;
+  verifyRazorpayPayment = setuMixin.verifyRazorpayPayment;
+  getAuthStatus = authMixin.getAuthStatus;
+  setupSetuWallet = authMixin.setupSetuWallet;
+  importSetuWallet = authMixin.importSetuWallet;
+  exportSetuWallet = authMixin.exportSetuWallet;
+  addProvider = authMixin.addProvider;
+  removeProvider = authMixin.removeProvider;
+  completeOnboarding = authMixin.completeOnboarding;
+  getOAuthStartUrl = authMixin.getOAuthStartUrl;
+  getOAuthUrl = authMixin.getOAuthUrl;
+  exchangeOAuthCode = authMixin.exchangeOAuthCode;
+  startCopilotDeviceFlow = authMixin.startCopilotDeviceFlow;
+  pollCopilotDeviceFlow = authMixin.pollCopilotDeviceFlow;
+  getCopilotAuthMethods = authMixin.getCopilotAuthMethods;
+  saveCopilotToken = authMixin.saveCopilotToken;
+  importCopilotTokenFromGh = authMixin.importCopilotTokenFromGh;
+  getCopilotDiagnostics = authMixin.getCopilotDiagnostics;
+  getProviderUsage = authMixin.getProviderUsage;
+  listSkills = skillsMixin.listSkills;
+  getSkill = skillsMixin.getSkill;
+  getSkillFiles = skillsMixin.getSkillFiles;
+  getSkillFileContent = skillsMixin.getSkillFileContent;
+}
+var apiClient = new ApiClient;
+
+// src/hooks/useConfig.ts
+function useConfig() {
+  return useQuery({
+    queryKey: ["config"],
+    queryFn: () => apiClient.getConfig(),
+    staleTime: 30000
+  });
+}
+function useModels(provider) {
+  return useQuery({
+    queryKey: ["models", provider],
+    queryFn: () => provider ? apiClient.getModels(provider) : null,
+    enabled: !!provider
+  });
+}
+function useAllModels() {
+  return useQuery({
+    queryKey: ["models", "all"],
+    queryFn: () => apiClient.getAllModels()
+  });
+}
+function useUpdateDefaults() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data) => apiClient.updateDefaults(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["config"] });
+    }
+  });
+}
+// src/hooks/usePreferences.ts
+import { useCallback, useMemo, useSyncExternalStore } from "react";
+var STORAGE_KEY = "otto-preferences";
+var DEFAULT_PREFERENCES = {
+  vimMode: false,
+  compactThread: true
+};
+function resolveInitialPreferences() {
+  if (typeof window === "undefined") {
+    return DEFAULT_PREFERENCES;
+  }
+  try {
+    const stored = window.localStorage.getItem(STORAGE_KEY);
+    if (stored) {
+      const parsed = JSON.parse(stored);
+      return {
+        ...DEFAULT_PREFERENCES,
+        ...parsed
+      };
+    }
+  } catch (error) {
+    console.warn("Failed to load preferences", error);
+  }
+  return DEFAULT_PREFERENCES;
+}
+var preferences = resolveInitialPreferences();
+var listeners = new Set;
+function getSnapshot() {
+  return preferences;
+}
+function getServerSnapshot() {
+  return DEFAULT_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 (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 updatePreferences = useCallback((updates) => {
+    updateStore(updates);
+  }, []);
+  return useMemo(() => ({ preferences: currentPreferences, updatePreferences }), [currentPreferences, updatePreferences]);
+}
+// src/hooks/useFiles.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function useFiles() {
+  return useQuery2({
+    queryKey: ["files"],
+    queryFn: async () => {
+      const result = await apiClient.listFiles();
+      return result;
+    },
+    staleTime: 1e4,
+    refetchOnWindowFocus: true,
+    retry: 1
+  });
+}
+// src/hooks/useGit.ts
+import { useQuery as useQuery3, useMutation as useMutation2, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+
+// src/stores/gitStore.ts
+import { create as create8 } from "zustand";
+
+// src/stores/sessionFilesStore.ts
+import { create as create7 } from "zustand";
+
+// src/stores/researchStore.ts
+import { create as create6 } from "zustand";
+
+// src/stores/settingsStore.ts
+import { create as create5 } from "zustand";
+
+// src/stores/tunnelStore.ts
+import { create as create4 } from "zustand";
+
+// src/stores/fileBrowserStore.ts
+import { create as create3 } from "zustand";
+
+// src/stores/mcpStore.ts
+import { create as create2 } from "zustand";
+
+// src/stores/skillsStore.ts
+import { create } from "zustand";
+var useSkillsStore = create((set) => ({
+  isExpanded: false,
+  skills: [],
+  selectedSkill: null,
+  isViewerOpen: false,
+  viewingFile: null,
+  toggleSidebar: () => {
+    set((state) => {
+      const newExpanded = !state.isExpanded;
+      if (newExpanded) {
+        useGitStore.getState().collapseSidebar();
+        useSessionFilesStore.getState().collapseSidebar();
+        useResearchStore.getState().collapseSidebar();
+        useSettingsStore.getState().collapseSidebar();
+        useTunnelStore.getState().collapseSidebar();
+        useFileBrowserStore.getState().collapseSidebar();
+        useMCPStore.getState().collapseSidebar();
+      }
+      return { isExpanded: newExpanded };
+    });
+  },
+  expandSidebar: () => {
+    useGitStore.getState().collapseSidebar();
+    useSessionFilesStore.getState().collapseSidebar();
+    useResearchStore.getState().collapseSidebar();
+    useSettingsStore.getState().collapseSidebar();
+    useTunnelStore.getState().collapseSidebar();
+    useFileBrowserStore.getState().collapseSidebar();
+    useMCPStore.getState().collapseSidebar();
+    set({ isExpanded: true });
+  },
+  collapseSidebar: () => set({ isExpanded: false }),
+  setSkills: (skills) => set({ skills }),
+  selectSkill: (name) => set({ selectedSkill: name, isViewerOpen: false, viewingFile: null }),
+  openViewer: (file) => set({ isViewerOpen: true, viewingFile: file }),
+  closeViewer: () => set({ isViewerOpen: false, viewingFile: null })
+}));
+
+// src/stores/mcpStore.ts
+var useMCPStore = create2((set) => ({
+  isExpanded: false,
+  servers: [],
+  loading: new Set,
+  authUrls: new Map,
+  copilotDevice: null,
+  toggleSidebar: () => {
+    set((state) => {
+      const newExpanded = !state.isExpanded;
+      if (newExpanded) {
+        useGitStore.getState().collapseSidebar();
+        useSessionFilesStore.getState().collapseSidebar();
+        useResearchStore.getState().collapseSidebar();
+        useSettingsStore.getState().collapseSidebar();
+        useTunnelStore.getState().collapseSidebar();
+        useFileBrowserStore.getState().collapseSidebar();
+        useSkillsStore.getState().collapseSidebar();
+      }
+      return { isExpanded: newExpanded };
+    });
+  },
+  expandSidebar: () => {
+    useGitStore.getState().collapseSidebar();
+    useSessionFilesStore.getState().collapseSidebar();
+    useResearchStore.getState().collapseSidebar();
+    useSettingsStore.getState().collapseSidebar();
+    useTunnelStore.getState().collapseSidebar();
+    useFileBrowserStore.getState().collapseSidebar();
+    useSkillsStore.getState().collapseSidebar();
+    set({ isExpanded: true });
+  },
+  collapseSidebar: () => set({ isExpanded: false }),
+  setServers: (servers) => set({ servers }),
+  setLoading: (name, loading) => set((state) => {
+    const next = new Set(state.loading);
+    if (loading)
+      next.add(name);
+    else
+      next.delete(name);
+    return { loading: next };
+  }),
+  updateServer: (name, updates) => set((state) => ({
+    servers: state.servers.map((s) => s.name === name ? { ...s, ...updates } : s)
+  })),
+  setAuthUrl: (name, url) => set((state) => {
+    const next = new Map(state.authUrls);
+    if (url)
+      next.set(name, url);
+    else
+      next.delete(name);
+    return { authUrls: next };
+  }),
+  setCopilotDevice: (info) => set({ copilotDevice: info })
+}));
+
+// src/stores/fileBrowserStore.ts
+var useFileBrowserStore = create3((set) => ({
+  isExpanded: false,
+  selectedFile: null,
+  isViewerOpen: false,
+  expandedDirs: new Set,
+  toggleSidebar: () => {
+    set((state) => {
+      const newExpanded = !state.isExpanded;
+      if (newExpanded) {
+        useGitStore.getState().collapseSidebar();
+        useSessionFilesStore.getState().collapseSidebar();
+        useResearchStore.getState().collapseSidebar();
+        useSettingsStore.getState().collapseSidebar();
+        useTunnelStore.getState().collapseSidebar();
+        useMCPStore.getState().collapseSidebar();
+        useSkillsStore.getState().collapseSidebar();
+      }
+      return { isExpanded: newExpanded };
+    });
+  },
+  expandSidebar: () => {
+    useGitStore.getState().collapseSidebar();
+    useSessionFilesStore.getState().collapseSidebar();
+    useResearchStore.getState().collapseSidebar();
+    useSettingsStore.getState().collapseSidebar();
+    useTunnelStore.getState().collapseSidebar();
+    useMCPStore.getState().collapseSidebar();
+    useSkillsStore.getState().collapseSidebar();
+    set({ isExpanded: true });
+  },
+  collapseSidebar: () => set({
+    isExpanded: false,
+    isViewerOpen: false,
+    selectedFile: null
+  }),
+  openFile: (path) => set({
+    selectedFile: path,
+    isViewerOpen: true
+  }),
+  closeViewer: () => set({
+    isViewerOpen: false,
+    selectedFile: null
+  }),
+  toggleDir: (path) => set((state) => {
+    const next = new Set(state.expandedDirs);
+    if (next.has(path)) {
+      next.delete(path);
+    } else {
+      next.add(path);
+    }
+    return { expandedDirs: next };
+  })
+}));
+
+// src/stores/tunnelStore.ts
+var useTunnelStore = create4((set) => ({
+  isExpanded: false,
+  status: "idle",
+  url: null,
+  qrCode: null,
+  error: null,
+  progress: null,
+  toggleSidebar: () => {
+    set((state) => {
+      const newExpanded = !state.isExpanded;
+      if (newExpanded) {
+        useGitStore.getState().collapseSidebar();
+        useSessionFilesStore.getState().collapseSidebar();
+        useSettingsStore.getState().collapseSidebar();
+        useResearchStore.getState().collapseSidebar();
+        useFileBrowserStore.getState().collapseSidebar();
+        useMCPStore.getState().collapseSidebar();
+        useSkillsStore.getState().collapseSidebar();
+      }
+      return { isExpanded: newExpanded };
+    });
+  },
+  expandSidebar: () => {
+    useGitStore.getState().collapseSidebar();
+    useSessionFilesStore.getState().collapseSidebar();
+    useSettingsStore.getState().collapseSidebar();
+    useResearchStore.getState().collapseSidebar();
+    useFileBrowserStore.getState().collapseSidebar();
+    useMCPStore.getState().collapseSidebar();
+    useSkillsStore.getState().collapseSidebar();
+    set({ isExpanded: true });
+  },
+  collapseSidebar: () => set({ isExpanded: false }),
+  setStatus: (status) => set({ status }),
+  setUrl: (url) => set({ url }),
+  setQrCode: (qrCode) => set({ qrCode }),
+  setError: (error) => set({ error }),
+  setProgress: (progress) => set({ progress }),
+  reset: () => set({
+    status: "idle",
+    url: null,
+    qrCode: null,
+    error: null,
+    progress: null
+  })
+}));
+
+// src/stores/settingsStore.ts
+var useSettingsStore = create5((set) => ({
+  isExpanded: false,
+  toggleSidebar: () => {
+    set((state) => {
+      const newExpanded = !state.isExpanded;
+      if (newExpanded) {
+        useGitStore.getState().collapseSidebar();
+        useSessionFilesStore.getState().collapseSidebar();
+        useResearchStore.getState().collapseSidebar();
+        useTunnelStore.getState().collapseSidebar();
+        useFileBrowserStore.getState().collapseSidebar();
+        useMCPStore.getState().collapseSidebar();
+        useSkillsStore.getState().collapseSidebar();
+      }
+      return { isExpanded: newExpanded };
+    });
+  },
+  expandSidebar: () => set({ isExpanded: true }),
+  collapseSidebar: () => set({ isExpanded: false })
+}));
+
+// src/stores/researchStore.ts
+var useResearchStore = create6((set, get) => ({
+  isExpanded: false,
+  activeResearchSessionId: null,
+  parentSessionId: null,
+  toggleSidebar: () => {
+    set((state) => {
+      const newExpanded = !state.isExpanded;
+      if (newExpanded) {
+        useGitStore.getState().collapseSidebar();
+        useSessionFilesStore.getState().collapseSidebar();
+        useSettingsStore.getState().collapseSidebar();
+        useTunnelStore.getState().collapseSidebar();
+        useFileBrowserStore.getState().collapseSidebar();
+        useMCPStore.getState().collapseSidebar();
+        useSkillsStore.getState().collapseSidebar();
+      }
+      return { isExpanded: newExpanded };
+    });
+  },
+  expandSidebar: () => {
+    useGitStore.getState().collapseSidebar();
+    useSessionFilesStore.getState().collapseSidebar();
+    useSettingsStore.getState().collapseSidebar();
+    useTunnelStore.getState().collapseSidebar();
+    useFileBrowserStore.getState().collapseSidebar();
+    useMCPStore.getState().collapseSidebar();
+    useSkillsStore.getState().collapseSidebar();
+    set({ isExpanded: true });
+  },
+  collapseSidebar: () => set({ isExpanded: false }),
+  selectResearchSession: (id) => set({ activeResearchSessionId: id }),
+  setParentSessionId: (id) => {
+    const currentParentId = get().parentSessionId;
+    if (currentParentId !== id) {
+      set({
+        parentSessionId: id,
+        activeResearchSessionId: null
+      });
+    }
+  },
+  reset: () => set({
+    activeResearchSessionId: null,
+    parentSessionId: null
+  })
+}));
+
+// src/stores/sessionFilesStore.ts
+var useSessionFilesStore = create7((set) => ({
+  isExpanded: false,
+  selectedFile: null,
+  allOperations: [],
+  selectedOperationIndex: 0,
+  isDiffOpen: false,
+  toggleSidebar: () => {
+    set((state) => {
+      const newExpanded = !state.isExpanded;
+      if (newExpanded) {
+        useGitStore.getState().collapseSidebar();
+        useResearchStore.getState().collapseSidebar();
+        useSettingsStore.getState().collapseSidebar();
+        useTunnelStore.getState().collapseSidebar();
+        useFileBrowserStore.getState().collapseSidebar();
+        useMCPStore.getState().collapseSidebar();
+        useSkillsStore.getState().collapseSidebar();
+      }
+      return { isExpanded: newExpanded };
+    });
+  },
+  expandSidebar: () => {
+    useGitStore.getState().collapseSidebar();
+    useResearchStore.getState().collapseSidebar();
+    useSettingsStore.getState().collapseSidebar();
+    useTunnelStore.getState().collapseSidebar();
+    useFileBrowserStore.getState().collapseSidebar();
+    useMCPStore.getState().collapseSidebar();
+    useSkillsStore.getState().collapseSidebar();
+    set({ isExpanded: true });
+  },
+  collapseSidebar: () => set({
+    isExpanded: false,
+    isDiffOpen: false,
+    selectedFile: null,
+    allOperations: [],
+    selectedOperationIndex: 0
+  }),
+  openDiff: (file, operations) => set({
+    selectedFile: file,
+    allOperations: operations,
+    selectedOperationIndex: operations.length - 1,
+    isDiffOpen: true,
+    isExpanded: true
+  }),
+  selectOperation: (index) => set({ selectedOperationIndex: index }),
+  closeDiff: () => set({
+    isDiffOpen: false,
+    selectedFile: null,
+    allOperations: [],
+    selectedOperationIndex: 0
+  })
+}));
+
+// src/stores/gitStore.ts
+var useGitStore = create8((set) => ({
+  isExpanded: false,
+  activeSessionId: null,
+  selectedFile: null,
+  selectedFileStaged: false,
+  isDiffOpen: false,
+  isCommitModalOpen: false,
+  commitSessionId: null,
+  wasSessionListCollapsed: false,
+  toggleSidebar: () => {
+    set((state) => {
+      const newExpanded = !state.isExpanded;
+      if (newExpanded) {
+        useSessionFilesStore.getState().collapseSidebar();
+        useResearchStore.getState().collapseSidebar();
+        useSettingsStore.getState().collapseSidebar();
+        useTunnelStore.getState().collapseSidebar();
+        useFileBrowserStore.getState().collapseSidebar();
+        useMCPStore.getState().collapseSidebar();
+        useSkillsStore.getState().collapseSidebar();
+      }
+      return { isExpanded: newExpanded };
+    });
+  },
+  expandSidebar: () => set({ isExpanded: true }),
+  collapseSidebar: () => set({ isExpanded: false, isDiffOpen: false, selectedFile: null }),
+  openDiff: (file, staged) => set({
+    selectedFile: file,
+    selectedFileStaged: staged,
+    isDiffOpen: true,
+    isExpanded: true
+  }),
+  closeDiff: () => set({
+    isDiffOpen: false,
+    selectedFile: null
+  }),
+  switchFile: (file, staged) => set({
+    selectedFile: file,
+    selectedFileStaged: staged
+  }),
+  openCommitModal: () => set((state) => ({
+    isCommitModalOpen: true,
+    commitSessionId: state.activeSessionId
+  })),
+  openCommitModalForSession: (sessionId) => set({ isCommitModalOpen: true, commitSessionId: sessionId }),
+  closeCommitModal: () => set({ isCommitModalOpen: false, commitSessionId: null }),
+  setActiveSessionId: (sessionId) => set({ activeSessionId: sessionId }),
+  setSessionListCollapsed: (collapsed) => set({ wasSessionListCollapsed: collapsed })
+}));
+
+// src/hooks/useGit.ts
+function useGitStatus() {
+  const isExpanded = useGitStore((state) => state.isExpanded);
+  return useQuery3({
+    queryKey: ["git", "status"],
+    queryFn: () => apiClient.getGitStatus(),
+    refetchInterval: isExpanded ? 5000 : false,
+    retry: 1,
+    staleTime: 3000
+  });
+}
+function useGitDiff(file, staged = false) {
+  return useQuery3({
+    queryKey: ["git", "diff", file, staged],
+    queryFn: () => file ? apiClient.getGitDiff(file, staged) : null,
+    enabled: !!file,
+    retry: 1,
+    refetchInterval: false
+  });
+}
+function useGitBranch() {
+  const isExpanded = useGitStore((state) => state.isExpanded);
+  return useQuery3({
+    queryKey: ["git", "branch"],
+    queryFn: () => apiClient.getGitBranch(),
+    refetchInterval: isExpanded ? 1e4 : false,
+    retry: 1,
+    staleTime: 5000
+  });
+}
+function useGenerateCommitMessage(sessionId) {
+  return useMutation2({
+    mutationFn: () => apiClient.generateCommitMessage(sessionId ?? undefined)
+  });
+}
+function useStageFiles() {
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: (files) => apiClient.stageFiles(files),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["git", "status"] });
+    }
+  });
+}
+function useUnstageFiles() {
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: (files) => apiClient.unstageFiles(files),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["git", "status"] });
+    }
+  });
+}
+function useRestoreFiles() {
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: (files) => apiClient.restoreFiles(files),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["git", "status"] });
+    }
+  });
+}
+function useDeleteFiles() {
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: (files) => apiClient.deleteFiles(files),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["git", "status"] });
+    }
+  });
+}
+function useCommitChanges() {
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: (message) => apiClient.commitChanges(message),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["git", "status"] });
+      queryClient.invalidateQueries({ queryKey: ["git", "branch"] });
+    }
+  });
+}
+function usePushCommits() {
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: () => apiClient.pushCommits(),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["git", "status"] });
+      queryClient.invalidateQueries({ queryKey: ["git", "branch"] });
+    }
+  });
+}
+function usePullChanges() {
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: () => apiClient.pullChanges(),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["git", "status"] });
+      queryClient.invalidateQueries({ queryKey: ["git", "branch"] });
+    }
+  });
+}
+function useGitInit() {
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: () => apiClient.initGitRepo(),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["git", "status"] });
+      queryClient.invalidateQueries({ queryKey: ["git", "branch"] });
+    }
+  });
+}
+function useGitRemotes() {
+  const isExpanded = useGitStore((state) => state.isExpanded);
+  return useQuery3({
+    queryKey: ["git", "remotes"],
+    queryFn: () => apiClient.getRemotes(),
+    enabled: isExpanded,
+    retry: 1,
+    staleTime: 1e4
+  });
+}
+function useAddRemote() {
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: ({ name, url }) => apiClient.addRemote(name, url),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["git", "remotes"] });
+      queryClient.invalidateQueries({ queryKey: ["git", "status"] });
+    }
+  });
+}
+function useRemoveRemote() {
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: (name) => apiClient.removeRemote(name),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["git", "remotes"] });
+      queryClient.invalidateQueries({ queryKey: ["git", "status"] });
+    }
+  });
+}
+// src/hooks/useMessages.ts
+import { useQuery as useQuery4, useMutation as useMutation4, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+
+// src/hooks/useSessions.ts
+import {
+  useInfiniteQuery,
+  useMutation as useMutation3,
+  useQueryClient as useQueryClient3
+} from "@tanstack/react-query";
+import { useMemo as useMemo2 } from "react";
+var SESSIONS_PAGE_SIZE = 50;
+var sessionsQueryKey = ["sessions", "list"];
+function useSessionsInfinite() {
+  return useInfiniteQuery({
+    queryKey: sessionsQueryKey,
+    queryFn: ({ pageParam = 0 }) => apiClient.getSessionsPage({
+      limit: SESSIONS_PAGE_SIZE,
+      offset: pageParam
+    }),
+    getNextPageParam: (lastPage) => lastPage.nextOffset ?? undefined,
+    initialPageParam: 0,
+    staleTime: 30000,
+    refetchInterval: 30000,
+    refetchOnWindowFocus: false
+  });
+}
+function useSessions() {
+  const query = useSessionsInfinite();
+  const data = useMemo2(() => {
+    if (!query.data?.pages)
+      return [];
+    return query.data.pages.flatMap((p) => p.items ?? []);
+  }, [query.data]);
+  return {
+    data,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    hasNextPage: query.hasNextPage,
+    fetchNextPage: query.fetchNextPage,
+    isFetchingNextPage: query.isFetchingNextPage
+  };
+}
+function useSession(sessionId) {
+  const { data: sessions } = useSessions();
+  return sessions?.find((s) => s.id === sessionId);
+}
+function useCreateSession() {
+  const queryClient = useQueryClient3();
+  return useMutation3({
+    mutationFn: (data) => apiClient.createSession(data),
+    onSuccess: (newSession) => {
+      queryClient.setQueryData(sessionsQueryKey, (old) => {
+        if (!old)
+          return old;
+        const firstPage = old.pages[0];
+        if (!firstPage)
+          return old;
+        return {
+          ...old,
+          pages: [
+            { ...firstPage, items: [newSession, ...firstPage.items] },
+            ...old.pages.slice(1)
+          ]
+        };
+      });
+      queryClient.invalidateQueries({ queryKey: sessionsQueryKey });
+    }
+  });
+}
+function useUpdateSession(sessionId) {
+  const queryClient = useQueryClient3();
+  return useMutation3({
+    mutationFn: (data) => apiClient.updateSession(sessionId, data),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: sessionsQueryKey });
+      await queryClient.invalidateQueries({ queryKey: ["session", sessionId] });
+    }
+  });
+}
+function useDeleteSession() {
+  const queryClient = useQueryClient3();
+  return useMutation3({
+    mutationFn: (sessionId) => apiClient.deleteSession(sessionId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: sessionsQueryKey });
+    }
+  });
+}
+
+// src/hooks/useMessages.ts
+function useMessages(sessionId) {
+  return useQuery4({
+    queryKey: ["messages", sessionId],
+    queryFn: () => {
+      if (!sessionId) {
+        throw new Error("Session ID is required");
+      }
+      return apiClient.getMessages(sessionId);
+    },
+    enabled: !!sessionId
+  });
+}
+function useSendMessage(sessionId) {
+  const queryClient = useQueryClient4();
+  return useMutation4({
+    mutationFn: (data) => apiClient.sendMessage(sessionId, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["messages", sessionId] });
+      queryClient.invalidateQueries({ queryKey: sessionsQueryKey });
+    }
+  });
+}
+// src/hooks/useSessionStream.ts
+import { useEffect, useRef } from "react";
+import { useQueryClient as useQueryClient5 } from "@tanstack/react-query";
+
+// src/lib/sse-client.ts
+class SSEClient {
+  abortController = null;
+  handlers = new Map;
+  running = false;
+  async connect(url) {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    this.abortController = new AbortController;
+    this.running = true;
+    try {
+      const response = await fetch(url, {
+        headers: { Accept: "text/event-stream" },
+        signal: this.abortController.signal
+      });
+      if (!response.ok) {
+        console.error("[SSE] Connection failed:", response.status);
+        return;
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        console.error("[SSE] No response body");
+        return;
+      }
+      const decoder = new TextDecoder;
+      let buffer = "";
+      while (this.running) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        let idx = buffer.indexOf(`
+
+`);
+        while (idx !== -1) {
+          const raw = buffer.slice(0, idx);
+          buffer = buffer.slice(idx + 2);
+          const lines = raw.split(`
+`);
+          let eventType = "message";
+          let data = "";
+          for (const line of lines) {
+            if (line.startsWith("event: ")) {
+              eventType = line.slice(7).trim();
+            } else if (line.startsWith("data: ")) {
+              data += (data ? `
+` : "") + line.slice(6);
+            } else if (line.startsWith(":")) {}
+          }
+          if (data) {
+            try {
+              const payload = JSON.parse(data);
+              this.emit({ type: eventType, payload });
+            } catch (error) {
+              console.error(`[SSE] Failed to parse ${eventType}:`, error);
+            }
+          }
+          idx = buffer.indexOf(`
+
+`);
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {} else if (error instanceof TypeError && error.message === "Load failed") {} else {
+        console.error("[SSE] Connection error:", error);
+      }
+    }
+  }
+  disconnect() {
+    this.running = false;
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+  on(eventType, handler) {
+    if (!this.handlers.has(eventType)) {
+      this.handlers.set(eventType, new Set);
+    }
+    this.handlers.get(eventType)?.add(handler);
+    return () => {
+      this.off(eventType, handler);
+    };
+  }
+  off(eventType, handler) {
+    const handlers = this.handlers.get(eventType);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.handlers.delete(eventType);
+      }
+    }
+  }
+  emit(event) {
+    const handlers = this.handlers.get(event.type);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(event);
+      }
+    }
+    const allHandlers = this.handlers.get("*");
+    if (allHandlers) {
+      for (const handler of allHandlers) {
+        handler(event);
+      }
+    }
+  }
+}
+
+// src/stores/toolApprovalStore.ts
+import { create as create9 } from "zustand";
+var useToolApprovalStore = create9((set) => ({
+  pendingApprovals: [],
+  addPendingApproval: (approval) => set((state) => ({
+    pendingApprovals: [...state.pendingApprovals, approval]
+  })),
+  removePendingApproval: (callId) => set((state) => ({
+    pendingApprovals: state.pendingApprovals.filter((a) => a.callId !== callId)
+  })),
+  updatePendingApproval: (callId, args) => set((state) => ({
+    pendingApprovals: state.pendingApprovals.map((a) => a.callId === callId ? { ...a, args } : a)
+  })),
+  clearPendingApprovals: () => set({ pendingApprovals: [] }),
+  setPendingApprovals: (approvals) => set({ pendingApprovals: approvals })
+}));
+
+// src/hooks/useSessionStream.ts
+function useSessionStream(sessionId) {
+  const queryClient = useQueryClient5();
+  const clientRef = useRef(null);
+  const assistantMessageIdRef = useRef(null);
+  const lastInvalidationRef = useRef(0);
+  const {
+    addPendingApproval,
+    removePendingApproval,
+    updatePendingApproval,
+    setPendingApprovals
+  } = useToolApprovalStore();
+  useEffect(() => {
+    if (!sessionId) {
+      console.log("[useSessionStream] No sessionId, skipping");
+      return;
+    }
+    assistantMessageIdRef.current = null;
+    let lastSessionInvalidation = 0;
+    apiClient.getPendingApprovals(sessionId).then((result) => {
+      if (result.ok && result.pending.length > 0) {
+        setPendingApprovals(result.pending);
+      } else {
+        setPendingApprovals([]);
+      }
+    }).catch(() => {
+      setPendingApprovals([]);
+    });
+    const client2 = new SSEClient;
+    clientRef.current = client2;
+    const url = apiClient.getStreamUrl(sessionId);
+    console.log("[useSessionStream] Connecting to stream:", url);
+    client2.connect(url);
+    const resolveAssistantTargetIndex = (messages) => {
+      if (assistantMessageIdRef.current) {
+        const byId = messages.findIndex((message) => message.id === assistantMessageIdRef.current);
+        if (byId !== -1)
+          return byId;
+      }
+      for (let i = messages.length - 1;i >= 0; i -= 1) {
+        const candidate = messages[i];
+        if (candidate.role === "assistant" && candidate.status !== "complete") {
+          return i;
+        }
+      }
+      return -1;
+    };
+    const extractText = (part) => {
+      if (part.contentJson && typeof part.contentJson === "object" && !Array.isArray(part.contentJson) && "text" in part.contentJson) {
+        return String(part.contentJson.text ?? "");
+      }
+      if (typeof part.content === "string") {
+        try {
+          const parsed = JSON.parse(part.content);
+          if (parsed && typeof parsed.text === "string")
+            return parsed.text;
+        } catch {}
+        return part.content;
+      }
+      return "";
+    };
+    const getOptimisticPartIndex = (parts, stepIndex) => {
+      if (typeof stepIndex !== "number") {
+        return parts.length;
+      }
+      const sameStepIndexes = parts.filter((part) => part.stepIndex === stepIndex).map((part) => part.index).filter((index) => Number.isFinite(index));
+      if (sameStepIndexes.length > 0) {
+        return Math.max(...sameStepIndexes) + 0.001;
+      }
+      const previousStepIndexes = parts.filter((part) => typeof part.stepIndex === "number" && part.stepIndex < stepIndex).map((part) => part.index).filter((index) => Number.isFinite(index));
+      const nextStepIndexes = parts.filter((part) => typeof part.stepIndex === "number" && part.stepIndex > stepIndex).map((part) => part.index).filter((index) => Number.isFinite(index));
+      const lowerBound = previousStepIndexes.length > 0 ? Math.max(...previousStepIndexes) : null;
+      const upperBound = nextStepIndexes.length > 0 ? Math.min(...nextStepIndexes) : null;
+      if (lowerBound !== null && upperBound !== null) {
+        return (lowerBound + upperBound) / 2;
+      }
+      if (lowerBound !== null) {
+        return lowerBound + 1;
+      }
+      if (upperBound !== null) {
+        return upperBound - 1;
+      }
+      return parts.length;
+    };
+    const applyReasoningDelta = (payload) => {
+      const messageId = typeof payload?.messageId === "string" ? payload.messageId : null;
+      const partId = typeof payload?.partId === "string" ? payload.partId : null;
+      const delta = typeof payload?.delta === "string" ? payload.delta : null;
+      if (!messageId || !partId || delta === null)
+        return;
+      queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
+        if (!oldMessages)
+          return oldMessages;
+        const nextMessages = [...oldMessages];
+        const messageIndex = nextMessages.findIndex((message) => message.id === messageId);
+        if (messageIndex === -1)
+          return oldMessages;
+        const targetMessage = nextMessages[messageIndex];
+        const parts = targetMessage.parts ? [...targetMessage.parts] : [];
+        let partIndex = parts.findIndex((part) => part.id === partId);
+        const stepIndex = typeof payload?.stepIndex === "number" ? payload.stepIndex : null;
+        if (partIndex === -1) {
+          const newPart = {
+            id: partId,
+            messageId,
+            index: getOptimisticPartIndex(parts, stepIndex),
+            stepIndex,
+            type: "reasoning",
+            content: JSON.stringify({ text: delta }),
+            contentJson: { text: delta },
+            agent: targetMessage.agent,
+            provider: targetMessage.provider,
+            model: targetMessage.model,
+            startedAt: Date.now(),
+            completedAt: null,
+            toolName: null,
+            toolCallId: null,
+            toolDurationMs: null
+          };
+          parts.push(newPart);
+          partIndex = parts.length - 1;
+        } else {
+          const existing = parts[partIndex];
+          const previous = extractText(existing);
+          const nextText = `${previous}${delta}`;
+          parts[partIndex] = {
+            ...existing,
+            content: JSON.stringify({ text: nextText }),
+            contentJson: { text: nextText },
+            stepIndex: stepIndex ?? existing.stepIndex ?? null,
+            completedAt: null
+          };
+        }
+        nextMessages[messageIndex] = { ...targetMessage, parts };
+        return nextMessages;
+      });
+    };
+    const applyMessageDelta = (payload) => {
+      const messageId = typeof payload?.messageId === "string" ? payload.messageId : null;
+      const partId = typeof payload?.partId === "string" ? payload.partId : null;
+      const delta = typeof payload?.delta === "string" ? payload.delta : null;
+      if (!messageId || !partId || delta === null)
+        return;
+      queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
+        if (!oldMessages)
+          return oldMessages;
+        const nextMessages = [...oldMessages];
+        const messageIndex = nextMessages.findIndex((message) => message.id === messageId);
+        if (messageIndex === -1)
+          return oldMessages;
+        const targetMessage = nextMessages[messageIndex];
+        const parts = targetMessage.parts ? [...targetMessage.parts] : [];
+        let partIndex = parts.findIndex((part) => part.id === partId);
+        const stepIndex = typeof payload?.stepIndex === "number" ? payload.stepIndex : null;
+        if (partIndex === -1) {
+          const newPart = {
+            id: partId,
+            messageId,
+            index: getOptimisticPartIndex(parts, stepIndex),
+            stepIndex,
+            type: "text",
+            content: JSON.stringify({ text: delta }),
+            contentJson: { text: delta },
+            agent: targetMessage.agent,
+            provider: targetMessage.provider,
+            model: targetMessage.model,
+            startedAt: Date.now(),
+            completedAt: null,
+            toolName: null,
+            toolCallId: null,
+            toolDurationMs: null
+          };
+          parts.push(newPart);
+          partIndex = parts.length - 1;
+        } else {
+          const existing = parts[partIndex];
+          const previous = extractText(existing);
+          const nextText = `${previous}${delta}`;
+          parts[partIndex] = {
+            ...existing,
+            content: JSON.stringify({ text: nextText }),
+            contentJson: { text: nextText },
+            stepIndex: stepIndex ?? existing.stepIndex ?? null,
+            completedAt: null
+          };
+        }
+        nextMessages[messageIndex] = { ...targetMessage, parts };
+        return nextMessages;
+      });
+    };
+    const upsertEphemeralToolCall = (payload) => {
+      if (!payload)
+        return;
+      const callId = typeof payload.callId === "string" ? payload.callId : null;
+      const name = typeof payload.name === "string" ? payload.name : null;
+      if (!name)
+        return;
+      queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
+        if (!oldMessages)
+          return oldMessages;
+        const nextMessages = [...oldMessages];
+        let targetIndex = resolveAssistantTargetIndex(nextMessages);
+        if (typeof payload.messageId === "string") {
+          const explicitIndex = nextMessages.findIndex((message) => message.id === payload.messageId);
+          if (explicitIndex !== -1)
+            targetIndex = explicitIndex;
+        }
+        if (targetIndex === -1)
+          return oldMessages;
+        const targetMessage = nextMessages[targetIndex];
+        const parts = targetMessage.parts ? [...targetMessage.parts] : [];
+        let partIndex = -1;
+        if (callId) {
+          partIndex = parts.findIndex((part) => part.toolCallId === callId && part.ephemeral);
+        }
+        if (partIndex === -1 && !callId) {
+          partIndex = parts.findIndex((part) => part.ephemeral && part.toolName === name);
+        }
+        const args = payload.args;
+        const stepIndex = typeof payload.stepIndex === "number" ? payload.stepIndex : null;
+        const contentJsonBase = { name };
+        if (callId)
+          contentJsonBase.callId = callId;
+        if (args !== undefined)
+          contentJsonBase.args = args;
+        if (partIndex === -1) {
+          const newPart = {
+            id: callId ? `ephemeral-tool-call-${callId}` : `ephemeral-tool-call-${name}-${Date.now()}`,
+            messageId: targetMessage.id,
+            index: getOptimisticPartIndex(parts, stepIndex),
+            stepIndex,
+            type: "tool_call",
+            content: JSON.stringify(contentJsonBase),
+            contentJson: contentJsonBase,
+            agent: targetMessage.agent,
+            provider: targetMessage.provider,
+            model: targetMessage.model,
+            startedAt: Date.now(),
+            completedAt: null,
+            toolName: name,
+            toolCallId: callId,
+            toolDurationMs: null,
+            ephemeral: true
+          };
+          parts.push(newPart);
+        } else {
+          const existing = parts[partIndex];
+          const nextContentJson = {
+            ...typeof existing.contentJson === "object" && !Array.isArray(existing.contentJson) ? existing.contentJson : {},
+            name
+          };
+          if (callId)
+            nextContentJson.callId = callId;
+          if (args !== undefined)
+            nextContentJson.args = args;
+          parts[partIndex] = {
+            ...existing,
+            content: JSON.stringify(nextContentJson),
+            contentJson: nextContentJson,
+            stepIndex: stepIndex ?? existing.stepIndex ?? null,
+            toolCallId: callId ?? existing.toolCallId,
+            toolName: name
+          };
+        }
+        nextMessages[targetIndex] = { ...targetMessage, parts };
+        return nextMessages;
+      });
+    };
+    const resolveEphemeralToolCall = (payload) => {
+      const callId = typeof payload?.callId === "string" ? payload.callId : null;
+      if (!callId)
+        return;
+      const payloadName = typeof payload?.name === "string" ? payload.name : null;
+      const payloadStepIndex = typeof payload?.stepIndex === "number" ? payload.stepIndex : null;
+      const payloadResult = payload?.result;
+      const payloadArtifact = payload?.artifact;
+      const payloadArgs = payload?.args;
+      queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
+        if (!oldMessages)
+          return oldMessages;
+        let changed = false;
+        const now = Date.now();
+        const nextMessages = oldMessages.map((message) => {
+          if (!message.parts?.length)
+            return message;
+          let messageChanged = false;
+          const updatedParts = message.parts.map((part) => {
+            if (!(part.ephemeral && part.toolCallId === callId)) {
+              return part;
+            }
+            messageChanged = true;
+            changed = true;
+            const nextContentJson = {
+              ...typeof part.contentJson === "object" && !Array.isArray(part.contentJson) ? part.contentJson : {},
+              name: payloadName ?? part.toolName ?? "tool",
+              callId
+            };
+            if (payloadArgs !== undefined)
+              nextContentJson.args = payloadArgs;
+            if (payloadResult !== undefined)
+              nextContentJson.result = payloadResult;
+            if (payloadArtifact !== undefined)
+              nextContentJson.artifact = payloadArtifact;
+            const durationMs = part.startedAt && Number.isFinite(part.startedAt) ? Math.max(0, now - part.startedAt) : part.toolDurationMs;
+            const resolvedPart = {
+              ...part,
+              type: "tool_result",
+              content: JSON.stringify(nextContentJson),
+              contentJson: nextContentJson,
+              stepIndex: payloadStepIndex ?? part.stepIndex ?? null,
+              completedAt: now,
+              toolName: payloadName ?? part.toolName,
+              toolDurationMs: durationMs ?? null
+            };
+            return resolvedPart;
+          });
+          if (!messageChanged)
+            return message;
+          return { ...message, parts: updatedParts };
+        });
+        return changed ? nextMessages : oldMessages;
+      });
+    };
+    const removeEphemeralToolCall = (payload) => {
+      const callId = typeof payload?.callId === "string" ? payload.callId : null;
+      if (!callId)
+        return;
+      queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
+        if (!oldMessages)
+          return oldMessages;
+        let changed = false;
+        const nextMessages = oldMessages.map((message) => {
+          if (!message.parts?.length)
+            return message;
+          const filtered = message.parts.filter((part) => !(part.ephemeral && part.toolCallId === callId));
+          if (filtered.length === message.parts.length)
+            return message;
+          changed = true;
+          return { ...message, parts: filtered };
+        });
+        return changed ? nextMessages : oldMessages;
+      });
+    };
+    const clearEphemeralForMessage = (messageId) => {
+      if (!messageId)
+        return;
+      queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
+        if (!oldMessages)
+          return oldMessages;
+        const targetIndex = oldMessages.findIndex((message) => message.id === messageId);
+        if (targetIndex === -1)
+          return oldMessages;
+        const target = oldMessages[targetIndex];
+        if (!target.parts?.some((part) => part.ephemeral && part.type === "tool_call"))
+          return oldMessages;
+        const nextMessages = [...oldMessages];
+        nextMessages[targetIndex] = {
+          ...target,
+          parts: target.parts?.filter((part) => !(part.ephemeral && part.type === "tool_call")) ?? []
+        };
+        return nextMessages;
+      });
+    };
+    const markMessageCompleted = (payload) => {
+      const id = typeof payload?.id === "string" ? payload.id : null;
+      if (!id)
+        return;
+      queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
+        if (!oldMessages)
+          return oldMessages;
+        const nextMessages = [...oldMessages];
+        const messageIndex = nextMessages.findIndex((message) => message.id === id);
+        if (messageIndex === -1)
+          return oldMessages;
+        const existing = nextMessages[messageIndex];
+        nextMessages[messageIndex] = {
+          ...existing,
+          status: "complete",
+          completedAt: Date.now()
+        };
+        return nextMessages;
+      });
+    };
+    const throttledInvalidate = () => {
+      const now = Date.now();
+      if (now - lastInvalidationRef.current < 500) {
+        return;
+      }
+      lastInvalidationRef.current = now;
+      queryClient.invalidateQueries({ queryKey: ["messages", sessionId] });
+    };
+    const invalidatingEvents = new Set([
+      "message.completed",
+      "message.updated",
+      "finish-step",
+      "error"
+    ]);
+    const unsubscribe = client2.on("*", (event) => {
+      const payload = event.payload;
+      switch (event.type) {
+        case "message.created": {
+          const role = typeof payload?.role === "string" ? payload.role : null;
+          const id = typeof payload?.id === "string" ? payload.id : null;
+          if (role === "assistant" && id) {
+            assistantMessageIdRef.current = id;
+          }
+          if (id && role) {
+            const agent = typeof payload?.agent === "string" ? payload.agent : "";
+            const provider = typeof payload?.provider === "string" ? payload.provider : "";
+            const model = typeof payload?.model === "string" ? payload.model : "";
+            queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
+              if (!oldMessages)
+                return oldMessages;
+              if (oldMessages.some((m) => m.id === id))
+                return oldMessages;
+              const newMessage = {
+                id,
+                sessionId,
+                role,
+                status: "pending",
+                agent,
+                provider,
+                model,
+                createdAt: Date.now(),
+                completedAt: null,
+                latencyMs: null,
+                promptTokens: null,
+                completionTokens: null,
+                totalTokens: null,
+                error: null,
+                parts: []
+              };
+              const next = [...oldMessages, newMessage];
+              next.sort((a, b) => a.createdAt - b.createdAt);
+              return next;
+            });
+            throttledInvalidate();
+          }
+          break;
+        }
+        case "message.part.delta": {
+          applyMessageDelta(payload);
+          break;
+        }
+        case "reasoning.delta": {
+          applyReasoningDelta(payload);
+          break;
+        }
+        case "message.completed": {
+          const id = typeof payload?.id === "string" ? payload.id : null;
+          if (id && assistantMessageIdRef.current === id) {
+            assistantMessageIdRef.current = null;
+          }
+          markMessageCompleted(payload);
+          clearEphemeralForMessage(id);
+          queryClient.invalidateQueries({ queryKey: sessionsQueryKey });
+          break;
+        }
+        case "tool.delta": {
+          const channel = typeof payload?.channel === "string" ? payload.channel : null;
+          if (channel === "input") {
+            upsertEphemeralToolCall(payload);
+          }
+          break;
+        }
+        case "tool.call": {
+          upsertEphemeralToolCall(payload);
+          break;
+        }
+        case "tool.result": {
+          resolveEphemeralToolCall(payload);
+          break;
+        }
+        case "tool.approval.required": {
+          const callId = typeof payload?.callId === "string" ? payload.callId : null;
+          const toolName = typeof payload?.toolName === "string" ? payload.toolName : null;
+          const messageId = typeof payload?.messageId === "string" ? payload.messageId : null;
+          const args = payload?.args;
+          if (callId && toolName && messageId) {
+            addPendingApproval({
+              callId,
+              toolName,
+              args,
+              messageId,
+              createdAt: Date.now()
+            });
+          }
+          break;
+        }
+        case "tool.approval.resolved": {
+          const callId = typeof payload?.callId === "string" ? payload.callId : null;
+          if (callId) {
+            removePendingApproval(callId);
+          }
+          break;
+        }
+        case "tool.approval.updated": {
+          const callId = typeof payload?.callId === "string" ? payload.callId : null;
+          const args = payload?.args;
+          if (callId) {
+            updatePendingApproval(callId, args);
+          }
+          break;
+        }
+        case "error": {
+          removeEphemeralToolCall(payload);
+          const messageId = typeof payload?.messageId === "string" ? payload.messageId : null;
+          if (messageId) {
+            clearEphemeralForMessage(messageId);
+          }
+          break;
+        }
+        case "message.updated": {
+          const id = typeof payload?.id === "string" ? payload.id : null;
+          const status = typeof payload?.status === "string" ? payload.status : null;
+          if (id && status) {
+            queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
+              if (!oldMessages)
+                return oldMessages;
+              const idx = oldMessages.findIndex((m) => m.id === id);
+              if (idx === -1)
+                return oldMessages;
+              const next = [...oldMessages];
+              next[idx] = {
+                ...next[idx],
+                status
+              };
+              return next;
+            });
+          }
+          break;
+        }
+        case "queue.updated": {
+          const queueState = {
+            currentMessageId: payload?.currentMessageId,
+            queuedMessages: payload?.queuedMessages ?? [],
+            queueLength: payload?.queueLength ?? 0
+          };
+          queryClient.setQueryData(["queueState", sessionId], queueState);
+          break;
+        }
+        default:
+          break;
+      }
+      if (invalidatingEvents.has(event.type)) {
+        throttledInvalidate();
+      }
+      if (event.type === "finish-step") {
+        const now = Date.now();
+        if (now - lastSessionInvalidation >= 2000) {
+          lastSessionInvalidation = now;
+          queryClient.invalidateQueries({ queryKey: sessionsQueryKey });
+        }
+      }
+    });
+    return () => {
+      unsubscribe();
+      client2.disconnect();
+    };
+  }, [
+    sessionId,
+    queryClient,
+    addPendingApproval,
+    removePendingApproval,
+    setPendingApprovals,
+    updatePendingApproval
+  ]);
+}
+// src/hooks/useTheme.ts
+import { useEffect as useEffect2, 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";
+}
+function useTheme() {
+  const [theme, setTheme] = useState(() => resolveInitialTheme());
+  useEffect2(() => {
+    if (typeof document === "undefined")
+      return;
+    const root = document.documentElement;
+    if (theme === "dark") {
+      root.classList.add("dark");
+    } 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]);
+  useEffect2(() => {
+    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 toggleTheme = useCallback2(() => {
+    setTheme((prev) => prev === "dark" ? "light" : "dark");
+  }, []);
+  return useMemo3(() => ({ theme, setTheme, toggleTheme }), [theme, toggleTheme]);
+}
+// src/hooks/useWorkingDirectory.ts
+import { useEffect as useEffect3, useState as useState2 } from "react";
+function useWorkingDirectory() {
+  const [dirName, setDirName] = useState2(null);
+  useEffect3(() => {
+    const fetchWorkingDirectory = async () => {
+      try {
+        const win = window;
+        const baseUrl = win.OTTO_SERVER_URL || API_BASE_URL;
+        const url = `${baseUrl}/v1/config/cwd`;
+        console.log("[useWorkingDirectory] Fetching from:", url);
+        const response = await fetch(url);
+        if (!response.ok) {
+          console.error("[useWorkingDirectory] Failed:", response.status, response.statusText);
+          throw new Error(`Failed to fetch working directory: ${response.status}`);
+        }
+        const data = await response.json();
+        console.log("[useWorkingDirectory] Success:", data);
+        if (data.dirName) {
+          console.log("[useWorkingDirectory] Setting title to:", data.dirName);
+          setDirName(data.dirName);
+          document.title = data.dirName;
+        }
+      } catch (error) {
+        console.error("[useWorkingDirectory] Error:", error);
+        document.title = "otto";
+      }
+    };
+    fetchWorkingDirectory();
+  }, []);
+  return dirName;
+}
+// src/hooks/useKeyboardShortcuts.ts
+import { useEffect as useEffect4, useCallback as useCallback3 } from "react";
+
+// src/stores/focusStore.ts
+import { create as create10 } from "zustand";
+var useFocusStore = create10((set) => ({
+  currentFocus: null,
+  sessionIndex: 0,
+  gitFileIndex: 0,
+  setFocus: (area) => set({ currentFocus: area }),
+  setSessionIndex: (index) => set({ sessionIndex: index }),
+  setGitFileIndex: (index) => set({ gitFileIndex: index }),
+  resetGitFileIndex: () => set({ gitFileIndex: 0 }),
+  resetSessionIndex: () => set({ sessionIndex: 0 })
+}));
+
+// src/stores/sidebarStore.ts
+import { create as create11 } from "zustand";
+import { persist } from "zustand/middleware";
+var useSidebarStore = create11()(persist((set) => ({
+  isCollapsed: false,
+  toggleCollapse: () => set((state) => ({ isCollapsed: !state.isCollapsed })),
+  setCollapsed: (collapsed) => set({ isCollapsed: collapsed })
+}), {
+  name: "sidebar-storage"
+}));
+
+// src/stores/filePickerStore.ts
+import { create as create12 } from "zustand";
+var useFilePickerStore = create12((set) => ({
+  isOpen: false,
+  open: () => set({ isOpen: true }),
+  close: () => set({ isOpen: false }),
+  toggle: () => set((state) => ({ isOpen: !state.isOpen }))
+}));
+
+// src/hooks/useKeyboardShortcuts.ts
+function useKeyboardShortcuts({
+  sessionIds,
+  activeSessionId,
+  gitFiles,
+  onSelectSession,
+  onNewSession,
+  onStageFile,
+  onUnstageFile,
+  onRestoreFile,
+  onDeleteFile,
+  onStageAll,
+  onUnstageAll,
+  onOpenCommitModal,
+  onViewDiff,
+  onReturnToInput
+}) {
+  const {
+    currentFocus,
+    sessionIndex,
+    gitFileIndex,
+    setFocus,
+    setSessionIndex,
+    setGitFileIndex,
+    resetGitFileIndex
+  } = useFocusStore();
+  const {
+    setCollapsed: setSessionListCollapsed,
+    toggleCollapse: toggleSessionList
+  } = useSidebarStore();
+  const { isExpanded: isGitExpanded, toggleSidebar: toggleGit } = useGitStore();
+  const closeDiff = useGitStore((state) => state.closeDiff);
+  const toggleResearch = useResearchStore((state) => state.toggleSidebar);
+  const currentSessionIndex = sessionIds.indexOf(activeSessionId || "");
+  const handleKeyDown = useCallback3((e) => {
+    const target = e.target;
+    const isInInput = target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable;
+    const isInTerminal = !!target.closest("[data-terminal-viewer]");
+    if ((e.ctrlKey || e.metaKey) && e.key === "h") {
+      e.preventDefault();
+      if (currentFocus === "sessions") {
+        document.activeElement?.blur();
+        setFocus("input");
+        setSessionListCollapsed(true);
+        setTimeout(() => onReturnToInput?.(), 50);
+      } else if (currentFocus === "git") {
+        document.activeElement?.blur();
+        setFocus("input");
+        toggleGit();
+        closeDiff();
+        setTimeout(() => onReturnToInput?.(), 50);
+      } else {
+        document.activeElement?.blur();
+        setFocus("sessions");
+        setSessionListCollapsed(false);
+        if (currentSessionIndex >= 0) {
+          setSessionIndex(currentSessionIndex);
+        }
+      }
+      return;
+    }
+    if ((e.ctrlKey || e.metaKey) && e.key === "l") {
+      e.preventDefault();
+      if (currentFocus === "git") {
+        document.activeElement?.blur();
+        setFocus("input");
+        toggleGit();
+        closeDiff();
+        setTimeout(() => onReturnToInput?.(), 50);
+      } else if (currentFocus === "sessions") {
+        document.activeElement?.blur();
+        setFocus("input");
+        setSessionListCollapsed(true);
+        setTimeout(() => onReturnToInput?.(), 50);
+      } else {
+        document.activeElement?.blur();
+        if (!isGitExpanded) {
+          toggleGit();
+        }
+        setFocus("git");
+        resetGitFileIndex();
+      }
+      return;
+    }
+    if ((e.ctrlKey || e.metaKey) && e.key === "/") {
+      e.preventDefault();
+      toggleSessionList();
+      return;
+    }
+    if ((e.ctrlKey || e.metaKey) && e.key === "\\") {
+      e.preventDefault();
+      toggleGit();
+      return;
+    }
+    if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key === "r") {
+      e.preventDefault();
+      toggleResearch();
+      return;
+    }
+    if ((e.ctrlKey || e.metaKey) && e.key === "n") {
+      e.preventDefault();
+      onNewSession();
+      return;
+    }
+    if ((e.ctrlKey || e.metaKey) && e.key === "p") {
+      e.preventDefault();
+      useFilePickerStore.getState().toggle();
+      return;
+    }
+    if (e.key === "Escape" && !isInTerminal || e.key === "q" && !isInInput && (currentFocus === "sessions" || currentFocus === "git")) {
+      e.preventDefault();
+      if (currentFocus === "sessions") {
+        setSessionListCollapsed(true);
+      } else if (currentFocus === "git") {
+        toggleGit();
+        closeDiff();
+      }
+      setFocus("input");
+      onReturnToInput?.();
+      return;
+    }
+    if (currentFocus === "sessions" && !isInInput) {
+      if (e.key === "j" && sessionIds.length > 0) {
+        e.preventDefault();
+        const nextIndex = Math.min(sessionIndex + 1, sessionIds.length - 1);
+        setSessionIndex(nextIndex);
+        return;
+      }
+      if (e.key === "k" && sessionIds.length > 0) {
+        e.preventDefault();
+        const prevIndex = Math.max(sessionIndex - 1, 0);
+        setSessionIndex(prevIndex);
+        return;
+      }
+      if (e.key === "Enter" && sessionIds[sessionIndex]) {
+        e.preventDefault();
+        onSelectSession(sessionIds[sessionIndex]);
+        setFocus("input");
+        return;
+      }
+    }
+    if (currentFocus === "git" && !isInInput) {
+      if (e.key === "j" && gitFiles.length > 0) {
+        e.preventDefault();
+        const nextIndex = Math.min(gitFileIndex + 1, gitFiles.length - 1);
+        setGitFileIndex(nextIndex);
+        return;
+      }
+      if (e.key === "k" && gitFiles.length > 0) {
+        e.preventDefault();
+        const prevIndex = Math.max(gitFileIndex - 1, 0);
+        setGitFileIndex(prevIndex);
+        return;
+      }
+      if (e.key === " " && gitFiles[gitFileIndex]) {
+        e.preventDefault();
+        const file = gitFiles[gitFileIndex];
+        if (file.staged) {
+          onUnstageFile?.(file.path);
+        } else {
+          onStageFile?.(file.path);
+        }
+        return;
+      }
+      if (e.key === "a") {
+        e.preventDefault();
+        onStageAll?.();
+        return;
+      }
+      if (e.key === "u") {
+        e.preventDefault();
+        onUnstageAll?.();
+        return;
+      }
+      if (e.key === "R" && gitFiles[gitFileIndex]) {
+        e.preventDefault();
+        const file = gitFiles[gitFileIndex];
+        const canRestore = !file.staged && file.status !== "untracked" && file.status !== "added";
+        if (canRestore) {
+          onRestoreFile?.(file.path);
+        }
+        return;
+      }
+      if (e.shiftKey && e.key === "D" || e.key === "Backspace") {
+        e.preventDefault();
+        const file = gitFiles[gitFileIndex];
+        if (file && !file.staged && file.status === "untracked") {
+          onDeleteFile?.(file.path);
+        }
+        return;
+      }
+      if (e.key === "c") {
+        e.preventDefault();
+        onOpenCommitModal?.();
+        return;
+      }
+      if (e.key === "Enter" && gitFiles[gitFileIndex]) {
+        e.preventDefault();
+        const file = gitFiles[gitFileIndex];
+        onViewDiff?.(file.path, file.staged);
+        return;
+      }
+    }
+  }, [
+    currentFocus,
+    sessionIndex,
+    gitFileIndex,
+    sessionIds,
+    gitFiles,
+    currentSessionIndex,
+    isGitExpanded,
+    setFocus,
+    setSessionIndex,
+    setGitFileIndex,
+    resetGitFileIndex,
+    setSessionListCollapsed,
+    toggleGit,
+    toggleResearch,
+    toggleSessionList,
+    onSelectSession,
+    onNewSession,
+    onStageFile,
+    onUnstageFile,
+    onRestoreFile,
+    onDeleteFile,
+    onStageAll,
+    onUnstageAll,
+    onOpenCommitModal,
+    onViewDiff,
+    onReturnToInput,
+    closeDiff
+  ]);
+  useEffect4(() => {
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [handleKeyDown]);
+  return {
+    currentFocus,
+    sessionIndex,
+    gitFileIndex
+  };
+}
+// src/hooks/useImageUpload.ts
+import {
+  useState as useState3,
+  useCallback as useCallback4,
+  useEffect as useEffect5
+} from "react";
+var SUPPORTED_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+function generateId() {
+  return `img-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+async function fileToBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader;
+    reader.onload = () => {
+      const result = reader.result;
+      const base64 = result.split(",")[1];
+      resolve(base64);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+  });
+}
+async function fileToPreview(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader;
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = reject;
+    reader.readAsDataURL(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 maxSizeBytes = maxSizeMB * 1024 * 1024;
+  const validateFile = useCallback4((file) => {
+    if (!SUPPORTED_TYPES.includes(file.type)) {
+      return `Unsupported file type: ${file.type}. Supported: PNG, JPEG, GIF, WebP`;
+    }
+    if (file.size > maxSizeBytes) {
+      return `File too large: ${(file.size / 1024 / 1024).toFixed(1)}MB. Max: ${maxSizeMB}MB`;
+    }
+    return null;
+  }, [maxSizeBytes, maxSizeMB]);
+  const addImages = useCallback4(async (files) => {
+    setError(null);
+    const fileArray = Array.from(files);
+    const remaining = maxImages - images.length;
+    if (remaining <= 0) {
+      setError(`Maximum ${maxImages} images allowed`);
+      return;
+    }
+    const filesToAdd = fileArray.slice(0, remaining);
+    const newImages = [];
+    for (const file of filesToAdd) {
+      const validationError = validateFile(file);
+      if (validationError) {
+        setError(validationError);
+        continue;
+      }
+      try {
+        const [preview, data] = await Promise.all([
+          fileToPreview(file),
+          fileToBase64(file)
+        ]);
+        newImages.push({
+          id: generateId(),
+          file,
+          preview,
+          data,
+          mediaType: file.type
+        });
+      } catch {
+        setError("Failed to process image");
+      }
+    }
+    if (newImages.length > 0) {
+      setImages((prev) => [...prev, ...newImages]);
+    }
+  }, [images.length, maxImages, validateFile]);
+  const removeImage = useCallback4((id) => {
+    setImages((prev) => prev.filter((img) => img.id !== id));
+    setError(null);
+  }, []);
+  const clearImages = useCallback4(() => {
+    setImages([]);
+    setError(null);
+  }, []);
+  const handleDragEnter = useCallback4((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (e.dataTransfer.types.includes("Files")) {
+      setIsDragging(true);
+    }
+  }, []);
+  const handleDragLeave = useCallback4((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    const rect = e.currentTarget.getBoundingClientRect();
+    const x = e.clientX;
+    const y = e.clientY;
+    if (x < rect.left || x > rect.right || y < rect.top || y > rect.bottom) {
+      setIsDragging(false);
+    }
+  }, []);
+  const handleDragOver = useCallback4((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+  }, []);
+  const handleDrop = useCallback4((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsDragging(false);
+    const files = e.dataTransfer.files;
+    if (files.length > 0) {
+      const imageFiles = Array.from(files).filter((f) => f.type.startsWith("image/"));
+      if (imageFiles.length > 0) {
+        addImages(imageFiles);
+      }
+    }
+  }, [addImages]);
+  const handlePaste = useCallback4((e) => {
+    const items = e.clipboardData?.items;
+    if (!items)
+      return;
+    const imageFiles = [];
+    for (const item of Array.from(items)) {
+      if (item.type.startsWith("image/")) {
+        const file = item.getAsFile();
+        if (file) {
+          imageFiles.push(file);
+        }
+      }
+    }
+    if (imageFiles.length > 0) {
+      e.preventDefault();
+      addImages(imageFiles);
+    }
+  }, [addImages]);
+  useEffect5(() => {
+    if (!pageWide)
+      return;
+    let dragCounter = 0;
+    const onDragEnter = (e) => {
+      e.preventDefault();
+      if (e.dataTransfer?.types.includes("Files")) {
+        dragCounter++;
+        if (dragCounter === 1) {
+          setIsDragging(true);
+        }
+      }
+    };
+    const onDragLeave = (e) => {
+      e.preventDefault();
+      dragCounter--;
+      if (dragCounter === 0) {
+        setIsDragging(false);
+      }
+    };
+    const onDragOver = (e) => {
+      e.preventDefault();
+    };
+    const onDrop = (e) => {
+      e.preventDefault();
+      dragCounter = 0;
+      setIsDragging(false);
+      const files = e.dataTransfer?.files;
+      if (files && files.length > 0) {
+        const imageFiles = Array.from(files).filter((f) => f.type.startsWith("image/"));
+        if (imageFiles.length > 0) {
+          addImages(imageFiles);
+        }
+      }
+    };
+    document.addEventListener("dragenter", onDragEnter);
+    document.addEventListener("dragleave", onDragLeave);
+    document.addEventListener("dragover", onDragOver);
+    document.addEventListener("drop", onDrop);
+    return () => {
+      document.removeEventListener("dragenter", onDragEnter);
+      document.removeEventListener("dragleave", onDragLeave);
+      document.removeEventListener("dragover", onDragOver);
+      document.removeEventListener("drop", onDrop);
+    };
+  }, [pageWide, addImages]);
+  return {
+    images,
+    isDragging,
+    error,
+    addImages,
+    removeImage,
+    clearImages,
+    handleDragEnter,
+    handleDragLeave,
+    handleDragOver,
+    handleDrop,
+    handlePaste
+  };
+}
+// src/hooks/useFileUpload.ts
+import {
+  useState as useState4,
+  useCallback as useCallback5,
+  useEffect as useEffect6
+} from "react";
+var IMAGE_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+var PDF_TYPES = ["application/pdf"];
+var TEXT_TYPES = [
+  "text/plain",
+  "text/markdown",
+  "text/x-markdown",
+  "application/json",
+  "text/csv",
+  "text/xml",
+  "application/xml",
+  "text/yaml",
+  "text/x-yaml",
+  "application/x-yaml",
+  "text/html",
+  "text/css",
+  "text/javascript",
+  "application/javascript",
+  "application/typescript"
+];
+var TEXT_EXTENSIONS = [
+  ".txt",
+  ".md",
+  ".markdown",
+  ".json",
+  ".csv",
+  ".xml",
+  ".yaml",
+  ".yml",
+  ".html",
+  ".css",
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".py",
+  ".rs",
+  ".go",
+  ".java",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".rb",
+  ".php",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".toml",
+  ".ini",
+  ".cfg",
+  ".env",
+  ".log",
+  ".sql",
+  ".graphql",
+  ".svelte",
+  ".vue"
+];
+var SUPPORTED_TYPES2 = [...IMAGE_TYPES, ...PDF_TYPES, ...TEXT_TYPES];
+function generateId2() {
+  return `file-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function getFileType(file) {
+  if (IMAGE_TYPES.includes(file.type))
+    return "image";
+  if (PDF_TYPES.includes(file.type))
+    return "pdf";
+  if (TEXT_TYPES.includes(file.type))
+    return "text";
+  const ext = file.name.toLowerCase().slice(file.name.lastIndexOf("."));
+  if (TEXT_EXTENSIONS.includes(ext))
+    return "text";
+  return null;
+}
+function isSupported(file) {
+  if (SUPPORTED_TYPES2.includes(file.type))
+    return true;
+  const ext = file.name.toLowerCase().slice(file.name.lastIndexOf("."));
+  return TEXT_EXTENSIONS.includes(ext);
+}
+async function fileToBase642(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader;
+    reader.onload = () => {
+      const result = reader.result;
+      const base64 = result.split(",")[1];
+      resolve(base64);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+  });
+}
+async function fileToText(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader;
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = reject;
+    reader.readAsText(file);
+  });
+}
+async function fileToPreview2(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader;
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+  });
+}
+function useFileUpload(options = {}) {
+  const {
+    maxFiles = 10,
+    maxSizeMB = 10,
+    pageWide = true,
+    supportsImages = true,
+    supportsFileAttachments = true,
+    onError
+  } = options;
+  const [files, setFiles] = useState4([]);
+  const [isDragging, setIsDragging] = useState4(false);
+  const [error, setError] = useState4(null);
+  const maxSizeBytes = maxSizeMB * 1024 * 1024;
+  const validateFile = useCallback5((file) => {
+    if (!supportsImages && IMAGE_TYPES.includes(file.type)) {
+      return "This model does not support image attachments";
+    }
+    if (!supportsFileAttachments && PDF_TYPES.includes(file.type)) {
+      return "This model does not support PDF attachments";
+    }
+    if (!isSupported(file)) {
+      const ext = file.name.slice(file.name.lastIndexOf("."));
+      return `Unsupported file type: ${ext || file.type || "unknown"}`;
+    }
+    if (file.size > maxSizeBytes) {
+      return `File too large: ${(file.size / 1024 / 1024).toFixed(1)}MB. Max: ${maxSizeMB}MB`;
+    }
+    return null;
+  }, [maxSizeBytes, maxSizeMB, supportsImages, supportsFileAttachments]);
+  const addFiles = useCallback5(async (inputFiles) => {
+    setError(null);
+    const fileArray = Array.from(inputFiles);
+    const remaining = maxFiles - files.length;
+    if (remaining <= 0) {
+      const msg = `Maximum ${maxFiles} files allowed`;
+      setError(msg);
+      onError?.(msg);
+      return;
+    }
+    const filesToAdd = fileArray.slice(0, remaining);
+    const newFiles = [];
+    for (const file of filesToAdd) {
+      const validationError = validateFile(file);
+      if (validationError) {
+        setError(validationError);
+        onError?.(validationError);
+        continue;
+      }
+      const fileType = getFileType(file);
+      if (!fileType)
+        continue;
+      try {
+        let preview;
+        let data;
+        let textContent;
+        let mediaType = file.type;
+        if (fileType === "image") {
+          [preview, data] = await Promise.all([
+            fileToPreview2(file),
+            fileToBase642(file)
+          ]);
+        } else if (fileType === "pdf") {
+          data = await fileToBase642(file);
+          mediaType = "application/pdf";
+        } else {
+          textContent = await fileToText(file);
+          data = textContent;
+          if (!mediaType) {
+            const ext = file.name.toLowerCase();
+            mediaType = ext.endsWith(".md") || ext.endsWith(".markdown") ? "text/markdown" : "text/plain";
+          }
+        }
+        newFiles.push({
+          id: generateId2(),
+          file,
+          type: fileType,
+          name: file.name,
+          preview,
+          data,
+          mediaType,
+          textContent
+        });
+      } catch {
+        const msg = `Failed to process file: ${file.name}`;
+        setError(msg);
+        onError?.(msg);
+      }
+    }
+    if (newFiles.length > 0) {
+      setFiles((prev) => [...prev, ...newFiles]);
+    }
+  }, [files.length, maxFiles, validateFile, onError]);
+  const removeFile = useCallback5((id) => {
+    setFiles((prev) => prev.filter((f) => f.id !== id));
+    setError(null);
+  }, []);
+  const clearFiles = useCallback5(() => {
+    setFiles([]);
+    setError(null);
+  }, []);
+  const handleDragEnter = useCallback5((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (e.dataTransfer.types.includes("Files")) {
+      setIsDragging(true);
+    }
+  }, []);
+  const handleDragLeave = useCallback5((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    const rect = e.currentTarget.getBoundingClientRect();
+    const x = e.clientX;
+    const y = e.clientY;
+    if (x < rect.left || x > rect.right || y < rect.top || y > rect.bottom) {
+      setIsDragging(false);
+    }
+  }, []);
+  const handleDragOver = useCallback5((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+  }, []);
+  const handleDrop = useCallback5((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsDragging(false);
+    const droppedFiles = e.dataTransfer.files;
+    if (droppedFiles.length > 0) {
+      addFiles(Array.from(droppedFiles));
+    }
+  }, [addFiles]);
+  const handlePaste = useCallback5((e) => {
+    const items = e.clipboardData?.items;
+    if (!items)
+      return;
+    const pastedFiles = [];
+    for (const item of Array.from(items)) {
+      if (item.kind === "file") {
+        const file = item.getAsFile();
+        if (file) {
+          pastedFiles.push(file);
+        }
+      }
+    }
+    if (pastedFiles.length > 0) {
+      e.preventDefault();
+      addFiles(pastedFiles);
+    }
+  }, [addFiles]);
+  useEffect6(() => {
+    if (!pageWide)
+      return;
+    let dragCounter = 0;
+    const onDragEnter = (e) => {
+      e.preventDefault();
+      if (e.dataTransfer?.types.includes("Files")) {
+        dragCounter++;
+        if (dragCounter === 1) {
+          setIsDragging(true);
+        }
+      }
+    };
+    const onDragLeave = (e) => {
+      e.preventDefault();
+      dragCounter--;
+      if (dragCounter === 0) {
+        setIsDragging(false);
+      }
+    };
+    const onDragOver = (e) => {
+      e.preventDefault();
+    };
+    const onDrop = (e) => {
+      e.preventDefault();
+      dragCounter = 0;
+      setIsDragging(false);
+      const droppedFiles = e.dataTransfer?.files;
+      if (droppedFiles && droppedFiles.length > 0) {
+        addFiles(Array.from(droppedFiles));
+      }
+    };
+    document.addEventListener("dragenter", onDragEnter);
+    document.addEventListener("dragleave", onDragLeave);
+    document.addEventListener("dragover", onDragOver);
+    document.addEventListener("drop", onDrop);
+    return () => {
+      document.removeEventListener("dragenter", onDragEnter);
+      document.removeEventListener("dragleave", onDragLeave);
+      document.removeEventListener("dragover", onDragOver);
+      document.removeEventListener("drop", onDrop);
+    };
+  }, [pageWide, addFiles]);
+  const images = files.filter((f) => f.type === "image");
+  const documents = files.filter((f) => f.type === "pdf" || f.type === "text");
+  return {
+    files,
+    images,
+    documents,
+    isDragging,
+    error,
+    addFiles,
+    removeFile,
+    clearFiles,
+    handleDragEnter,
+    handleDragLeave,
+    handleDragOver,
+    handleDrop,
+    handlePaste
+  };
+}
+// src/hooks/useSessionFiles.ts
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+function useSessionFiles(sessionId) {
+  const isExpanded = useSessionFilesStore((state) => state.isExpanded);
+  return useQuery5({
+    queryKey: ["session", sessionId, "files"],
+    queryFn: () => sessionId ? apiClient.getSessionFiles(sessionId) : null,
+    enabled: !!sessionId,
+    refetchInterval: isExpanded ? 5000 : false,
+    retry: 1,
+    staleTime: 3000
+  });
+}
+// src/hooks/useQueueState.ts
+import { useQuery as useQuery6 } from "@tanstack/react-query";
+var defaultQueueState = {
+  currentMessageId: null,
+  queuedMessages: [],
+  queueLength: 0
+};
+function useQueueState(sessionId) {
+  const { data } = useQuery6({
+    queryKey: ["queueState", sessionId],
+    queryFn: () => defaultQueueState,
+    enabled: !!sessionId,
+    initialData: defaultQueueState,
+    staleTime: Infinity
+  });
+  return data ?? defaultQueueState;
+}
+function useMessageQueuePosition(sessionId, messageId) {
+  const queueState = useQueueState(sessionId);
+  if (!sessionId || !queueState) {
+    return { isQueued: false, isRunning: false, position: null };
+  }
+  if (queueState.currentMessageId === messageId) {
+    return { isQueued: false, isRunning: true, position: null };
+  }
+  const queuedItem = queueState.queuedMessages.find((item) => item.messageId === messageId);
+  if (queuedItem) {
+    return { isQueued: true, isRunning: false, position: queuedItem.position };
+  }
+  return { isQueued: false, isRunning: false, position: null };
+}
+// src/hooks/useBranch.ts
+import { useQuery as useQuery7, useMutation as useMutation5, useQueryClient as useQueryClient6 } from "@tanstack/react-query";
+function useCreateBranch(sessionId) {
+  const queryClient = useQueryClient6();
+  return useMutation5({
+    mutationFn: (data) => {
+      if (!sessionId)
+        throw new Error("No session ID");
+      return apiClient.createBranch(sessionId, data);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: sessionsQueryKey });
+      if (sessionId) {
+        queryClient.invalidateQueries({
+          queryKey: ["branches", sessionId]
+        });
+      }
+    }
+  });
+}
+function useBranches(sessionId) {
+  return useQuery7({
+    queryKey: ["branches", sessionId],
+    queryFn: () => {
+      if (!sessionId)
+        throw new Error("No session ID");
+      return apiClient.listBranches(sessionId);
+    },
+    enabled: Boolean(sessionId)
+  });
+}
+function useParentSession(sessionId) {
+  return useQuery7({
+    queryKey: ["parentSession", sessionId],
+    queryFn: () => {
+      if (!sessionId)
+        throw new Error("No session ID");
+      return apiClient.getParentSession(sessionId);
+    },
+    enabled: Boolean(sessionId)
+  });
+}
+// src/hooks/useResearch.ts
+import { useQuery as useQuery8, useMutation as useMutation6, useQueryClient as useQueryClient7 } from "@tanstack/react-query";
+
+// src/stores/pendingResearchStore.ts
+import { create as create13 } from "zustand";
+var usePendingResearchStore = create13((set, get) => ({
+  pendingContexts: new Map,
+  addContext: (parentSessionId, context) => {
+    set((state) => {
+      const newMap = new Map(state.pendingContexts);
+      const existing = newMap.get(parentSessionId) || [];
+      if (!existing.some((c) => c.id === context.id)) {
+        newMap.set(parentSessionId, [...existing, context]);
+      }
+      return { pendingContexts: newMap };
+    });
+  },
+  removeContext: (parentSessionId, contextId) => {
+    set((state) => {
+      const newMap = new Map(state.pendingContexts);
+      const existing = newMap.get(parentSessionId) || [];
+      newMap.set(parentSessionId, existing.filter((c) => c.id !== contextId));
+      return { pendingContexts: newMap };
+    });
+  },
+  getContexts: (parentSessionId) => {
+    return get().pendingContexts.get(parentSessionId) || [];
+  },
+  clearContexts: (parentSessionId) => {
+    set((state) => {
+      const newMap = new Map(state.pendingContexts);
+      newMap.delete(parentSessionId);
+      return { pendingContexts: newMap };
+    });
+  },
+  consumeContexts: (parentSessionId) => {
+    const contexts = get().getContexts(parentSessionId);
+    get().clearContexts(parentSessionId);
+    return contexts;
+  }
+}));
+
+// src/hooks/useResearch.ts
+class ResearchApiClient {
+  get baseUrl() {
+    const win = window;
+    if (win.OTTO_SERVER_URL) {
+      return win.OTTO_SERVER_URL;
+    }
+    if (import.meta.env?.VITE_API_BASE_URL) {
+      return import.meta.env.VITE_API_BASE_URL;
+    }
+    return API_BASE_URL;
+  }
+  async listResearchSessions(parentSessionId) {
+    const response = await fetch(`${this.baseUrl}/v1/sessions/${parentSessionId}/research`, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to fetch research sessions" }));
+      throw new Error(error.error || "Failed to fetch research sessions");
+    }
+    return response.json();
+  }
+  async createResearchSession(parentSessionId, data) {
+    const response = await fetch(`${this.baseUrl}/v1/sessions/${parentSessionId}/research`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to create research session" }));
+      throw new Error(error.error || "Failed to create research session");
+    }
+    return response.json();
+  }
+  async deleteResearchSession(researchId) {
+    const response = await fetch(`${this.baseUrl}/v1/research/${researchId}`, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to delete research session" }));
+      throw new Error(error.error || "Failed to delete research session");
+    }
+    return response.json();
+  }
+  async injectContext(parentSessionId, researchSessionId, label) {
+    const response = await fetch(`${this.baseUrl}/v1/sessions/${parentSessionId}/inject`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ researchSessionId, label })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to inject context" }));
+      throw new Error(error.error || "Failed to inject context");
+    }
+    return response.json();
+  }
+  async exportToNewSession(researchId, data) {
+    const response = await fetch(`${this.baseUrl}/v1/research/${researchId}/export`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data ?? {})
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to export to session" }));
+      throw new Error(error.error || "Failed to export to session");
+    }
+    return response.json();
+  }
+}
+var researchApi = new ResearchApiClient;
+function useResearchSessions(parentSessionId) {
+  return useQuery8({
+    queryKey: ["research", "sessions", parentSessionId],
+    queryFn: () => researchApi.listResearchSessions(parentSessionId),
+    enabled: !!parentSessionId,
+    staleTime: 30000
+  });
+}
+function useCreateResearchSession() {
+  const queryClient = useQueryClient7();
+  return useMutation6({
+    mutationFn: ({
+      parentSessionId,
+      data
+    }) => researchApi.createResearchSession(parentSessionId, data ?? {}),
+    onSuccess: (_, { parentSessionId }) => {
+      queryClient.invalidateQueries({
+        queryKey: ["research", "sessions", parentSessionId]
+      });
+    }
+  });
+}
+function useDeleteResearchSession() {
+  const queryClient = useQueryClient7();
+  return useMutation6({
+    mutationFn: (researchId) => researchApi.deleteResearchSession(researchId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["research", "sessions"] });
+    }
+  });
+}
+function useInjectContext() {
+  const addContext = usePendingResearchStore((state) => state.addContext);
+  return useMutation6({
+    mutationFn: ({
+      parentSessionId,
+      researchSessionId,
+      label
+    }) => researchApi.injectContext(parentSessionId, researchSessionId, label),
+    onSuccess: (data, { parentSessionId }) => {
+      addContext(parentSessionId, {
+        id: data.sessionId,
+        sessionId: data.sessionId,
+        label: data.label,
+        content: data.content
+      });
+    }
+  });
+}
+function useExportToSession() {
+  const queryClient = useQueryClient7();
+  return useMutation6({
+    mutationFn: ({
+      researchId,
+      data
+    }) => researchApi.exportToNewSession(researchId, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: sessionsQueryKey });
+    }
+  });
+}
+// src/hooks/useSetuPayments.ts
+import { useEffect as useEffect7, useRef as useRef2 } from "react";
+
+// src/stores/toastStore.ts
+import { create as create14 } from "zustand";
+var toastId = 0;
+var useToastStore = create14((set) => ({
+  toasts: [],
+  addToast: (toast) => {
+    const id = `toast-${++toastId}`;
+    set((state) => ({
+      toasts: [...state.toasts, { ...toast, id }]
+    }));
+    return id;
+  },
+  removeToast: (id) => set((state) => ({
+    toasts: state.toasts.filter((t) => t.id !== id)
+  })),
+  updateToast: (id, updates) => set((state) => ({
+    toasts: state.toasts.map((t) => t.id === id ? { ...t, ...updates } : t)
+  })),
+  clearToasts: () => set({ toasts: [] })
+}));
+function toast(message, type = "default", duration = 4000) {
+  const id = useToastStore.getState().addToast({ message, type, duration });
+  if (duration > 0) {
+    setTimeout(() => {
+      useToastStore.getState().removeToast(id);
+    }, duration);
+  }
+  return id;
+}
+toast.success = (message, duration = 4000) => toast(message, "success", duration);
+toast.error = (message, duration = 5000) => toast(message, "error", duration);
+toast.info = (message, duration = 4000) => toast(message, "default", duration);
+toast.loading = (message) => toast(message, "loading", 0);
+toast.successWithAction = (message, action, duration = 6000) => {
+  const id = useToastStore.getState().addToast({
+    message,
+    type: "success",
+    duration,
+    action
+  });
+  if (duration > 0) {
+    setTimeout(() => {
+      useToastStore.getState().removeToast(id);
+    }, duration);
+  }
+  return id;
+};
+
+// src/stores/setuStore.ts
+import { create as create15 } from "zustand";
+var useSetuStore = create15((set) => ({
+  balance: null,
+  usdcBalance: null,
+  network: "mainnet",
+  isPaymentPending: false,
+  lastPaymentAmount: null,
+  walletAddress: null,
+  isLoading: false,
+  isTopupModalOpen: false,
+  scope: null,
+  payg: null,
+  subscription: null,
+  limits: null,
+  setBalance: (balance) => set({ balance }),
+  setUsdcBalance: (usdcBalance) => set({ usdcBalance }),
+  setNetwork: (network) => set({ network }),
+  setPaymentPending: (isPaymentPending) => set({ isPaymentPending }),
+  setLastPaymentAmount: (lastPaymentAmount) => set({ lastPaymentAmount }),
+  setWalletAddress: (walletAddress) => set({ walletAddress }),
+  setLoading: (isLoading) => set({ isLoading }),
+  openTopupModal: () => set({ isTopupModalOpen: true }),
+  closeTopupModal: () => set({ isTopupModalOpen: false }),
+  setScope: (scope) => set({ scope }),
+  setPayg: (payg) => set({ payg }),
+  setSubscription: (subscription) => set({ subscription }),
+  setLimits: (limits) => set({ limits })
+}));
+
+// src/stores/topupApprovalStore.ts
+import { create as create16 } from "zustand";
+var useTopupApprovalStore = create16((set) => ({
+  pendingTopup: null,
+  isProcessing: false,
+  selectedMethod: null,
+  setPendingTopup: (pendingTopup) => set({ pendingTopup, isProcessing: false, selectedMethod: null }),
+  setProcessing: (isProcessing) => set({ isProcessing }),
+  setSelectedMethod: (selectedMethod) => set({ selectedMethod }),
+  clearPendingTopup: () => set({ pendingTopup: null, isProcessing: false, selectedMethod: null })
+}));
+
+// src/hooks/useSetuPayments.ts
+function useSetuPayments(sessionId) {
+  const clientRef = useRef2(null);
+  const loadingToastIdRef = useRef2(null);
+  const setBalance = useSetuStore((s) => s.setBalance);
+  const setPaymentPending = useSetuStore((s) => s.setPaymentPending);
+  const removeToast = useToastStore((s) => s.removeToast);
+  const updateToast = useToastStore((s) => s.updateToast);
+  const setPendingTopup = useTopupApprovalStore((s) => s.setPendingTopup);
+  const clearPendingTopup = useTopupApprovalStore((s) => s.clearPendingTopup);
+  useEffect7(() => {
+    if (!sessionId)
+      return;
+    const client2 = new SSEClient;
+    clientRef.current = client2;
+    const url = apiClient.getStreamUrl(sessionId);
+    client2.connect(url);
+    const unsubscribe = client2.on("*", (event) => {
+      const payload = event.payload;
+      switch (event.type) {
+        case "setu.topup.required": {
+          const amountUsd = typeof payload?.amountUsd === "number" ? payload.amountUsd : 0;
+          const currentBalance = typeof payload?.currentBalance === "number" ? payload.currentBalance : 0;
+          const minTopupUsd = typeof payload?.minTopupUsd === "number" ? payload.minTopupUsd : 5;
+          const suggestedTopupUsd = typeof payload?.suggestedTopupUsd === "number" ? payload.suggestedTopupUsd : 10;
+          const messageId = typeof payload?.messageId === "string" ? payload.messageId : "";
+          setPendingTopup({
+            sessionId,
+            messageId,
+            amountUsd,
+            currentBalance,
+            minTopupUsd,
+            suggestedTopupUsd
+          });
+          break;
+        }
+        case "setu.topup.method_selected": {
+          const method = payload?.method;
+          if (method === "crypto") {
+            setPaymentPending(true);
+            loadingToastIdRef.current = toast.loading("\uD83D\uDCB3 Processing crypto payment...");
+          }
+          break;
+        }
+        case "setu.topup.cancelled": {
+          clearPendingTopup();
+          const reason = typeof payload?.reason === "string" ? payload.reason : "Request cancelled";
+          toast(`⚠️ ${reason}`);
+          break;
+        }
+        case "setu.payment.required": {
+          const amountUsd = typeof payload?.amountUsd === "number" ? payload.amountUsd : 0;
+          setPaymentPending(true);
+          if (!loadingToastIdRef.current) {
+            loadingToastIdRef.current = toast.loading(`\uD83D\uDCB3 Payment required: $${amountUsd.toFixed(2)}`);
+          }
+          break;
+        }
+        case "setu.payment.signing": {
+          if (loadingToastIdRef.current) {
+            updateToast(loadingToastIdRef.current, {
+              message: "✍️ Signing transaction..."
+            });
+          } else {
+            loadingToastIdRef.current = toast.loading("✍️ Signing transaction...");
+          }
+          break;
+        }
+        case "setu.payment.complete": {
+          clearPendingTopup();
+          const rawAmount = payload?.amountUsd;
+          const rawBalance = payload?.newBalance;
+          const transactionId = typeof payload?.transactionId === "string" ? payload.transactionId : undefined;
+          const amountUsd = typeof rawAmount === "number" ? rawAmount : typeof rawAmount === "string" ? parseFloat(rawAmount) : 0;
+          const newBalance = typeof rawBalance === "number" ? rawBalance : typeof rawBalance === "string" ? parseFloat(rawBalance) : 0;
+          setBalance(newBalance);
+          setPaymentPending(false);
+          if (loadingToastIdRef.current) {
+            removeToast(loadingToastIdRef.current);
+            loadingToastIdRef.current = null;
+          }
+          const message = `✅ Paid $${amountUsd.toFixed(2)}`;
+          if (transactionId) {
+            toast.successWithAction(message, {
+              label: "View Tx",
+              href: `https://orbmarkets.io/tx/${transactionId}`
+            });
+          } else {
+            toast.success(message);
+          }
+          break;
+        }
+        case "setu.fiat.checkout_created": {
+          clearPendingTopup();
+          setPaymentPending(false);
+          if (loadingToastIdRef.current) {
+            removeToast(loadingToastIdRef.current);
+            loadingToastIdRef.current = null;
+          }
+          toast.success("\uD83D\uDCB3 Complete payment, then retry your message");
+          break;
+        }
+        case "setu.balance.updated": {
+          const rawBalance = payload?.balanceRemaining;
+          const newBalance = typeof rawBalance === "number" ? rawBalance : typeof rawBalance === "string" ? parseFloat(rawBalance) : null;
+          if (newBalance !== null && !Number.isNaN(newBalance)) {
+            setBalance(newBalance);
+          }
+          break;
+        }
+        case "setu.payment.error": {
+          clearPendingTopup();
+          const error = typeof payload?.error === "string" ? payload.error : "Payment failed";
+          setPaymentPending(false);
+          if (loadingToastIdRef.current) {
+            removeToast(loadingToastIdRef.current);
+            loadingToastIdRef.current = null;
+          }
+          toast.error(`❌ ${error}`);
+          break;
+        }
+        default:
+          break;
+      }
+    });
+    return () => {
+      unsubscribe();
+      client2.disconnect();
+    };
+  }, [
+    sessionId,
+    setBalance,
+    setPaymentPending,
+    removeToast,
+    updateToast,
+    setPendingTopup,
+    clearPendingTopup
+  ]);
+}
+// src/hooks/useSetuBalance.ts
+import { useEffect as useEffect8, useCallback as useCallback6 } from "react";
+function useSetuBalance(providerName) {
+  const setBalance = useSetuStore((s) => s.setBalance);
+  const setUsdcBalance = useSetuStore((s) => s.setUsdcBalance);
+  const setWalletAddress = useSetuStore((s) => s.setWalletAddress);
+  const setLoading = useSetuStore((s) => s.setLoading);
+  const setScope = useSetuStore((s) => s.setScope);
+  const setPayg = useSetuStore((s) => s.setPayg);
+  const setSubscription = useSetuStore((s) => s.setSubscription);
+  const setLimits = useSetuStore((s) => s.setLimits);
+  const balance = useSetuStore((s) => s.balance);
+  const usdcBalance = useSetuStore((s) => s.usdcBalance);
+  const network = useSetuStore((s) => s.network);
+  const fetchBalance = useCallback6(async () => {
+    if (providerName !== "setu") {
+      return;
+    }
+    setLoading(true);
+    try {
+      const [setuData, usdcData, walletData] = await Promise.all([
+        apiClient.getSetuBalance(),
+        apiClient.getSetuUsdcBalance(network),
+        apiClient.getSetuWallet()
+      ]);
+      if (setuData) {
+        setBalance(setuData.balance);
+        setWalletAddress(setuData.walletAddress);
+        setScope(setuData.scope ?? null);
+        setPayg(setuData.payg ?? null);
+        setSubscription(setuData.subscription ?? null);
+        setLimits(setuData.limits ?? null);
+      } else if (walletData?.configured && walletData.publicKey) {
+        setWalletAddress(walletData.publicKey);
+      }
+      if (usdcData) {
+        setUsdcBalance(usdcData.usdcBalance);
+        if (!setuData && usdcData.walletAddress) {
+          setWalletAddress(usdcData.walletAddress);
+        }
+      }
+    } catch {} finally {
+      setLoading(false);
+    }
+  }, [
+    providerName,
+    network,
+    setBalance,
+    setUsdcBalance,
+    setWalletAddress,
+    setLoading,
+    setScope,
+    setPayg,
+    setSubscription,
+    setLimits
+  ]);
+  useEffect8(() => {
+    if (providerName === "setu" && (balance === null || usdcBalance === null)) {
+      fetchBalance();
+    }
+  }, [providerName, balance, usdcBalance, fetchBalance]);
+  return {
+    fetchBalance
+  };
+}
+// src/hooks/useShareStatus.ts
+import { useQuery as useQuery9 } from "@tanstack/react-query";
+function useShareStatus(sessionId) {
+  const { data, isLoading, error } = useQuery9({
+    queryKey: ["share-status", sessionId],
+    queryFn: () => apiClient.getShareStatus(sessionId),
+    enabled: !!sessionId,
+    staleTime: 30000
+  });
+  return { data, isLoading, error };
+}
+// src/hooks/useToolApprovalShortcuts.ts
+import { useEffect as useEffect9, useCallback as useCallback7 } from "react";
+function useToolApprovalShortcuts(sessionId) {
+  const { pendingApprovals, removePendingApproval } = useToolApprovalStore();
+  const sessionPendingApprovals = pendingApprovals;
+  const handleApprove = useCallback7(async (callId) => {
+    if (!sessionId)
+      return;
+    try {
+      await apiClient.approveToolCall(sessionId, callId, true);
+      removePendingApproval(callId);
+    } catch (error) {
+      console.error("Failed to approve tool call:", error);
+    }
+  }, [sessionId, removePendingApproval]);
+  const handleReject = useCallback7(async (callId) => {
+    if (!sessionId)
+      return;
+    try {
+      await apiClient.approveToolCall(sessionId, callId, false);
+      removePendingApproval(callId);
+    } catch (error) {
+      console.error("Failed to reject tool call:", error);
+    }
+  }, [sessionId, removePendingApproval]);
+  const handleApproveAll = useCallback7(async () => {
+    if (!sessionId)
+      return;
+    try {
+      await Promise.all(sessionPendingApprovals.map((a) => apiClient.approveToolCall(sessionId, a.callId, true)));
+      for (const a of sessionPendingApprovals) {
+        removePendingApproval(a.callId);
+      }
+    } catch (error) {
+      console.error("Failed to approve all tool calls:", error);
+    }
+  }, [sessionId, sessionPendingApprovals, removePendingApproval]);
+  useEffect9(() => {
+    if (!sessionId || sessionPendingApprovals.length === 0)
+      return;
+    const handleKeyDown = (e) => {
+      if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement || e.target?.isContentEditable) {
+        return;
+      }
+      const firstPending = sessionPendingApprovals[0];
+      if (e.key === "y" || e.key === "Y") {
+        e.preventDefault();
+        handleApprove(firstPending.callId);
+      } else if (e.key === "n" || e.key === "N" || e.key === "Escape") {
+        e.preventDefault();
+        handleReject(firstPending.callId);
+      } else if (e.key === "a" || e.key === "A") {
+        e.preventDefault();
+        handleApproveAll();
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [
+    sessionId,
+    sessionPendingApprovals,
+    handleApprove,
+    handleReject,
+    handleApproveAll
+  ]);
+}
+// src/hooks/useTopupCallback.ts
+import { useEffect as useEffect10, useRef as useRef3 } from "react";
+var STORAGE_KEY3 = "pendingPolarCheckout";
+function useTopupCallback() {
+  const hasHandled = useRef3(false);
+  const loadingToastId = useRef3(null);
+  const setBalance = useSetuStore((s) => s.setBalance);
+  const removeToast = useToastStore((s) => s.removeToast);
+  useEffect10(() => {
+    if (hasHandled.current)
+      return;
+    const params = new URLSearchParams(window.location.search);
+    const topupStatus = params.get("topup");
+    const pendingCheckoutId = localStorage.getItem(STORAGE_KEY3);
+    if (topupStatus === "pending" || pendingCheckoutId) {
+      hasHandled.current = true;
+      const url = new URL(window.location.href);
+      url.searchParams.delete("topup");
+      window.history.replaceState({}, "", url.toString());
+      if (!pendingCheckoutId) {
+        toast.info("Checking top-up status...");
+        return;
+      }
+      loadingToastId.current = toast.loading("Verifying top-up...");
+      let attempts = 0;
+      const maxAttempts = 10;
+      const delayMs = 2000;
+      const dismissLoading = () => {
+        if (loadingToastId.current) {
+          removeToast(loadingToastId.current);
+          loadingToastId.current = null;
+        }
+      };
+      const checkStatus = async () => {
+        attempts++;
+        try {
+          const status = await apiClient.getPolarTopupStatus(pendingCheckoutId);
+          if (status?.confirmed) {
+            localStorage.removeItem(STORAGE_KEY3);
+            dismissLoading();
+            const balanceData = await apiClient.getSetuBalance();
+            if (balanceData?.balance !== undefined) {
+              setBalance(balanceData.balance);
+            }
+            toast.success(`Top-up confirmed! +$${status.amountUsd?.toFixed(2)} credited`);
+            return;
+          }
+          if (attempts < maxAttempts) {
+            setTimeout(checkStatus, delayMs);
+          } else {
+            localStorage.removeItem(STORAGE_KEY3);
+            dismissLoading();
+            toast.info("Top-up is still processing. Balance will update automatically.");
+          }
+        } catch {
+          if (attempts < maxAttempts) {
+            setTimeout(checkStatus, delayMs);
+          } else {
+            localStorage.removeItem(STORAGE_KEY3);
+            dismissLoading();
+            toast.error("Could not verify top-up. Please check your balance.");
+          }
+        }
+      };
+      setTimeout(checkStatus, 1500);
+    }
+  }, [setBalance, removeToast]);
+}
+// src/hooks/useAuthStatus.ts
+import { useEffect as useEffect11, useCallback as useCallback8, useState as useState5, useRef as useRef4 } from "react";
+import { useQueryClient as useQueryClient8 } from "@tanstack/react-query";
+
+// src/stores/onboardingStore.ts
+import { create as create17 } from "zustand";
+var STEPS = ["wallet", "defaults"];
+var useOnboardingStore = create17((set, get) => ({
+  isOpen: false,
+  currentStep: "wallet",
+  manageMode: false,
+  isLoading: false,
+  error: null,
+  authStatus: null,
+  setOpen: (isOpen) => set({ isOpen }),
+  setStep: (currentStep) => set({ currentStep }),
+  setManageMode: (manageMode) => set({ manageMode }),
+  setLoading: (isLoading) => set({ isLoading }),
+  setError: (error) => set({ error }),
+  setAuthStatus: (authStatus) => set({ authStatus }),
+  nextStep: () => {
+    const { currentStep } = get();
+    const currentIndex = STEPS.indexOf(currentStep);
+    if (currentIndex < STEPS.length - 1) {
+      set({ currentStep: STEPS[currentIndex + 1] });
+    }
+  },
+  prevStep: () => {
+    const { currentStep } = get();
+    const currentIndex = STEPS.indexOf(currentStep);
+    if (currentIndex > 0) {
+      set({ currentStep: STEPS[currentIndex - 1] });
+    }
+  },
+  reset: () => set({
+    isOpen: false,
+    currentStep: "wallet",
+    manageMode: false,
+    isLoading: false,
+    error: null
+  })
+}));
+
+// src/hooks/useAuthStatus.ts
+var isInIframe = typeof window !== "undefined" && window.self !== window.top;
+function useAuthStatus() {
+  const setAuthStatus = useOnboardingStore((s) => s.setAuthStatus);
+  const setOpen = useOnboardingStore((s) => s.setOpen);
+  const setLoading = useOnboardingStore((s) => s.setLoading);
+  const setError = useOnboardingStore((s) => s.setError);
+  const authStatus = useOnboardingStore((s) => s.authStatus);
+  const isOpen = useOnboardingStore((s) => s.isOpen);
+  const queryClient = useQueryClient8();
+  const [initialized, setInitialized] = useState5(false);
+  const [oauthPolling, setOauthPolling] = useState5(false);
+  const oauthPollingRef = useRef4(null);
+  const preOauthProvidersRef = useRef4(new Set);
+  const fetchAuthStatus = useCallback8(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const status = await apiClient.getAuthStatus();
+      setAuthStatus(status);
+      queryClient.invalidateQueries({ queryKey: ["config"] });
+      queryClient.invalidateQueries({ queryKey: ["models"] });
+      return status;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to load";
+      setError(message);
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, [setAuthStatus, setLoading, setError, queryClient]);
+  const checkOnboarding = useCallback8(async () => {
+    const status = await fetchAuthStatus();
+    if (status) {
+      const hasAnyProvider = Object.values(status.providers).some((p) => p.configured);
+      const needsOnboarding = !status.onboardingComplete || !hasAnyProvider || !status.setu.configured;
+      if (needsOnboarding) {
+        setOpen(true);
+      }
+    }
+    setInitialized(true);
+  }, [fetchAuthStatus, setOpen]);
+  const setupWallet = useCallback8(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await apiClient.setupSetuWallet();
+      await fetchAuthStatus();
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Setup failed";
+      setError(message);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchAuthStatus, setLoading, setError]);
+  const importWallet = useCallback8(async (privateKey) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await apiClient.importSetuWallet(privateKey);
+      await fetchAuthStatus();
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Import failed";
+      setError(message);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchAuthStatus, setLoading, setError]);
+  const addProvider = useCallback8(async (provider, apiKey) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await apiClient.addProvider(provider, apiKey);
+      await fetchAuthStatus();
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to add provider";
+      setError(message);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchAuthStatus, setLoading, setError]);
+  const removeProvider = useCallback8(async (provider) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await apiClient.removeProvider(provider);
+      await fetchAuthStatus();
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to remove provider";
+      setError(message);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchAuthStatus, setLoading, setError]);
+  const completeOnboarding = useCallback8(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      await apiClient.completeOnboarding();
+      await fetchAuthStatus();
+      setOpen(false);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to complete onboarding";
+      setError(message);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchAuthStatus, setLoading, setError, setOpen]);
+  const snapshotConfiguredProviders = useCallback8(() => {
+    const status = useOnboardingStore.getState().authStatus;
+    if (status) {
+      preOauthProvidersRef.current = new Set(Object.entries(status.providers).filter(([, p]) => p.configured).map(([id]) => id));
+    }
+  }, []);
+  const startOAuth = useCallback8((provider, mode) => {
+    const url = apiClient.getOAuthStartUrl(provider, mode);
+    if (isInIframe) {
+      snapshotConfiguredProviders();
+      window.parent.postMessage({ type: "otto-open-url", url }, "*");
+      setOauthPolling(true);
+      return null;
+    }
+    const width = 600;
+    const height = 700;
+    const left = window.screenX + (window.outerWidth - width) / 2;
+    const top = window.screenY + (window.outerHeight - height) / 2;
+    const popup = window.open(url, "oauth_popup", `width=${width},height=${height},left=${left},top=${top},toolbar=no,menubar=no`);
+    return popup;
+  }, [snapshotConfiguredProviders]);
+  const startOAuthManual = useCallback8(async (provider, mode) => {
+    const { url, sessionId } = await apiClient.getOAuthUrl(provider, mode);
+    if (isInIframe) {
+      snapshotConfiguredProviders();
+      window.parent.postMessage({ type: "otto-open-url", url }, "*");
+      setOauthPolling(true);
+      return { popup: null, sessionId };
+    }
+    const width = 600;
+    const height = 700;
+    const left = window.screenX + (window.outerWidth - width) / 2;
+    const top = window.screenY + (window.outerHeight - height) / 2;
+    const popup = window.open(url, "oauth_popup", `width=${width},height=${height},left=${left},top=${top},toolbar=no,menubar=no`);
+    return { popup, sessionId };
+  }, [snapshotConfiguredProviders]);
+  const exchangeOAuthCode = useCallback8(async (provider, code, sessionId) => {
+    setLoading(true);
+    setError(null);
+    try {
+      await apiClient.exchangeOAuthCode(provider, code, sessionId);
+      await fetchAuthStatus();
+      return true;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to exchange code";
+      setError(message);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchAuthStatus, setLoading, setError]);
+  useEffect11(() => {
+    if (!oauthPolling || !isInIframe)
+      return;
+    oauthPollingRef.current = setInterval(() => {
+      fetchAuthStatus();
+    }, 3000);
+    const timeout = setTimeout(() => {
+      setOauthPolling(false);
+    }, 300000);
+    return () => {
+      clearInterval(oauthPollingRef.current);
+      clearTimeout(timeout);
+    };
+  }, [oauthPolling, fetchAuthStatus]);
+  useEffect11(() => {
+    if (!oauthPolling || !authStatus)
+      return;
+    const currentConfigured = Object.entries(authStatus.providers).filter(([, p]) => p.configured);
+    const hasNewProvider = currentConfigured.some(([id]) => !preOauthProvidersRef.current.has(id));
+    if (hasNewProvider) {
+      setOauthPolling(false);
+    }
+  }, [authStatus, oauthPolling]);
+  useEffect11(() => {
+    const handleOAuthMessage = (event) => {
+      if (event.data?.type === "oauth-success") {
+        fetchAuthStatus();
+      }
+    };
+    window.addEventListener("message", handleOAuthMessage);
+    return () => window.removeEventListener("message", handleOAuthMessage);
+  }, [fetchAuthStatus]);
+  const pollCopilotDeviceFlow = useCallback8(async (sessionId) => {
+    const result = await apiClient.pollCopilotDeviceFlow(sessionId);
+    if (result.status === "complete") {
+      await fetchAuthStatus();
+    }
+    return result;
+  }, [fetchAuthStatus]);
+  const saveCopilotToken = useCallback8(async (token) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await apiClient.saveCopilotToken(token);
+      await fetchAuthStatus();
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to save Copilot token";
+      setError(message);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchAuthStatus, setLoading, setError]);
+  const importCopilotTokenFromGh = useCallback8(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await apiClient.importCopilotTokenFromGh();
+      await fetchAuthStatus();
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to import Copilot token from GH";
+      setError(message);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchAuthStatus, setLoading, setError]);
+  return {
+    authStatus,
+    isOpen,
+    initialized,
+    fetchAuthStatus,
+    checkOnboarding,
+    setupWallet,
+    importWallet,
+    addProvider,
+    removeProvider,
+    completeOnboarding,
+    startOAuth,
+    startOAuthManual,
+    exchangeOAuthCode,
+    startCopilotDeviceFlow: apiClient.startCopilotDeviceFlow.bind(apiClient),
+    pollCopilotDeviceFlow,
+    getCopilotAuthMethods: apiClient.getCopilotAuthMethods.bind(apiClient),
+    saveCopilotToken,
+    importCopilotTokenFromGh,
+    getCopilotDiagnostics: apiClient.getCopilotDiagnostics.bind(apiClient)
+  };
+}
+// src/hooks/useTunnel.ts
+import { useQuery as useQuery10, useMutation as useMutation7, useQueryClient as useQueryClient9 } from "@tanstack/react-query";
+import { useEffect as useEffect12, useCallback as useCallback9, useRef as useRef5 } from "react";
+async function fetchTunnelStatus() {
+  const response = await fetch(`${API_BASE_URL}/v1/tunnel/status`);
+  if (!response.ok) {
+    throw new Error("Failed to fetch tunnel status");
+  }
+  return response.json();
+}
+async function startTunnel() {
+  const response = await fetch(`${API_BASE_URL}/v1/tunnel/start`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({})
+  });
+  return response.json();
+}
+async function stopTunnel() {
+  const response = await fetch(`${API_BASE_URL}/v1/tunnel/stop`, {
+    method: "POST"
+  });
+  return response.json();
+}
+async function fetchTunnelQr() {
+  const response = await fetch(`${API_BASE_URL}/v1/tunnel/qr`);
+  return response.json();
+}
+function useTunnelStatus() {
+  const setStatus = useTunnelStore((s) => s.setStatus);
+  const setUrl = useTunnelStore((s) => s.setUrl);
+  const setError = useTunnelStore((s) => s.setError);
+  const query = useQuery10({
+    queryKey: ["tunnel", "status"],
+    queryFn: fetchTunnelStatus,
+    refetchInterval: 3000
+  });
+  useEffect12(() => {
+    if (query.data) {
+      setStatus(query.data.status);
+      setUrl(query.data.url);
+      setError(query.data.error);
+    }
+  }, [query.data, setStatus, setUrl, setError]);
+  return query;
+}
+function useStartTunnel() {
+  const queryClient = useQueryClient9();
+  const setStatus = useTunnelStore((s) => s.setStatus);
+  const setUrl = useTunnelStore((s) => s.setUrl);
+  const setError = useTunnelStore((s) => s.setError);
+  const setProgress = useTunnelStore((s) => s.setProgress);
+  return useMutation7({
+    mutationFn: () => startTunnel(),
+    onMutate: () => {
+      setStatus("starting");
+      setProgress("Connecting...");
+      setError(null);
+    },
+    onSuccess: (data) => {
+      if (data.ok && data.url) {
+        setStatus("connected");
+        setUrl(data.url);
+        setProgress(null);
+      } else if (!data.ok) {
+        setStatus("error");
+        setError(data.error || "Failed to start tunnel");
+        setProgress(null);
+      }
+      queryClient.invalidateQueries({ queryKey: ["tunnel"] });
+    },
+    onError: (error) => {
+      setStatus("error");
+      setError(error.message);
+      setProgress(null);
+    }
+  });
+}
+function useStopTunnel() {
+  const queryClient = useQueryClient9();
+  const reset = useTunnelStore((s) => s.reset);
+  return useMutation7({
+    mutationFn: stopTunnel,
+    onSuccess: () => {
+      reset();
+      queryClient.invalidateQueries({ queryKey: ["tunnel"] });
+    }
+  });
+}
+function useTunnelQr() {
+  const url = useTunnelStore((s) => s.url);
+  const setQrCode = useTunnelStore((s) => s.setQrCode);
+  const query = useQuery10({
+    queryKey: ["tunnel", "qr", url],
+    queryFn: fetchTunnelQr,
+    enabled: !!url
+  });
+  useEffect12(() => {
+    if (query.data?.ok && query.data.qrCode) {
+      setQrCode(query.data.qrCode);
+    }
+  }, [query.data, setQrCode]);
+  return query;
+}
+function useTunnelStream() {
+  const setStatus = useTunnelStore((s) => s.setStatus);
+  const setUrl = useTunnelStore((s) => s.setUrl);
+  const setError = useTunnelStore((s) => s.setError);
+  const setProgress = useTunnelStore((s) => s.setProgress);
+  const isExpanded = useTunnelStore((s) => s.isExpanded);
+  const eventSourceRef = useRef5(null);
+  const connect = useCallback9(() => {
+    if (eventSourceRef.current) {
+      eventSourceRef.current.close();
+    }
+    const es = new EventSource(`${API_BASE_URL}/v1/tunnel/stream`);
+    eventSourceRef.current = es;
+    es.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type === "status") {
+          setStatus(data.status);
+          setUrl(data.url);
+          setError(data.error);
+          setProgress(data.progress);
+        }
+      } catch {}
+    };
+    es.onerror = () => {
+      es.close();
+      eventSourceRef.current = null;
+    };
+    return () => {
+      es.close();
+      eventSourceRef.current = null;
+    };
+  }, [setStatus, setUrl, setError, setProgress]);
+  useEffect12(() => {
+    if (isExpanded) {
+      const cleanup = connect();
+      return cleanup;
+    }
+    return () => {
+      if (eventSourceRef.current) {
+        eventSourceRef.current.close();
+        eventSourceRef.current = null;
+      }
+    };
+  }, [isExpanded, connect]);
+  return { connect };
+}
+// src/hooks/useProviderUsage.ts
+import { useEffect as useEffect13, useCallback as useCallback10 } from "react";
+
+// src/stores/usageStore.ts
+import { create as create18 } from "zustand";
+var useUsageStore = create18((set) => ({
+  usage: {},
+  isLoading: {},
+  lastFetched: {},
+  isModalOpen: false,
+  modalProvider: null,
+  setUsage: (provider, data) => set((s) => ({ usage: { ...s.usage, [provider]: data } })),
+  setLoading: (provider, loading) => set((s) => ({ isLoading: { ...s.isLoading, [provider]: loading } })),
+  setLastFetched: (provider, time) => set((s) => ({ lastFetched: { ...s.lastFetched, [provider]: time } })),
+  openModal: (provider) => set({ isModalOpen: true, modalProvider: provider }),
+  closeModal: () => set({ isModalOpen: false, modalProvider: null })
+}));
+
+// src/hooks/useProviderUsage.ts
+var POLL_INTERVAL = 60000;
+var STALE_THRESHOLD = 30000;
+function useProviderUsage(provider, authType) {
+  const setUsage = useUsageStore((s) => s.setUsage);
+  const setLoading = useUsageStore((s) => s.setLoading);
+  const setLastFetched = useUsageStore((s) => s.setLastFetched);
+  const usage = useUsageStore((s) => provider ? s.usage[provider] : undefined);
+  const lastFetched = useUsageStore((s) => provider ? s.lastFetched[provider] : 0);
+  const isOAuthProvider = authType === "oauth" && (provider === "anthropic" || provider === "openai");
+  const fetchUsage = useCallback10(async () => {
+    if (!provider || !isOAuthProvider)
+      return;
+    setLoading(provider, true);
+    try {
+      const data = await apiClient.getProviderUsage(provider);
+      setUsage(provider, data);
+      setLastFetched(provider, Date.now());
+    } catch {} finally {
+      setLoading(provider, false);
+    }
+  }, [provider, isOAuthProvider, setUsage, setLoading, setLastFetched]);
+  useEffect13(() => {
+    if (!isOAuthProvider)
+      return;
+    const isStale = !lastFetched || Date.now() - lastFetched > STALE_THRESHOLD;
+    if (isStale) {
+      fetchUsage();
+    }
+    const interval = setInterval(fetchUsage, POLL_INTERVAL);
+    return () => clearInterval(interval);
+  }, [isOAuthProvider, fetchUsage, lastFetched]);
+  return {
+    usage,
+    fetchUsage,
+    isOAuthProvider
+  };
+}
+// src/hooks/useFileBrowser.ts
+import { useQuery as useQuery11 } from "@tanstack/react-query";
+function useFileTree(dirPath, enabled = true) {
+  return useQuery11({
+    queryKey: ["files", "tree", dirPath],
+    queryFn: () => apiClient.getFileTree(dirPath),
+    enabled,
+    staleTime: 1e4,
+    retry: 1
+  });
+}
+function useFileContent(filePath) {
+  return useQuery11({
+    queryKey: ["files", "read", filePath],
+    queryFn: () => filePath ? apiClient.readFileContent(filePath) : null,
+    enabled: !!filePath,
+    staleTime: 5000,
+    retry: 1
+  });
+}
+function useGitDiffFullFile(file, staged = false, enabled = false) {
+  return useQuery11({
+    queryKey: ["git", "diff", "fullFile", file, staged],
+    queryFn: () => file ? apiClient.getGitDiffFullFile(file, staged) : null,
+    enabled: enabled && !!file,
+    retry: 1,
+    refetchInterval: false
+  });
+}
+// src/hooks/useMCP.ts
+import { useQuery as useQuery12, useMutation as useMutation8, useQueryClient as useQueryClient10 } from "@tanstack/react-query";
+import { useEffect as useEffect14, useRef as useRef6, useCallback as useCallback11 } from "react";
+import {
+  listMcpServers,
+  startMcpServer,
+  stopMcpServer,
+  addMcpServer,
+  removeMcpServer,
+  initiateMcpAuth,
+  revokeMcpAuth,
+  getMcpAuthStatus,
+  completeMcpAuth
+} from "@ottocode/api";
+function useMCPServers() {
+  const setServers = useMCPStore((s) => s.setServers);
+  const query = useQuery12({
+    queryKey: ["mcp", "servers"],
+    queryFn: async () => {
+      const { data } = await listMcpServers();
+      return data;
+    },
+    refetchInterval: 1e4
+  });
+  useEffect14(() => {
+    if (query.data?.servers) {
+      setServers(query.data.servers);
+    }
+  }, [query.data, setServers]);
+  return query;
+}
+function useStartMCPServer() {
+  const queryClient = useQueryClient10();
+  return useMutation8({
+    mutationFn: async (name) => {
+      const { data, error } = await startMcpServer({
+        path: { name }
+      });
+      if (error)
+        throw new Error("Failed to start server");
+      const result = data;
+      if (!result.ok)
+        throw new Error(result.error || "Failed to start server");
+      return result;
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: ["mcp", "servers"] });
+    }
+  });
+}
+function useStopMCPServer() {
+  const queryClient = useQueryClient10();
+  const setLoading = useMCPStore((s) => s.setLoading);
+  return useMutation8({
+    mutationFn: async (name) => {
+      setLoading(name, true);
+      const { data, error } = await stopMcpServer({
+        path: { name }
+      });
+      if (error)
+        throw new Error("Failed to stop server");
+      const result = data;
+      if (!result.ok)
+        throw new Error(result.error || "Failed to stop server");
+      return result;
+    },
+    onSettled: (_data, _error, name) => {
+      setLoading(name, false);
+      queryClient.invalidateQueries({ queryKey: ["mcp", "servers"] });
+    }
+  });
+}
+function useAddMCPServer() {
+  const queryClient = useQueryClient10();
+  return useMutation8({
+    mutationFn: async (params) => {
+      const { data, error } = await addMcpServer({
+        body: params
+      });
+      if (error)
+        throw new Error("Failed to add MCP server");
+      const result = data;
+      if (!result.ok)
+        throw new Error(result.error || "Failed to add MCP server");
+      return result;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["mcp", "servers"] });
+    }
+  });
+}
+function useRemoveMCPServer() {
+  const queryClient = useQueryClient10();
+  return useMutation8({
+    mutationFn: async (name) => {
+      const { data, error } = await removeMcpServer({
+        path: { name }
+      });
+      if (error)
+        throw new Error("Failed to remove MCP server");
+      const result = data;
+      if (!result.ok)
+        throw new Error(result.error || "Failed to remove MCP server");
+      return result;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["mcp", "servers"] });
+    }
+  });
+}
+function useAuthenticateMCPServer() {
+  const queryClient = useQueryClient10();
+  return useMutation8({
+    mutationFn: async (name) => {
+      const { data, error } = await initiateMcpAuth({
+        path: { name }
+      });
+      if (error)
+        throw new Error("Failed to initiate auth");
+      const result = data;
+      if (!result.ok)
+        throw new Error(result.error || "Failed to initiate auth");
+      return result;
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: ["mcp", "servers"] });
+    }
+  });
+}
+function useRevokeMCPAuth() {
+  const queryClient = useQueryClient10();
+  return useMutation8({
+    mutationFn: async (name) => {
+      const { data, error } = await revokeMcpAuth({
+        path: { name }
+      });
+      if (error)
+        throw new Error("Failed to revoke auth");
+      const result = data;
+      if (!result.ok)
+        throw new Error(result.error || "Failed to revoke auth");
+      return result;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["mcp", "servers"] });
+    }
+  });
+}
+function useMCPAuthStatus(name) {
+  return useQuery12({
+    queryKey: ["mcp", "auth", name],
+    queryFn: async () => {
+      if (!name)
+        return { authenticated: false };
+      const { data } = await getMcpAuthStatus({
+        path: { name }
+      });
+      return data;
+    },
+    enabled: !!name,
+    refetchInterval: 3000
+  });
+}
+function useCopilotDevicePoller() {
+  const copilotDevice = useMCPStore((s) => s.copilotDevice);
+  const setCopilotDevice = useMCPStore((s) => s.setCopilotDevice);
+  const setLoading = useMCPStore((s) => s.setLoading);
+  const queryClient = useQueryClient10();
+  const timerRef = useRef6(null);
+  const stopPolling = useCallback11(() => {
+    if (timerRef.current) {
+      clearInterval(timerRef.current);
+      timerRef.current = null;
+    }
+  }, []);
+  useEffect14(() => {
+    if (!copilotDevice) {
+      stopPolling();
+      return;
+    }
+    const { sessionId, serverName, interval } = copilotDevice;
+    const pollMs = (interval || 5) * 1000 + 1000;
+    timerRef.current = setInterval(async () => {
+      try {
+        const { data } = await completeMcpAuth({
+          path: { name: serverName },
+          body: { sessionId }
+        });
+        const result = data;
+        if (result?.status === "complete") {
+          stopPolling();
+          setCopilotDevice(null);
+          setLoading(serverName, false);
+          queryClient.invalidateQueries({ queryKey: ["mcp", "servers"] });
+        } else if (result?.status === "error") {
+          stopPolling();
+          setCopilotDevice(null);
+          setLoading(serverName, false);
+        }
+      } catch {
+        stopPolling();
+        setCopilotDevice(null);
+        setLoading(serverName, false);
+      }
+    }, pollMs);
+    return stopPolling;
+  }, [copilotDevice, setCopilotDevice, setLoading, queryClient, stopPolling]);
+  return copilotDevice;
+}
+// src/hooks/useSkills.ts
+import { useQuery as useQuery13 } from "@tanstack/react-query";
+import { useEffect as useEffect15 } from "react";
+function useSkills() {
+  const setSkills = useSkillsStore((s) => s.setSkills);
+  const query = useQuery13({
+    queryKey: ["skills"],
+    queryFn: async () => {
+      return apiClient.listSkills();
+    },
+    refetchInterval: 30000
+  });
+  useEffect15(() => {
+    if (query.data?.skills) {
+      setSkills(query.data.skills);
+    }
+  }, [query.data, setSkills]);
+  return query;
+}
+function useSkillDetail(name) {
+  return useQuery13({
+    queryKey: ["skills", name],
+    queryFn: async () => {
+      if (!name)
+        return null;
+      return apiClient.getSkill(name);
+    },
+    enabled: !!name
+  });
+}
+function useSkillFiles(name) {
+  return useQuery13({
+    queryKey: ["skills", name, "files"],
+    queryFn: async () => {
+      if (!name)
+        return null;
+      return apiClient.getSkillFiles(name);
+    },
+    enabled: !!name
+  });
+}
+function useSkillFileContent(name, filePath) {
+  return useQuery13({
+    queryKey: ["skills", name, "files", filePath],
+    queryFn: async () => {
+      if (!name || !filePath)
+        return null;
+      return apiClient.getSkillFileContent(name, filePath);
+    },
+    enabled: !!name && !!filePath
+  });
+}
+export {
+  useWorkingDirectory,
+  useUpdateSession,
+  useUpdateDefaults,
+  useUnstageFiles,
+  useTunnelStream,
+  useTunnelStatus,
+  useTunnelQr,
+  useTopupCallback,
+  useToolApprovalShortcuts,
+  useTheme,
+  useStopTunnel,
+  useStopMCPServer,
+  useStartTunnel,
+  useStartMCPServer,
+  useStageFiles,
+  useSkills,
+  useSkillFiles,
+  useSkillFileContent,
+  useSkillDetail,
+  useShareStatus,
+  useSetuPayments,
+  useSetuBalance,
+  useSessionsInfinite,
+  useSessions,
+  useSessionStream,
+  useSessionFiles,
+  useSession,
+  useSendMessage,
+  useRevokeMCPAuth,
+  useRestoreFiles,
+  useResearchSessions,
+  useRemoveRemote,
+  useRemoveMCPServer,
+  useQueueState,
+  usePushCommits,
+  usePullChanges,
+  useProviderUsage,
+  usePreferences,
+  useParentSession,
+  useModels,
+  useMessages,
+  useMessageQueuePosition,
+  useMCPServers,
+  useMCPAuthStatus,
+  useKeyboardShortcuts,
+  useInjectContext,
+  useImageUpload,
+  useGitStatus,
+  useGitRemotes,
+  useGitInit,
+  useGitDiffFullFile,
+  useGitDiff,
+  useGitBranch,
+  useGenerateCommitMessage,
+  useFiles,
+  useFileUpload,
+  useFileTree,
+  useFileContent,
+  useExportToSession,
+  useDeleteSession,
+  useDeleteResearchSession,
+  useDeleteFiles,
+  useCreateSession,
+  useCreateResearchSession,
+  useCreateBranch,
+  useCopilotDevicePoller,
+  useConfig,
+  useCommitChanges,
+  useBranches,
+  useAuthenticateMCPServer,
+  useAuthStatus,
+  useAllModels,
+  useAddRemote,
+  useAddMCPServer,
+  sessionsQueryKey
+};
+
+//# debugId=381FB663C2D4B88E64756E2164756E21