@uniqueli/openwork 0.1.0

package/out/main/index.js

@@ -0,0 +1,1989 @@
+"use strict";
+const electron = require("electron");
+const path = require("path");
+const messages = require("@langchain/core/messages");
+const langgraph = require("@langchain/langgraph");
+const deepagents = require("deepagents");
+const Store = require("electron-store");
+const fs$1 = require("fs/promises");
+const fs = require("fs");
+const os = require("os");
+const anthropic = require("@langchain/anthropic");
+const openai = require("@langchain/openai");
+const googleGenai = require("@langchain/google-genai");
+const initSqlJs = require("sql.js");
+const langgraphCheckpoint = require("@langchain/langgraph-checkpoint");
+const node_child_process = require("node:child_process");
+const node_crypto = require("node:crypto");
+const uuid = require("uuid");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+const fs__namespace$1 = /* @__PURE__ */ _interopNamespaceDefault(fs$1);
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const activeWatchers = /* @__PURE__ */ new Map();
+const debounceTimers = /* @__PURE__ */ new Map();
+const DEBOUNCE_DELAY = 500;
+function startWatching(threadId, workspacePath) {
+  stopWatching(threadId);
+  try {
+    const stat = fs__namespace.statSync(workspacePath);
+    if (!stat.isDirectory()) {
+      console.warn(`[WorkspaceWatcher] Path is not a directory: ${workspacePath}`);
+      return;
+    }
+  } catch (e) {
+    console.warn(`[WorkspaceWatcher] Cannot access path: ${workspacePath}`, e);
+    return;
+  }
+  try {
+    const watcher = fs__namespace.watch(workspacePath, { recursive: true }, (eventType, filename) => {
+      if (filename) {
+        const parts = filename.split(path__namespace.sep);
+        if (parts.some((p) => p.startsWith(".") || p === "node_modules")) {
+          return;
+        }
+      }
+      console.log(`[WorkspaceWatcher] ${eventType}: ${filename} in thread ${threadId}`);
+      const existingTimer = debounceTimers.get(threadId);
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+      const timer = setTimeout(() => {
+        debounceTimers.delete(threadId);
+        notifyRenderer(threadId, workspacePath);
+      }, DEBOUNCE_DELAY);
+      debounceTimers.set(threadId, timer);
+    });
+    watcher.on("error", (error) => {
+      console.error(`[WorkspaceWatcher] Error watching ${workspacePath}:`, error);
+      stopWatching(threadId);
+    });
+    activeWatchers.set(threadId, watcher);
+    console.log(`[WorkspaceWatcher] Started watching ${workspacePath} for thread ${threadId}`);
+  } catch (e) {
+    console.error(`[WorkspaceWatcher] Failed to start watching ${workspacePath}:`, e);
+  }
+}
+function stopWatching(threadId) {
+  const watcher = activeWatchers.get(threadId);
+  if (watcher) {
+    watcher.close();
+    activeWatchers.delete(threadId);
+    console.log(`[WorkspaceWatcher] Stopped watching for thread ${threadId}`);
+  }
+  const timer = debounceTimers.get(threadId);
+  if (timer) {
+    clearTimeout(timer);
+    debounceTimers.delete(threadId);
+  }
+}
+function notifyRenderer(threadId, workspacePath) {
+  const windows = electron.BrowserWindow.getAllWindows();
+  for (const win of windows) {
+    win.webContents.send("workspace:files-changed", {
+      threadId,
+      workspacePath
+    });
+  }
+}
+const OPENWORK_DIR = path.join(os.homedir(), ".openwork");
+const ENV_FILE = path.join(OPENWORK_DIR, ".env");
+const ENV_VAR_NAMES = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  google: "GOOGLE_API_KEY",
+  custom: "CUSTOM_API_KEY"
+};
+function getOpenworkDir() {
+  if (!fs.existsSync(OPENWORK_DIR)) {
+    fs.mkdirSync(OPENWORK_DIR, { recursive: true });
+  }
+  return OPENWORK_DIR;
+}
+function getDbPath() {
+  return path.join(getOpenworkDir(), "openwork.sqlite");
+}
+function getThreadCheckpointDir() {
+  const dir = path.join(getOpenworkDir(), "threads");
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getThreadCheckpointPath(threadId) {
+  return path.join(getThreadCheckpointDir(), `${threadId}.sqlite`);
+}
+function deleteThreadCheckpoint(threadId) {
+  const path2 = getThreadCheckpointPath(threadId);
+  if (fs.existsSync(path2)) {
+    fs.unlinkSync(path2);
+  }
+}
+function getEnvFilePath() {
+  return ENV_FILE;
+}
+function parseEnvFile() {
+  const envPath = getEnvFilePath();
+  if (!fs.existsSync(envPath)) return {};
+  const content = fs.readFileSync(envPath, "utf-8");
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex > 0) {
+      const key = trimmed.slice(0, eqIndex).trim();
+      const value = trimmed.slice(eqIndex + 1).trim();
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function writeEnvFile(env) {
+  getOpenworkDir();
+  const lines = Object.entries(env).filter(([_, v]) => v).map(([k, v]) => `${k}=${v}`);
+  fs.writeFileSync(getEnvFilePath(), lines.join("\n") + "\n");
+}
+function getApiKey(provider) {
+  const envVarName = ENV_VAR_NAMES[provider];
+  if (!envVarName) return void 0;
+  const env = parseEnvFile();
+  if (env[envVarName]) return env[envVarName];
+  return process.env[envVarName];
+}
+function setApiKey(provider, apiKey) {
+  const envVarName = ENV_VAR_NAMES[provider];
+  if (!envVarName) return;
+  const env = parseEnvFile();
+  env[envVarName] = apiKey;
+  writeEnvFile(env);
+  process.env[envVarName] = apiKey;
+}
+function deleteApiKey(provider) {
+  const envVarName = ENV_VAR_NAMES[provider];
+  if (!envVarName) return;
+  const env = parseEnvFile();
+  delete env[envVarName];
+  writeEnvFile(env);
+  delete process.env[envVarName];
+}
+function hasApiKey(provider) {
+  return !!getApiKey(provider);
+}
+function getCustomApiConfig() {
+  const env = parseEnvFile();
+  const baseUrl = env.CUSTOM_BASE_URL;
+  const apiKey = env.CUSTOM_API_KEY;
+  const model = env.CUSTOM_MODEL;
+  if (!baseUrl || !apiKey) return void 0;
+  return { baseUrl, apiKey, model };
+}
+function setCustomApiConfig(config) {
+  const env = parseEnvFile();
+  env.CUSTOM_BASE_URL = config.baseUrl;
+  env.CUSTOM_API_KEY = config.apiKey;
+  if (config.model) {
+    env.CUSTOM_MODEL = config.model;
+  } else {
+    delete env.CUSTOM_MODEL;
+  }
+  writeEnvFile(env);
+  process.env.CUSTOM_BASE_URL = config.baseUrl;
+  process.env.CUSTOM_API_KEY = config.apiKey;
+  if (config.model) {
+    process.env.CUSTOM_MODEL = config.model;
+  }
+}
+function deleteCustomApiConfig() {
+  const env = parseEnvFile();
+  delete env.CUSTOM_BASE_URL;
+  delete env.CUSTOM_API_KEY;
+  delete env.CUSTOM_MODEL;
+  writeEnvFile(env);
+  delete process.env.CUSTOM_BASE_URL;
+  delete process.env.CUSTOM_API_KEY;
+  delete process.env.CUSTOM_MODEL;
+}
+function hasCustomApiConfig() {
+  return !!getCustomApiConfig();
+}
+const store = new Store({
+  name: "settings",
+  cwd: getOpenworkDir()
+});
+const PROVIDERS = [
+  { id: "anthropic", name: "Anthropic" },
+  { id: "openai", name: "OpenAI" },
+  { id: "google", name: "Google" },
+  { id: "custom", name: "Custom API" }
+];
+const AVAILABLE_MODELS = [
+  // Anthropic Claude 4.5 series (latest as of Jan 2026)
+  {
+    id: "claude-opus-4-5-20251101",
+    name: "Claude Opus 4.5",
+    provider: "anthropic",
+    model: "claude-opus-4-5-20251101",
+    description: "Premium model with maximum intelligence",
+    available: true
+  },
+  {
+    id: "claude-sonnet-4-5-20250929",
+    name: "Claude Sonnet 4.5",
+    provider: "anthropic",
+    model: "claude-sonnet-4-5-20250929",
+    description: "Best balance of intelligence, speed, and cost for agents",
+    available: true
+  },
+  {
+    id: "claude-haiku-4-5-20251001",
+    name: "Claude Haiku 4.5",
+    provider: "anthropic",
+    model: "claude-haiku-4-5-20251001",
+    description: "Fastest model with near-frontier intelligence",
+    available: true
+  },
+  // Anthropic Claude legacy models
+  {
+    id: "claude-opus-4-1-20250805",
+    name: "Claude Opus 4.1",
+    provider: "anthropic",
+    model: "claude-opus-4-1-20250805",
+    description: "Previous generation premium model with extended thinking",
+    available: true
+  },
+  {
+    id: "claude-sonnet-4-20250514",
+    name: "Claude Sonnet 4",
+    provider: "anthropic",
+    model: "claude-sonnet-4-20250514",
+    description: "Fast and capable previous generation model",
+    available: true
+  },
+  // OpenAI GPT-5 series (latest as of Jan 2026)
+  {
+    id: "gpt-5.2",
+    name: "GPT-5.2",
+    provider: "openai",
+    model: "gpt-5.2",
+    description: "Latest flagship with enhanced coding and agentic capabilities",
+    available: true
+  },
+  {
+    id: "gpt-5.1",
+    name: "GPT-5.1",
+    provider: "openai",
+    model: "gpt-5.1",
+    description: "Advanced reasoning and robust performance",
+    available: true
+  },
+  // OpenAI o-series reasoning models
+  {
+    id: "o3",
+    name: "o3",
+    provider: "openai",
+    model: "o3",
+    description: "Advanced reasoning for complex problem-solving",
+    available: true
+  },
+  {
+    id: "o3-mini",
+    name: "o3 Mini",
+    provider: "openai",
+    model: "o3-mini",
+    description: "Cost-effective reasoning with faster response times",
+    available: true
+  },
+  {
+    id: "o4-mini",
+    name: "o4 Mini",
+    provider: "openai",
+    model: "o4-mini",
+    description: "Fast, efficient reasoning model succeeding o3",
+    available: true
+  },
+  {
+    id: "o1",
+    name: "o1",
+    provider: "openai",
+    model: "o1",
+    description: "Premium reasoning for research, coding, math and science",
+    available: true
+  },
+  // OpenAI GPT-4 series
+  {
+    id: "gpt-4.1",
+    name: "GPT-4.1",
+    provider: "openai",
+    model: "gpt-4.1",
+    description: "Strong instruction-following with 1M context window",
+    available: true
+  },
+  {
+    id: "gpt-4.1-mini",
+    name: "GPT-4.1 Mini",
+    provider: "openai",
+    model: "gpt-4.1-mini",
+    description: "Faster, smaller version balancing performance and efficiency",
+    available: true
+  },
+  {
+    id: "gpt-4.1-nano",
+    name: "GPT-4.1 Nano",
+    provider: "openai",
+    model: "gpt-4.1-nano",
+    description: "Most cost-efficient for lighter tasks",
+    available: true
+  },
+  {
+    id: "gpt-4o",
+    name: "GPT-4o",
+    provider: "openai",
+    model: "gpt-4o",
+    description: "Versatile model for text generation and comprehension",
+    available: true
+  },
+  {
+    id: "gpt-4o-mini",
+    name: "GPT-4o Mini",
+    provider: "openai",
+    model: "gpt-4o-mini",
+    description: "Cost-efficient variant with faster response times",
+    available: true
+  },
+  // Google Gemini models
+  {
+    id: "gemini-3-pro-preview",
+    name: "Gemini 3 Pro Preview",
+    provider: "google",
+    model: "gemini-3-pro-preview",
+    description: "State-of-the-art reasoning and multimodal understanding",
+    available: true
+  },
+  {
+    id: "gemini-2.5-pro",
+    name: "Gemini 2.5 Pro",
+    provider: "google",
+    model: "gemini-2.5-pro",
+    description: "High-capability model for complex reasoning and coding",
+    available: true
+  },
+  {
+    id: "gemini-2.5-flash",
+    name: "Gemini 2.5 Flash",
+    provider: "google",
+    model: "gemini-2.5-flash",
+    description: "Lightning-fast with balance of intelligence and latency",
+    available: true
+  },
+  {
+    id: "gemini-2.5-flash-lite",
+    name: "Gemini 2.5 Flash Lite",
+    provider: "google",
+    model: "gemini-2.5-flash-lite",
+    description: "Fast, low-cost, high-performance model",
+    available: true
+  },
+  // Custom API
+  {
+    id: "custom",
+    name: "Custom API",
+    provider: "custom",
+    model: "custom",
+    description: "Use your own OpenAI-compatible API endpoint",
+    available: true
+  }
+];
+function registerModelHandlers(ipcMain) {
+  ipcMain.handle("models:list", async () => {
+    return AVAILABLE_MODELS.map((model) => ({
+      ...model,
+      available: model.provider === "custom" ? hasCustomApiConfig() : hasApiKey(model.provider)
+    }));
+  });
+  ipcMain.handle("models:getDefault", async () => {
+    return store.get("defaultModel", "claude-sonnet-4-5-20250929");
+  });
+  ipcMain.handle("models:setDefault", async (_event, modelId) => {
+    store.set("defaultModel", modelId);
+  });
+  ipcMain.handle(
+    "models:setApiKey",
+    async (_event, { provider, apiKey }) => {
+      setApiKey(provider, apiKey);
+    }
+  );
+  ipcMain.handle("models:getApiKey", async (_event, provider) => {
+    return getApiKey(provider) ?? null;
+  });
+  ipcMain.handle("models:deleteApiKey", async (_event, provider) => {
+    deleteApiKey(provider);
+  });
+  ipcMain.handle("models:listProviders", async () => {
+    return PROVIDERS.map((provider) => ({
+      ...provider,
+      hasApiKey: provider.id === "custom" ? hasCustomApiConfig() : hasApiKey(provider.id)
+    }));
+  });
+  ipcMain.handle("models:getCustomApiConfig", async () => {
+    return getCustomApiConfig() ?? null;
+  });
+  ipcMain.handle("models:setCustomApiConfig", async (_event, config) => {
+    setCustomApiConfig(config);
+  });
+  ipcMain.handle("models:deleteCustomApiConfig", async () => {
+    deleteCustomApiConfig();
+  });
+  ipcMain.on("app:version", (event) => {
+    event.returnValue = electron.app.getVersion();
+  });
+  ipcMain.handle("workspace:get", async (_event, threadId) => {
+    if (!threadId) {
+      return store.get("workspacePath", null);
+    }
+    const { getThread: getThread2 } = await Promise.resolve().then(() => index);
+    const thread = getThread2(threadId);
+    if (!thread?.metadata) return null;
+    const metadata = JSON.parse(thread.metadata);
+    return metadata.workspacePath || null;
+  });
+  ipcMain.handle(
+    "workspace:set",
+    async (_event, { threadId, path: newPath }) => {
+      if (!threadId) {
+        if (newPath) {
+          store.set("workspacePath", newPath);
+        } else {
+          store.delete("workspacePath");
+        }
+        return newPath;
+      }
+      const { getThread: getThread2, updateThread: updateThread2 } = await Promise.resolve().then(() => index);
+      const thread = getThread2(threadId);
+      if (!thread) return null;
+      const metadata = thread.metadata ? JSON.parse(thread.metadata) : {};
+      metadata.workspacePath = newPath;
+      updateThread2(threadId, { metadata: JSON.stringify(metadata) });
+      if (newPath) {
+        startWatching(threadId, newPath);
+      } else {
+        stopWatching(threadId);
+      }
+      return newPath;
+    }
+  );
+  ipcMain.handle("workspace:select", async (_event, threadId) => {
+    const result = await electron.dialog.showOpenDialog({
+      properties: ["openDirectory", "createDirectory"],
+      title: "Select Workspace Folder",
+      message: "Choose a folder for the agent to work in"
+    });
+    if (result.canceled || result.filePaths.length === 0) {
+      return null;
+    }
+    const selectedPath = result.filePaths[0];
+    if (threadId) {
+      const { getThread: getThread2, updateThread: updateThread2 } = await Promise.resolve().then(() => index);
+      const thread = getThread2(threadId);
+      if (thread) {
+        const metadata = thread.metadata ? JSON.parse(thread.metadata) : {};
+        metadata.workspacePath = selectedPath;
+        updateThread2(threadId, { metadata: JSON.stringify(metadata) });
+        startWatching(threadId, selectedPath);
+      }
+    } else {
+      store.set("workspacePath", selectedPath);
+    }
+    return selectedPath;
+  });
+  ipcMain.handle("workspace:loadFromDisk", async (_event, { threadId }) => {
+    const { getThread: getThread2 } = await Promise.resolve().then(() => index);
+    const thread = getThread2(threadId);
+    const metadata = thread?.metadata ? JSON.parse(thread.metadata) : {};
+    const workspacePath = metadata.workspacePath;
+    if (!workspacePath) {
+      return { success: false, error: "No workspace folder linked", files: [] };
+    }
+    try {
+      const files = [];
+      async function readDir(dirPath, relativePath = "") {
+        const entries = await fs__namespace$1.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.name.startsWith(".") || entry.name === "node_modules") {
+            continue;
+          }
+          const fullPath = path__namespace.join(dirPath, entry.name);
+          const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+          if (entry.isDirectory()) {
+            files.push({
+              path: "/" + relPath,
+              is_dir: true
+            });
+            await readDir(fullPath, relPath);
+          } else {
+            const stat = await fs__namespace$1.stat(fullPath);
+            files.push({
+              path: "/" + relPath,
+              is_dir: false,
+              size: stat.size,
+              modified_at: stat.mtime.toISOString()
+            });
+          }
+        }
+      }
+      await readDir(workspacePath);
+      startWatching(threadId, workspacePath);
+      return {
+        success: true,
+        files,
+        workspacePath
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e instanceof Error ? e.message : "Unknown error",
+        files: []
+      };
+    }
+  });
+  ipcMain.handle(
+    "workspace:readFile",
+    async (_event, { threadId, filePath }) => {
+      const { getThread: getThread2 } = await Promise.resolve().then(() => index);
+      const thread = getThread2(threadId);
+      const metadata = thread?.metadata ? JSON.parse(thread.metadata) : {};
+      const workspacePath = metadata.workspacePath;
+      if (!workspacePath) {
+        return {
+          success: false,
+          error: "No workspace folder linked"
+        };
+      }
+      try {
+        const relativePath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+        const fullPath = path__namespace.join(workspacePath, relativePath);
+        const resolvedPath = path__namespace.resolve(fullPath);
+        const resolvedWorkspace = path__namespace.resolve(workspacePath);
+        if (!resolvedPath.startsWith(resolvedWorkspace)) {
+          return { success: false, error: "Access denied: path outside workspace" };
+        }
+        const stat = await fs__namespace$1.stat(fullPath);
+        if (stat.isDirectory()) {
+          return { success: false, error: "Cannot read directory as file" };
+        }
+        const content = await fs__namespace$1.readFile(fullPath, "utf-8");
+        return {
+          success: true,
+          content,
+          size: stat.size,
+          modified_at: stat.mtime.toISOString()
+        };
+      } catch (e) {
+        return {
+          success: false,
+          error: e instanceof Error ? e.message : "Unknown error"
+        };
+      }
+    }
+  );
+  ipcMain.handle(
+    "workspace:readBinaryFile",
+    async (_event, { threadId, filePath }) => {
+      const { getThread: getThread2 } = await Promise.resolve().then(() => index);
+      const thread = getThread2(threadId);
+      const metadata = thread?.metadata ? JSON.parse(thread.metadata) : {};
+      const workspacePath = metadata.workspacePath;
+      if (!workspacePath) {
+        return {
+          success: false,
+          error: "No workspace folder linked"
+        };
+      }
+      try {
+        const relativePath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+        const fullPath = path__namespace.join(workspacePath, relativePath);
+        const resolvedPath = path__namespace.resolve(fullPath);
+        const resolvedWorkspace = path__namespace.resolve(workspacePath);
+        if (!resolvedPath.startsWith(resolvedWorkspace)) {
+          return { success: false, error: "Access denied: path outside workspace" };
+        }
+        const stat = await fs__namespace$1.stat(fullPath);
+        if (stat.isDirectory()) {
+          return { success: false, error: "Cannot read directory as file" };
+        }
+        const buffer = await fs__namespace$1.readFile(fullPath);
+        const base64 = buffer.toString("base64");
+        return {
+          success: true,
+          content: base64,
+          size: stat.size,
+          modified_at: stat.mtime.toISOString()
+        };
+      } catch (e) {
+        return {
+          success: false,
+          error: e instanceof Error ? e.message : "Unknown error"
+        };
+      }
+    }
+  );
+}
+function getDefaultModel() {
+  return store.get("defaultModel", "claude-sonnet-4-5-20250929");
+}
+class SqlJsSaver extends langgraphCheckpoint.BaseCheckpointSaver {
+  db = null;
+  dbPath;
+  isSetup = false;
+  saveTimer = null;
+  dirty = false;
+  constructor(dbPath, serde) {
+    super(serde);
+    this.dbPath = dbPath;
+  }
+  /**
+   * Initialize the database asynchronously
+   */
+  async initialize() {
+    if (this.db) return;
+    const SQL = await initSqlJs();
+    if (fs.existsSync(this.dbPath)) {
+      const stats = fs.statSync(this.dbPath);
+      const MAX_DB_SIZE = 100 * 1024 * 1024;
+      if (stats.size > MAX_DB_SIZE) {
+        console.warn(
+          `[SqlJsSaver] Database file is too large (${Math.round(stats.size / 1024 / 1024)}MB). Creating fresh database to prevent memory issues.`
+        );
+        const backupPath = this.dbPath + ".bak." + Date.now();
+        try {
+          fs.renameSync(this.dbPath, backupPath);
+          console.log(`[SqlJsSaver] Old database backed up to: ${backupPath}`);
+        } catch (e) {
+          console.warn("[SqlJsSaver] Could not backup old database:", e);
+          try {
+            fs.unlinkSync(this.dbPath);
+          } catch (e2) {
+            console.error("[SqlJsSaver] Could not delete old database:", e2);
+          }
+        }
+        this.db = new SQL.Database();
+      } else {
+        const buffer = fs.readFileSync(this.dbPath);
+        this.db = new SQL.Database(buffer);
+      }
+    } else {
+      const dir = path.dirname(this.dbPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      this.db = new SQL.Database();
+    }
+    this.setup();
+  }
+  setup() {
+    if (this.isSetup || !this.db) return;
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS checkpoints (
+        thread_id TEXT NOT NULL,
+        checkpoint_ns TEXT NOT NULL DEFAULT '',
+        checkpoint_id TEXT NOT NULL,
+        parent_checkpoint_id TEXT,
+        type TEXT,
+        checkpoint TEXT,
+        metadata TEXT,
+        PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS writes (
+        thread_id TEXT NOT NULL,
+        checkpoint_ns TEXT NOT NULL DEFAULT '',
+        checkpoint_id TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        idx INTEGER NOT NULL,
+        channel TEXT NOT NULL,
+        type TEXT,
+        value TEXT,
+        PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
+      )
+    `);
+    this.isSetup = true;
+    this.saveToDisk();
+  }
+  /**
+   * Save database to disk (debounced)
+   */
+  saveToDisk() {
+    if (!this.db) return;
+    this.dirty = true;
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+    }
+    this.saveTimer = setTimeout(() => {
+      if (this.db && this.dirty) {
+        const data = this.db.export();
+        fs.writeFileSync(this.dbPath, Buffer.from(data));
+        this.dirty = false;
+      }
+    }, 100);
+  }
+  /**
+   * Force immediate save to disk
+   */
+  async flush() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+    if (this.db && this.dirty) {
+      const data = this.db.export();
+      fs.writeFileSync(this.dbPath, Buffer.from(data));
+      this.dirty = false;
+    }
+  }
+  async getTuple(config) {
+    await this.initialize();
+    if (!this.db) throw new Error("Database not initialized");
+    const { thread_id, checkpoint_ns = "", checkpoint_id } = config.configurable ?? {};
+    let sql;
+    let params;
+    if (checkpoint_id) {
+      sql = `
+        SELECT thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata
+        FROM checkpoints
+        WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?
+      `;
+      params = [thread_id, checkpoint_ns, checkpoint_id];
+    } else {
+      sql = `
+        SELECT thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata
+        FROM checkpoints
+        WHERE thread_id = ? AND checkpoint_ns = ?
+        ORDER BY checkpoint_id DESC
+        LIMIT 1
+      `;
+      params = [thread_id, checkpoint_ns];
+    }
+    const stmt = this.db.prepare(sql);
+    stmt.bind(params.filter((p) => p !== void 0));
+    if (!stmt.step()) {
+      stmt.free();
+      return void 0;
+    }
+    const row = stmt.getAsObject();
+    stmt.free();
+    const writesStmt = this.db.prepare(`
+      SELECT task_id, channel, type, value
+      FROM writes
+      WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?
+    `);
+    writesStmt.bind([row.thread_id, row.checkpoint_ns, row.checkpoint_id]);
+    const pendingWrites = [];
+    while (writesStmt.step()) {
+      const write = writesStmt.getAsObject();
+      const value = await this.serde.loadsTyped(write.type ?? "json", write.value ?? "");
+      pendingWrites.push([write.task_id, write.channel, value]);
+    }
+    writesStmt.free();
+    const checkpoint = await this.serde.loadsTyped(
+      row.type ?? "json",
+      row.checkpoint
+    );
+    const finalConfig = checkpoint_id ? config : {
+      configurable: {
+        thread_id: row.thread_id,
+        checkpoint_ns: row.checkpoint_ns,
+        checkpoint_id: row.checkpoint_id
+      }
+    };
+    return {
+      checkpoint,
+      config: finalConfig,
+      metadata: await this.serde.loadsTyped(
+        row.type ?? "json",
+        row.metadata
+      ),
+      parentConfig: row.parent_checkpoint_id ? {
+        configurable: {
+          thread_id: row.thread_id,
+          checkpoint_ns: row.checkpoint_ns,
+          checkpoint_id: row.parent_checkpoint_id
+        }
+      } : void 0,
+      pendingWrites
+    };
+  }
+  async *list(config, options) {
+    await this.initialize();
+    if (!this.db) throw new Error("Database not initialized");
+    const { limit, before } = options ?? {};
+    const thread_id = config.configurable?.thread_id;
+    const checkpoint_ns = config.configurable?.checkpoint_ns ?? "";
+    let sql = `
+      SELECT thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata
+      FROM checkpoints
+      WHERE thread_id = ? AND checkpoint_ns = ?
+    `;
+    const params = [thread_id, checkpoint_ns];
+    if (before?.configurable?.checkpoint_id) {
+      sql += ` AND checkpoint_id < ?`;
+      params.push(before.configurable.checkpoint_id);
+    }
+    sql += ` ORDER BY checkpoint_id DESC`;
+    if (limit) {
+      sql += ` LIMIT ${parseInt(String(limit), 10)}`;
+    }
+    const stmt = this.db.prepare(sql);
+    stmt.bind(params);
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      const writesStmt = this.db.prepare(`
+        SELECT task_id, channel, type, value
+        FROM writes
+        WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?
+      `);
+      writesStmt.bind([row.thread_id, row.checkpoint_ns, row.checkpoint_id]);
+      const pendingWrites = [];
+      while (writesStmt.step()) {
+        const write = writesStmt.getAsObject();
+        const value = await this.serde.loadsTyped(write.type ?? "json", write.value ?? "");
+        pendingWrites.push([write.task_id, write.channel, value]);
+      }
+      writesStmt.free();
+      const checkpoint = await this.serde.loadsTyped(
+        row.type ?? "json",
+        row.checkpoint
+      );
+      yield {
+        config: {
+          configurable: {
+            thread_id: row.thread_id,
+            checkpoint_ns: row.checkpoint_ns,
+            checkpoint_id: row.checkpoint_id
+          }
+        },
+        checkpoint,
+        metadata: await this.serde.loadsTyped(
+          row.type ?? "json",
+          row.metadata
+        ),
+        parentConfig: row.parent_checkpoint_id ? {
+          configurable: {
+            thread_id: row.thread_id,
+            checkpoint_ns: row.checkpoint_ns,
+            checkpoint_id: row.parent_checkpoint_id
+          }
+        } : void 0,
+        pendingWrites
+      };
+    }
+    stmt.free();
+  }
+  async put(config, checkpoint, metadata) {
+    await this.initialize();
+    if (!this.db) throw new Error("Database not initialized");
+    if (!config.configurable) {
+      throw new Error("Empty configuration supplied.");
+    }
+    const thread_id = config.configurable?.thread_id;
+    const checkpoint_ns = config.configurable?.checkpoint_ns ?? "";
+    const parent_checkpoint_id = config.configurable?.checkpoint_id;
+    if (!thread_id) {
+      throw new Error('Missing "thread_id" field in passed "config.configurable".');
+    }
+    const preparedCheckpoint = langgraphCheckpoint.copyCheckpoint(checkpoint);
+    const [[type1, serializedCheckpoint], [type2, serializedMetadata]] = await Promise.all([
+      this.serde.dumpsTyped(preparedCheckpoint),
+      this.serde.dumpsTyped(metadata)
+    ]);
+    if (type1 !== type2) {
+      throw new Error("Failed to serialize checkpoint and metadata to the same type.");
+    }
+    this.db.run(
+      `INSERT OR REPLACE INTO checkpoints 
+       (thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata) 
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [
+        thread_id,
+        checkpoint_ns,
+        checkpoint.id,
+        parent_checkpoint_id ?? null,
+        type1,
+        serializedCheckpoint,
+        serializedMetadata
+      ]
+    );
+    this.saveToDisk();
+    return {
+      configurable: {
+        thread_id,
+        checkpoint_ns,
+        checkpoint_id: checkpoint.id
+      }
+    };
+  }
+  async putWrites(config, writes, taskId) {
+    await this.initialize();
+    if (!this.db) throw new Error("Database not initialized");
+    if (!config.configurable) {
+      throw new Error("Empty configuration supplied.");
+    }
+    if (!config.configurable?.thread_id) {
+      throw new Error("Missing thread_id field in config.configurable.");
+    }
+    if (!config.configurable?.checkpoint_id) {
+      throw new Error("Missing checkpoint_id field in config.configurable.");
+    }
+    for (let idx = 0; idx < writes.length; idx++) {
+      const write = writes[idx];
+      const [type, serializedWrite] = await this.serde.dumpsTyped(write[1]);
+      this.db.run(
+        `INSERT OR REPLACE INTO writes 
+         (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, value) 
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          config.configurable.thread_id,
+          config.configurable.checkpoint_ns ?? "",
+          config.configurable.checkpoint_id,
+          taskId,
+          idx,
+          write[0],
+          type,
+          serializedWrite
+        ]
+      );
+    }
+    this.saveToDisk();
+  }
+  async deleteThread(threadId) {
+    await this.initialize();
+    if (!this.db) throw new Error("Database not initialized");
+    this.db.run(`DELETE FROM checkpoints WHERE thread_id = ?`, [threadId]);
+    this.db.run(`DELETE FROM writes WHERE thread_id = ?`, [threadId]);
+    this.saveToDisk();
+  }
+  /**
+   * Close the database and save any pending changes
+   */
+  async close() {
+    await this.flush();
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+}
+class LocalSandbox extends deepagents.FilesystemBackend {
+  /** Unique identifier for this sandbox instance */
+  id;
+  timeout;
+  maxOutputBytes;
+  env;
+  workingDir;
+  constructor(options = {}) {
+    super({
+      rootDir: options.rootDir,
+      virtualMode: options.virtualMode,
+      maxFileSizeMb: options.maxFileSizeMb
+    });
+    this.id = `local-sandbox-${node_crypto.randomUUID().slice(0, 8)}`;
+    this.timeout = options.timeout ?? 12e4;
+    this.maxOutputBytes = options.maxOutputBytes ?? 1e5;
+    this.env = options.env ?? { ...process.env };
+    this.workingDir = options.rootDir ?? process.cwd();
+  }
+  /**
+   * Execute a shell command in the workspace directory.
+   *
+   * @param command - Shell command string to execute
+   * @returns ExecuteResponse with combined output, exit code, and truncation flag
+   *
+   * @example
+   * ```typescript
+   * const result = await sandbox.execute('echo "Hello World"');
+   * // result.output: "Hello World\n"
+   * // result.exitCode: 0
+   * // result.truncated: false
+   * ```
+   */
+  async execute(command) {
+    if (!command || typeof command !== "string") {
+      return {
+        output: "Error: Shell tool expects a non-empty command string.",
+        exitCode: 1,
+        truncated: false
+      };
+    }
+    return new Promise((resolve) => {
+      const outputParts = [];
+      let totalBytes = 0;
+      let truncated = false;
+      let resolved = false;
+      const isWindows = process.platform === "win32";
+      const shell = isWindows ? "cmd.exe" : "/bin/sh";
+      const shellArgs = isWindows ? ["/c", command] : ["-c", command];
+      const proc = node_child_process.spawn(shell, shellArgs, {
+        cwd: this.workingDir,
+        env: this.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const timeoutId = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          proc.kill("SIGTERM");
+          setTimeout(() => proc.kill("SIGKILL"), 1e3);
+          resolve({
+            output: `Error: Command timed out after ${(this.timeout / 1e3).toFixed(1)} seconds.`,
+            exitCode: null,
+            truncated: false
+          });
+        }
+      }, this.timeout);
+      proc.stdout.on("data", (data) => {
+        if (truncated) return;
+        const chunk = data.toString();
+        const newTotal = totalBytes + chunk.length;
+        if (newTotal > this.maxOutputBytes) {
+          const remaining = this.maxOutputBytes - totalBytes;
+          if (remaining > 0) {
+            outputParts.push(chunk.slice(0, remaining));
+          }
+          truncated = true;
+          totalBytes = this.maxOutputBytes;
+        } else {
+          outputParts.push(chunk);
+          totalBytes = newTotal;
+        }
+      });
+      proc.stderr.on("data", (data) => {
+        if (truncated) return;
+        const chunk = data.toString();
+        const prefixedLines = chunk.split("\n").filter((line) => line.length > 0).map((line) => `[stderr] ${line}`).join("\n");
+        if (prefixedLines.length === 0) return;
+        const withNewline = prefixedLines + (chunk.endsWith("\n") ? "\n" : "");
+        const newTotal = totalBytes + withNewline.length;
+        if (newTotal > this.maxOutputBytes) {
+          const remaining = this.maxOutputBytes - totalBytes;
+          if (remaining > 0) {
+            outputParts.push(withNewline.slice(0, remaining));
+          }
+          truncated = true;
+          totalBytes = this.maxOutputBytes;
+        } else {
+          outputParts.push(withNewline);
+          totalBytes = newTotal;
+        }
+      });
+      proc.on("close", (code, signal) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timeoutId);
+        let output = outputParts.join("");
+        if (truncated) {
+          output += `
+
+... Output truncated at ${this.maxOutputBytes} bytes.`;
+        }
+        if (!output.trim()) {
+          output = "<no output>";
+        }
+        resolve({
+          output,
+          exitCode: signal ? null : code,
+          truncated
+        });
+      });
+      proc.on("error", (err) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timeoutId);
+        resolve({
+          output: `Error: Failed to execute command: ${err.message}`,
+          exitCode: 1,
+          truncated: false
+        });
+      });
+    });
+  }
+}
+const BASE_SYSTEM_PROMPT = `You are an AI assistant that helps users with various tasks including coding, research, and analysis.
+
+# Core Behavior
+
+Be concise and direct. Answer in fewer than 4 lines unless the user asks for detail.
+After working on a file, just stop - don't explain what you did unless asked.
+Avoid unnecessary introductions or conclusions.
+
+When you run non-trivial bash commands, briefly explain what they do.
+
+## Proactiveness
+Take action when asked, but don't surprise users with unrequested actions.
+If asked how to approach something, answer first before taking action.
+
+## Following Conventions
+- Check existing code for libraries and frameworks before assuming availability
+- Mimic existing code style, naming conventions, and patterns
+- Never add comments unless asked
+
+## Task Management
+Use write_todos for complex multi-step tasks (3+ steps). Mark tasks in_progress before starting, completed immediately after finishing.
+For simple 1-2 step tasks, just do them directly without todos.
+
+## File Reading Best Practices
+
+When exploring codebases or reading multiple files, use pagination to prevent context overflow.
+
+**Pattern for codebase exploration:**
+1. First scan: \`read_file(path, limit=100)\` - See file structure and key sections
+2. Targeted read: \`read_file(path, offset=100, limit=200)\` - Read specific sections if needed
+3. Full read: Only use \`read_file(path)\` without limit when necessary for editing
+
+**When to paginate:**
+- Reading any file >500 lines
+- Exploring unfamiliar codebases (always start with limit=100)
+- Reading multiple files in sequence
+
+**When full read is OK:**
+- Small files (<500 lines)
+- Files you need to edit immediately after reading
+
+## Working with Subagents (task tool)
+When delegating to subagents:
+- **Use filesystem for large I/O**: If input/output is large (>500 words), communicate via files
+- **Parallelize independent work**: Spawn parallel subagents for independent tasks
+- **Clear specifications**: Tell subagent exactly what format/structure you need
+- **Main agent synthesizes**: Subagents gather/execute, main agent integrates results
+
+## Tools
+
+### File Tools
+- read_file: Read file contents
+- edit_file: Replace exact strings in files (must read first, provide unique old_string)
+- write_file: Create or overwrite files
+- ls: List directory contents
+- glob: Find files by pattern (e.g., "**/*.py")
+- grep: Search file contents
+
+All file paths should use fully qualified absolute system paths (e.g., /Users/name/project/src/file.ts).
+
+### Shell Tool
+- execute: Run shell commands in the workspace directory
+
+The execute tool runs commands directly on the user's machine. Use it for:
+- Running scripts, tests, and builds (npm test, python script.py, make)
+- Git operations (git status, git diff, git commit)
+- Installing dependencies (npm install, pip install)
+- System commands (which, env, pwd)
+
+**Important:**
+- All execute commands require user approval before running
+- Commands run in the workspace root directory
+- Avoid using shell for file reading (use read_file instead)
+- Avoid using shell for file searching (use grep/glob instead)
+- When running non-trivial commands, briefly explain what they do
+
+## Code References
+When referencing code, use format: \`file_path:line_number\`
+
+## Documentation
+- Do NOT create excessive markdown summary/documentation files after completing work
+- Focus on the work itself, not documenting what you did
+- Only create documentation when explicitly requested
+
+## Human-in-the-Loop Tool Approval
+
+Some tool calls require user approval before execution. When a tool call is rejected by the user:
+1. Accept their decision immediately - do NOT retry the same command
+2. Explain that you understand they rejected the action
+3. Suggest an alternative approach or ask for clarification
+4. Never attempt the exact same rejected command again
+
+Respect the user's decisions and work with them collaboratively.
+
+## Todo List Management
+
+When using the write_todos tool:
+1. Keep the todo list MINIMAL - aim for 3-6 items maximum
+2. Only create todos for complex, multi-step tasks that truly need tracking
+3. Break down work into clear, actionable items without over-fragmenting
+4. For simple tasks (1-2 steps), just do them directly without creating todos
+5. When first creating a todo list for a task, ALWAYS ask the user if the plan looks good before starting work
+   - Create the todos, let them render, then ask: "Does this plan look good?" or similar
+   - Wait for the user's response before marking the first todo as in_progress
+   - If they want changes, adjust the plan accordingly
+6. Update todo status promptly as you complete each item
+
+The todo list is a planning tool - use it judiciously to avoid overwhelming the user with excessive task tracking.
+`;
+function getSystemPrompt(workspacePath) {
+  const workingDirSection = `
+### File System and Paths
+
+**IMPORTANT - Path Handling:**
+- All file paths use fully qualified absolute system paths
+- The workspace root is: \`${workspacePath}\`
+- Example: \`${workspacePath}/src/index.ts\`, \`${workspacePath}/README.md\`
+- To list the workspace root, use \`ls("${workspacePath}")\`
+- Always use full absolute paths for all file operations
+`;
+  return workingDirSection + BASE_SYSTEM_PROMPT;
+}
+const checkpointers = /* @__PURE__ */ new Map();
+async function getCheckpointer(threadId) {
+  let checkpointer = checkpointers.get(threadId);
+  if (!checkpointer) {
+    const dbPath = getThreadCheckpointPath(threadId);
+    checkpointer = new SqlJsSaver(dbPath);
+    await checkpointer.initialize();
+    checkpointers.set(threadId, checkpointer);
+  }
+  return checkpointer;
+}
+async function closeCheckpointer(threadId) {
+  const checkpointer = checkpointers.get(threadId);
+  if (checkpointer) {
+    await checkpointer.close();
+    checkpointers.delete(threadId);
+  }
+}
+function getModelInstance(modelId) {
+  const model = modelId || getDefaultModel();
+  console.log("[Runtime] Using model:", model);
+  if (model === "custom" || model.startsWith("custom-")) {
+    const customConfig = getCustomApiConfig();
+    console.log("[Runtime] Custom API config present:", !!customConfig);
+    if (!customConfig) {
+      throw new Error("Custom API configuration not set");
+    }
+    console.log("[Runtime] Custom API config:", {
+      baseUrl: customConfig.baseUrl,
+      model: customConfig.model,
+      apiKeyLength: customConfig.apiKey?.length,
+      apiKeyPrefix: customConfig.apiKey?.substring(0, 10),
+      apiKeySuffix: customConfig.apiKey?.substring(customConfig.apiKey.length - 10),
+      apiKeyHasNewline: customConfig.apiKey?.includes("\n"),
+      apiKeyHasSpace: customConfig.apiKey?.includes(" ")
+    });
+    const chatModel = new openai.ChatOpenAI({
+      model: customConfig.model || model,
+      apiKey: customConfig.apiKey,
+      // 尝试使用 apiKey 而不是 openAIApiKey
+      configuration: {
+        baseURL: customConfig.baseUrl
+      },
+      timeout: 6e4,
+      // 60 seconds timeout
+      maxRetries: 2
+    });
+    console.log("[Runtime] ChatOpenAI instance created");
+    return chatModel;
+  }
+  if (model.startsWith("claude")) {
+    const apiKey = getApiKey("anthropic");
+    console.log("[Runtime] Anthropic API key present:", !!apiKey);
+    if (!apiKey) {
+      throw new Error("Anthropic API key not configured");
+    }
+    return new anthropic.ChatAnthropic({
+      model,
+      anthropicApiKey: apiKey
+    });
+  } else if (model.startsWith("gpt") || model.startsWith("o1") || model.startsWith("o3") || model.startsWith("o4")) {
+    const apiKey = getApiKey("openai");
+    console.log("[Runtime] OpenAI API key present:", !!apiKey);
+    if (!apiKey) {
+      throw new Error("OpenAI API key not configured");
+    }
+    return new openai.ChatOpenAI({
+      model,
+      openAIApiKey: apiKey
+    });
+  } else if (model.startsWith("gemini")) {
+    const apiKey = getApiKey("google");
+    console.log("[Runtime] Google API key present:", !!apiKey);
+    if (!apiKey) {
+      throw new Error("Google API key not configured");
+    }
+    return new googleGenai.ChatGoogleGenerativeAI({
+      model,
+      apiKey
+    });
+  }
+  return model;
+}
+async function createAgentRuntime(options) {
+  const { threadId, modelId, workspacePath } = options;
+  if (!threadId) {
+    throw new Error("Thread ID is required for checkpointing.");
+  }
+  if (!workspacePath) {
+    throw new Error(
+      "Workspace path is required. Please select a workspace folder before running the agent."
+    );
+  }
+  console.log("[Runtime] Creating agent runtime...");
+  console.log("[Runtime] Thread ID:", threadId);
+  console.log("[Runtime] Workspace path:", workspacePath);
+  const model = getModelInstance(modelId);
+  console.log("[Runtime] Model instance created:", typeof model);
+  const checkpointer = await getCheckpointer(threadId);
+  console.log("[Runtime] Checkpointer ready for thread:", threadId);
+  const backend = new LocalSandbox({
+    rootDir: workspacePath,
+    virtualMode: false,
+    // Use absolute system paths for consistency with shell commands
+    timeout: 12e4,
+    // 2 minutes
+    maxOutputBytes: 1e5
+    // ~100KB
+  });
+  const systemPrompt = getSystemPrompt(workspacePath);
+  const filesystemSystemPrompt = `You have access to a filesystem. All file paths use fully qualified absolute system paths.
+
+- ls: list files in a directory (e.g., ls("${workspacePath}"))
+- read_file: read a file from the filesystem
+- write_file: write to a file in the filesystem
+- edit_file: edit a file in the filesystem
+- glob: find files matching a pattern (e.g., "**/*.py")
+- grep: search for text within files
+
+The workspace root is: ${workspacePath}`;
+  const agent = deepagents.createDeepAgent({
+    model,
+    checkpointer,
+    backend,
+    systemPrompt,
+    // Custom filesystem prompt for absolute paths (requires deepagents update)
+    filesystemSystemPrompt,
+    // Require human approval for all shell commands
+    interruptOn: { execute: true }
+  });
+  console.log("[Runtime] Deep agent created with LocalSandbox at:", workspacePath);
+  return agent;
+}
+let db = null;
+let saveTimer = null;
+let dirty = false;
+function saveToDisk() {
+  if (!db) return;
+  dirty = true;
+  if (saveTimer) {
+    clearTimeout(saveTimer);
+  }
+  saveTimer = setTimeout(() => {
+    if (db && dirty) {
+      const data = db.export();
+      fs.writeFileSync(getDbPath(), Buffer.from(data));
+      dirty = false;
+    }
+  }, 100);
+}
+function getDb() {
+  if (!db) {
+    throw new Error("Database not initialized. Call initializeDatabase() first.");
+  }
+  return db;
+}
+async function initializeDatabase() {
+  const dbPath = getDbPath();
+  console.log("Initializing database at:", dbPath);
+  const SQL = await initSqlJs();
+  if (fs.existsSync(dbPath)) {
+    const buffer = fs.readFileSync(dbPath);
+    db = new SQL.Database(buffer);
+  } else {
+    const dir = path.dirname(dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    db = new SQL.Database();
+  }
+  db.run(`
+    CREATE TABLE IF NOT EXISTS threads (
+      thread_id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      metadata TEXT,
+      status TEXT DEFAULT 'idle',
+      thread_values TEXT,
+      title TEXT
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS runs (
+      run_id TEXT PRIMARY KEY,
+      thread_id TEXT REFERENCES threads(thread_id) ON DELETE CASCADE,
+      assistant_id TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      status TEXT,
+      metadata TEXT,
+      kwargs TEXT
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS assistants (
+      assistant_id TEXT PRIMARY KEY,
+      graph_id TEXT NOT NULL,
+      name TEXT,
+      model TEXT DEFAULT 'claude-sonnet-4-5-20250929',
+      config TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_threads_updated_at ON threads(updated_at)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_runs_thread_id ON runs(thread_id)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status)`);
+  saveToDisk();
+  console.log("Database initialized successfully");
+  return db;
+}
+function getAllThreads() {
+  const database = getDb();
+  const stmt = database.prepare("SELECT * FROM threads ORDER BY updated_at DESC");
+  const threads = [];
+  while (stmt.step()) {
+    threads.push(stmt.getAsObject());
+  }
+  stmt.free();
+  return threads;
+}
+function getThread(threadId) {
+  const database = getDb();
+  const stmt = database.prepare("SELECT * FROM threads WHERE thread_id = ?");
+  stmt.bind([threadId]);
+  if (!stmt.step()) {
+    stmt.free();
+    return null;
+  }
+  const thread = stmt.getAsObject();
+  stmt.free();
+  return thread;
+}
+function createThread(threadId, metadata) {
+  const database = getDb();
+  const now = Date.now();
+  database.run(
+    `INSERT INTO threads (thread_id, created_at, updated_at, metadata, status)
+     VALUES (?, ?, ?, ?, ?)`,
+    [threadId, now, now, metadata ? JSON.stringify(metadata) : null, "idle"]
+  );
+  saveToDisk();
+  return {
+    thread_id: threadId,
+    created_at: now,
+    updated_at: now,
+    metadata: metadata ? JSON.stringify(metadata) : null,
+    status: "idle",
+    thread_values: null,
+    title: null
+  };
+}
+function updateThread(threadId, updates) {
+  const database = getDb();
+  const existing = getThread(threadId);
+  if (!existing) return null;
+  const now = Date.now();
+  const setClauses = ["updated_at = ?"];
+  const values = [now];
+  if (updates.metadata !== void 0) {
+    setClauses.push("metadata = ?");
+    values.push(
+      typeof updates.metadata === "string" ? updates.metadata : JSON.stringify(updates.metadata)
+    );
+  }
+  if (updates.status !== void 0) {
+    setClauses.push("status = ?");
+    values.push(updates.status);
+  }
+  if (updates.thread_values !== void 0) {
+    setClauses.push("thread_values = ?");
+    values.push(updates.thread_values);
+  }
+  if (updates.title !== void 0) {
+    setClauses.push("title = ?");
+    values.push(updates.title);
+  }
+  values.push(threadId);
+  database.run(`UPDATE threads SET ${setClauses.join(", ")} WHERE thread_id = ?`, values);
+  saveToDisk();
+  return getThread(threadId);
+}
+function deleteThread(threadId) {
+  const database = getDb();
+  database.run("DELETE FROM threads WHERE thread_id = ?", [threadId]);
+  saveToDisk();
+}
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createThread,
+  deleteThread,
+  getAllThreads,
+  getDb,
+  getThread,
+  initializeDatabase,
+  updateThread
+}, Symbol.toStringTag, { value: "Module" }));
+const activeRuns = /* @__PURE__ */ new Map();
+function registerAgentHandlers(ipcMain) {
+  console.log("[Agent] Registering agent handlers...");
+  ipcMain.on(
+    "agent:invoke",
+    async (event, { threadId, message }) => {
+      const channel = `agent:stream:${threadId}`;
+      const window = electron.BrowserWindow.fromWebContents(event.sender);
+      console.log("[Agent] Received invoke request:", {
+        threadId,
+        message: message.substring(0, 50)
+      });
+      if (!window) {
+        console.error("[Agent] No window found");
+        return;
+      }
+      const existingController = activeRuns.get(threadId);
+      if (existingController) {
+        console.log("[Agent] Aborting existing stream for thread:", threadId);
+        existingController.abort();
+        activeRuns.delete(threadId);
+      }
+      const abortController = new AbortController();
+      activeRuns.set(threadId, abortController);
+      const onWindowClosed = () => {
+        console.log("[Agent] Window closed, aborting stream for thread:", threadId);
+        abortController.abort();
+      };
+      window.once("closed", onWindowClosed);
+      try {
+        const thread = getThread(threadId);
+        const metadata = thread?.metadata ? JSON.parse(thread.metadata) : {};
+        const workspacePath = metadata.workspacePath;
+        const currentModel = metadata.currentModel;
+        if (!workspacePath) {
+          window.webContents.send(channel, {
+            type: "error",
+            error: "WORKSPACE_REQUIRED",
+            message: "Please select a workspace folder before sending messages."
+          });
+          return;
+        }
+        const agent = await createAgentRuntime({
+          threadId,
+          workspacePath,
+          modelId: currentModel
+        });
+        const humanMessage = new messages.HumanMessage(message);
+        const stream = await agent.stream(
+          { messages: [humanMessage] },
+          {
+            configurable: { thread_id: threadId },
+            signal: abortController.signal,
+            streamMode: ["messages", "values"],
+            recursionLimit: 1e3
+          }
+        );
+        for await (const chunk of stream) {
+          if (abortController.signal.aborted) break;
+          const [mode, data] = chunk;
+          window.webContents.send(channel, {
+            type: "stream",
+            mode,
+            data: JSON.parse(JSON.stringify(data))
+          });
+        }
+        if (!abortController.signal.aborted) {
+          window.webContents.send(channel, { type: "done" });
+        }
+      } catch (error) {
+        const isAbortError = error instanceof Error && (error.name === "AbortError" || error.message.includes("aborted") || error.message.includes("Controller is already closed"));
+        if (!isAbortError) {
+          console.error("[Agent] Error:", error);
+          window.webContents.send(channel, {
+            type: "error",
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+      } finally {
+        window.removeListener("closed", onWindowClosed);
+        activeRuns.delete(threadId);
+      }
+    }
+  );
+  ipcMain.on(
+    "agent:resume",
+    async (event, {
+      threadId,
+      command
+    }) => {
+      const channel = `agent:stream:${threadId}`;
+      const window = electron.BrowserWindow.fromWebContents(event.sender);
+      console.log("[Agent] Received resume request:", { threadId, command });
+      if (!window) {
+        console.error("[Agent] No window found for resume");
+        return;
+      }
+      const thread = getThread(threadId);
+      const metadata = thread?.metadata ? JSON.parse(thread.metadata) : {};
+      const workspacePath = metadata.workspacePath;
+      const currentModel = metadata.currentModel;
+      if (!workspacePath) {
+        window.webContents.send(channel, {
+          type: "error",
+          error: "Workspace path is required"
+        });
+        return;
+      }
+      const existingController = activeRuns.get(threadId);
+      if (existingController) {
+        existingController.abort();
+        activeRuns.delete(threadId);
+      }
+      const abortController = new AbortController();
+      activeRuns.set(threadId, abortController);
+      try {
+        const agent = await createAgentRuntime({
+          threadId,
+          workspacePath,
+          modelId: currentModel
+        });
+        const config = {
+          configurable: { thread_id: threadId },
+          signal: abortController.signal,
+          streamMode: ["messages", "values"],
+          recursionLimit: 1e3
+        };
+        const decisionType = command?.resume?.decision || "approve";
+        const resumeValue = { decisions: [{ type: decisionType }] };
+        const stream = await agent.stream(new langgraph.Command({ resume: resumeValue }), config);
+        for await (const chunk of stream) {
+          if (abortController.signal.aborted) break;
+          const [mode, data] = chunk;
+          window.webContents.send(channel, {
+            type: "stream",
+            mode,
+            data: JSON.parse(JSON.stringify(data))
+          });
+        }
+        if (!abortController.signal.aborted) {
+          window.webContents.send(channel, { type: "done" });
+        }
+      } catch (error) {
+        const isAbortError = error instanceof Error && (error.name === "AbortError" || error.message.includes("aborted") || error.message.includes("Controller is already closed"));
+        if (!isAbortError) {
+          console.error("[Agent] Resume error:", error);
+          window.webContents.send(channel, {
+            type: "error",
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+      } finally {
+        activeRuns.delete(threadId);
+      }
+    }
+  );
+  ipcMain.on(
+    "agent:interrupt",
+    async (event, { threadId, decision }) => {
+      const channel = `agent:stream:${threadId}`;
+      const window = electron.BrowserWindow.fromWebContents(event.sender);
+      if (!window) {
+        console.error("[Agent] No window found for interrupt response");
+        return;
+      }
+      const thread = getThread(threadId);
+      const metadata = thread?.metadata ? JSON.parse(thread.metadata) : {};
+      const workspacePath = metadata.workspacePath;
+      const currentModel = metadata.currentModel;
+      if (!workspacePath) {
+        window.webContents.send(channel, {
+          type: "error",
+          error: "Workspace path is required"
+        });
+        return;
+      }
+      const existingController = activeRuns.get(threadId);
+      if (existingController) {
+        existingController.abort();
+        activeRuns.delete(threadId);
+      }
+      const abortController = new AbortController();
+      activeRuns.set(threadId, abortController);
+      try {
+        const agent = await createAgentRuntime({
+          threadId,
+          workspacePath,
+          modelId: currentModel
+        });
+        const config = {
+          configurable: { thread_id: threadId },
+          signal: abortController.signal,
+          streamMode: ["messages", "values"],
+          recursionLimit: 1e3
+        };
+        if (decision.type === "approve") {
+          const stream = await agent.stream(null, config);
+          for await (const chunk of stream) {
+            if (abortController.signal.aborted) break;
+            const [mode, data] = chunk;
+            window.webContents.send(channel, {
+              type: "stream",
+              mode,
+              data: JSON.parse(JSON.stringify(data))
+            });
+          }
+          if (!abortController.signal.aborted) {
+            window.webContents.send(channel, { type: "done" });
+          }
+        } else if (decision.type === "reject") {
+          window.webContents.send(channel, { type: "done" });
+        }
+      } catch (error) {
+        const isAbortError = error instanceof Error && (error.name === "AbortError" || error.message.includes("aborted") || error.message.includes("Controller is already closed"));
+        if (!isAbortError) {
+          console.error("[Agent] Interrupt error:", error);
+          window.webContents.send(channel, {
+            type: "error",
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+      } finally {
+        activeRuns.delete(threadId);
+      }
+    }
+  );
+  ipcMain.handle("agent:cancel", async (_event, { threadId }) => {
+    const controller = activeRuns.get(threadId);
+    if (controller) {
+      controller.abort();
+      activeRuns.delete(threadId);
+    }
+  });
+}
+function generateTitle(message) {
+  const cleaned = message.trim().replace(/\s+/g, " ");
+  if (cleaned.length <= 50) {
+    return cleaned;
+  }
+  const sentenceMatch = cleaned.match(/^[^.!?]+[.!?]/);
+  if (sentenceMatch && sentenceMatch[0].length <= 60) {
+    return sentenceMatch[0].trim();
+  }
+  const words = cleaned.split(/\s+/);
+  let title = "";
+  for (const word of words) {
+    if ((title + " " + word).length > 47) {
+      break;
+    }
+    title = title ? title + " " + word : word;
+  }
+  if (words.join(" ").length > title.length) {
+    title += "...";
+  }
+  return title;
+}
+function registerThreadHandlers(ipcMain) {
+  ipcMain.handle("threads:list", async () => {
+    const threads = getAllThreads();
+    return threads.map((row) => ({
+      thread_id: row.thread_id,
+      created_at: new Date(row.created_at),
+      updated_at: new Date(row.updated_at),
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      status: row.status,
+      thread_values: row.thread_values ? JSON.parse(row.thread_values) : void 0,
+      title: row.title
+    }));
+  });
+  ipcMain.handle("threads:get", async (_event, threadId) => {
+    const row = getThread(threadId);
+    if (!row) return null;
+    return {
+      thread_id: row.thread_id,
+      created_at: new Date(row.created_at),
+      updated_at: new Date(row.updated_at),
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      status: row.status,
+      thread_values: row.thread_values ? JSON.parse(row.thread_values) : void 0,
+      title: row.title
+    };
+  });
+  ipcMain.handle("threads:create", async (_event, metadata) => {
+    const threadId = uuid.v4();
+    const title = metadata?.title || `Thread ${(/* @__PURE__ */ new Date()).toLocaleDateString()}`;
+    const thread = createThread(threadId, { ...metadata, title });
+    return {
+      thread_id: thread.thread_id,
+      created_at: new Date(thread.created_at),
+      updated_at: new Date(thread.updated_at),
+      metadata: thread.metadata ? JSON.parse(thread.metadata) : void 0,
+      status: thread.status,
+      thread_values: thread.thread_values ? JSON.parse(thread.thread_values) : void 0,
+      title
+    };
+  });
+  ipcMain.handle(
+    "threads:update",
+    async (_event, { threadId, updates }) => {
+      const updateData = {};
+      if (updates.title !== void 0) updateData.title = updates.title;
+      if (updates.status !== void 0) updateData.status = updates.status;
+      if (updates.metadata !== void 0)
+        updateData.metadata = JSON.stringify(updates.metadata);
+      if (updates.thread_values !== void 0) updateData.thread_values = JSON.stringify(updates.thread_values);
+      const row = updateThread(threadId, updateData);
+      if (!row) throw new Error("Thread not found");
+      return {
+        thread_id: row.thread_id,
+        created_at: new Date(row.created_at),
+        updated_at: new Date(row.updated_at),
+        metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+        status: row.status,
+        thread_values: row.thread_values ? JSON.parse(row.thread_values) : void 0,
+        title: row.title
+      };
+    }
+  );
+  ipcMain.handle("threads:delete", async (_event, threadId) => {
+    console.log("[Threads] Deleting thread:", threadId);
+    deleteThread(threadId);
+    console.log("[Threads] Deleted from metadata store");
+    try {
+      await closeCheckpointer(threadId);
+      console.log("[Threads] Closed checkpointer");
+    } catch (e) {
+      console.warn("[Threads] Failed to close checkpointer:", e);
+    }
+    try {
+      deleteThreadCheckpoint(threadId);
+      console.log("[Threads] Deleted checkpoint file");
+    } catch (e) {
+      console.warn("[Threads] Failed to delete checkpoint file:", e);
+    }
+  });
+  ipcMain.handle("threads:history", async (_event, threadId) => {
+    try {
+      const checkpointer = await getCheckpointer(threadId);
+      const history = [];
+      const config = { configurable: { thread_id: threadId } };
+      for await (const checkpoint of checkpointer.list(config, { limit: 50 })) {
+        history.push(checkpoint);
+      }
+      return history;
+    } catch (e) {
+      console.warn("Failed to get thread history:", e);
+      return [];
+    }
+  });
+  ipcMain.handle("threads:generateTitle", async (_event, message) => {
+    return generateTitle(message);
+  });
+}
+const originalConsoleError = console.error;
+console.error = (...args) => {
+  const message = args.map((a) => String(a)).join(" ");
+  if (message.includes("Controller is already closed") || message.includes("ERR_INVALID_STATE") || message.includes("StreamMessagesHandler") && message.includes("aborted")) {
+    return;
+  }
+  originalConsoleError.apply(console, args);
+};
+process.on("uncaughtException", (error) => {
+  if (error.message?.includes("Controller is already closed") || error.message?.includes("aborted")) {
+    return;
+  }
+  originalConsoleError("Uncaught exception:", error);
+});
+process.on("unhandledRejection", (reason) => {
+  const message = reason instanceof Error ? reason.message : String(reason);
+  if (message?.includes("Controller is already closed") || message?.includes("aborted")) {
+    return;
+  }
+  originalConsoleError("Unhandled rejection:", reason);
+});
+let mainWindow = null;
+const isDev = !electron.app.isPackaged;
+function createWindow() {
+  mainWindow = new electron.BrowserWindow({
+    width: 1440,
+    height: 900,
+    minWidth: 1200,
+    minHeight: 700,
+    show: false,
+    backgroundColor: "#0D0D0F",
+    titleBarStyle: "hiddenInset",
+    trafficLightPosition: { x: 16, y: 16 },
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      sandbox: false
+    }
+  });
+  mainWindow.on("ready-to-show", () => {
+    mainWindow?.show();
+  });
+  mainWindow.webContents.setWindowOpenHandler((details) => {
+    electron.shell.openExternal(details.url);
+    return { action: "deny" };
+  });
+  if (isDev && process.env["ELECTRON_RENDERER_URL"]) {
+    mainWindow.loadURL(process.env["ELECTRON_RENDERER_URL"]);
+  } else {
+    mainWindow.loadFile(path.join(__dirname, "../renderer/index.html"));
+  }
+  mainWindow.on("closed", () => {
+    mainWindow = null;
+  });
+}
+electron.app.whenReady().then(async () => {
+  if (process.platform === "win32") {
+    electron.app.setAppUserModelId(isDev ? process.execPath : "com.langchain.openwork");
+  }
+  if (process.platform === "darwin" && electron.app.dock) {
+    const iconPath = path.join(__dirname, "../../resources/icon.png");
+    try {
+      const icon = electron.nativeImage.createFromPath(iconPath);
+      if (!icon.isEmpty()) {
+        electron.app.dock.setIcon(icon);
+      }
+    } catch {
+    }
+  }
+  if (isDev) {
+    electron.app.on("browser-window-created", (_, window) => {
+      window.webContents.on("before-input-event", (event, input) => {
+        if (input.key === "F12") {
+          window.webContents.toggleDevTools();
+          event.preventDefault();
+        }
+      });
+    });
+  }
+  await initializeDatabase();
+  registerAgentHandlers(electron.ipcMain);
+  registerThreadHandlers(electron.ipcMain);
+  registerModelHandlers(electron.ipcMain);
+  createWindow();
+  electron.app.on("activate", () => {
+    if (electron.BrowserWindow.getAllWindows().length === 0) {
+      createWindow();
+    }
+  });
+});
+electron.app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    electron.app.quit();
+  }
+});