openwork 0.1.1 → 0.1.3

package/README.md

@@ -43,6 +43,7 @@ Or configure them in-app via the settings panel.
 | --------- | ----------------------------------------------------------------- |
 | Anthropic | Claude Opus 4.5, Claude Sonnet 4.5, Claude Haiku 4.5, Claude Opus 4.1, Claude Sonnet 4 |
 | OpenAI    | GPT-5.2, GPT-5.1, o3, o3 Mini, o4 Mini, o1, GPT-4.1, GPT-4o       |
+| Google    | Gemini 3 Pro Preview, Gemini 2.5 Pro, Gemini 2.5 Flash, Gemini 2.5 Flash Lite |
 
 ## Contributing
 

package/out/main/index.js

@@ -10,6 +10,7 @@ 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");
@@ -104,7 +105,8 @@ 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"
+  openai: "OPENAI_API_KEY",
+  google: "GOOGLE_API_KEY"
 };
 function getOpenworkDir() {
   if (!fs.existsSync(OPENWORK_DIR)) {
@@ -115,8 +117,21 @@ function getOpenworkDir() {
 function getDbPath() {
   return path.join(getOpenworkDir(), "openwork.sqlite");
 }
-function getCheckpointDbPath() {
-  return path.join(getOpenworkDir(), "langgraph.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;
@@ -175,7 +190,8 @@ const store = new Store({
 });
 const PROVIDERS = [
   { id: "anthropic", name: "Anthropic" },
-  { id: "openai", name: "OpenAI" }
+  { id: "openai", name: "OpenAI" },
+  { id: "google", name: "Google" }
 ];
 const AVAILABLE_MODELS = [
   // Anthropic Claude 4.5 series (latest as of Jan 2026)
@@ -310,6 +326,39 @@ const AVAILABLE_MODELS = [
     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
   }
 ];
 function registerModelHandlers(ipcMain) {
@@ -495,6 +544,47 @@ function registerModelHandlers(ipcMain) {
       }
     }
   );
+  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");
@@ -516,8 +606,29 @@ class SqlJsSaver extends langgraphCheckpoint.BaseCheckpointSaver {
     if (this.db) return;
     const SQL = await initSqlJs();
     if (fs.existsSync(this.dbPath)) {
-      const buffer = fs.readFileSync(this.dbPath);
-      this.db = new SQL.Database(buffer);
+      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)) {
@@ -1075,14 +1186,24 @@ function getSystemPrompt(workspacePath) {
 `;
   return workingDirSection + BASE_SYSTEM_PROMPT;
 }
-let checkpointer = null;
-async function getCheckpointer() {
+const checkpointers = /* @__PURE__ */ new Map();
+async function getCheckpointer(threadId) {
+  let checkpointer = checkpointers.get(threadId);
   if (!checkpointer) {
-    checkpointer = new SqlJsSaver(getCheckpointDbPath());
+    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);
@@ -1106,22 +1227,36 @@ function getModelInstance(modelId) {
       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 { modelId, workspacePath } = 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 checkpointer2 = await getCheckpointer();
-  console.log("[Runtime] Checkpointer ready");
+  const checkpointer = await getCheckpointer(threadId);
+  console.log("[Runtime] Checkpointer ready for thread:", threadId);
   const backend = new LocalSandbox({
     rootDir: workspacePath,
     virtualMode: false,
@@ -1144,7 +1279,7 @@ async function createAgentRuntime(options) {
 The workspace root is: ${workspacePath}`;
   const agent = deepagents.createDeepAgent({
     model,
-    checkpointer: checkpointer2,
+    checkpointer,
     backend,
     systemPrompt,
     // Custom filesystem prompt for absolute paths (requires deepagents update)
@@ -1360,7 +1495,7 @@ function registerAgentHandlers(ipcMain) {
           });
           return;
         }
-        const agent = await createAgentRuntime({ workspacePath });
+        const agent = await createAgentRuntime({ threadId, workspacePath });
         const humanMessage = new messages.HumanMessage(message);
         const stream = await agent.stream(
           { messages: [humanMessage] },
@@ -1380,13 +1515,18 @@ function registerAgentHandlers(ipcMain) {
             data: JSON.parse(JSON.stringify(data))
           });
         }
-        window.webContents.send(channel, { type: "done" });
+        if (!abortController.signal.aborted) {
+          window.webContents.send(channel, { type: "done" });
+        }
       } catch (error) {
-        console.error("[Agent] Error:", error);
-        window.webContents.send(channel, {
-          type: "error",
-          error: error instanceof Error ? error.message : "Unknown 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);
@@ -1424,7 +1564,7 @@ function registerAgentHandlers(ipcMain) {
       const abortController = new AbortController();
       activeRuns.set(threadId, abortController);
       try {
-        const agent = await createAgentRuntime({ workspacePath });
+        const agent = await createAgentRuntime({ threadId, workspacePath });
         const config = {
           configurable: { thread_id: threadId },
           signal: abortController.signal,
@@ -1443,13 +1583,18 @@ function registerAgentHandlers(ipcMain) {
             data: JSON.parse(JSON.stringify(data))
           });
         }
-        window.webContents.send(channel, { type: "done" });
+        if (!abortController.signal.aborted) {
+          window.webContents.send(channel, { type: "done" });
+        }
       } catch (error) {
-        console.error("[Agent] Resume error:", error);
-        window.webContents.send(channel, {
-          type: "error",
-          error: error instanceof Error ? error.message : "Unknown 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);
       }
@@ -1482,7 +1627,7 @@ function registerAgentHandlers(ipcMain) {
       const abortController = new AbortController();
       activeRuns.set(threadId, abortController);
       try {
-        const agent = await createAgentRuntime({ workspacePath });
+        const agent = await createAgentRuntime({ threadId, workspacePath });
         const config = {
           configurable: { thread_id: threadId },
           signal: abortController.signal,
@@ -1500,16 +1645,21 @@ function registerAgentHandlers(ipcMain) {
               data: JSON.parse(JSON.stringify(data))
             });
           }
-          window.webContents.send(channel, { type: "done" });
+          if (!abortController.signal.aborted) {
+            window.webContents.send(channel, { type: "done" });
+          }
         } else if (decision.type === "reject") {
           window.webContents.send(channel, { type: "done" });
         }
       } catch (error) {
-        console.error("[Agent] Interrupt error:", error);
-        window.webContents.send(channel, {
-          type: "error",
-          error: error instanceof Error ? error.message : "Unknown 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);
       }
@@ -1612,19 +1762,24 @@ function registerThreadHandlers(ipcMain) {
     deleteThread(threadId);
     console.log("[Threads] Deleted from metadata store");
     try {
-      const checkpointer2 = await getCheckpointer();
-      await checkpointer2.deleteThread(threadId);
-      console.log("[Threads] Deleted from checkpointer");
+      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 thread from checkpointer:", e);
+      console.warn("[Threads] Failed to delete checkpoint file:", e);
     }
   });
   ipcMain.handle("threads:history", async (_event, threadId) => {
     try {
-      const checkpointer2 = await getCheckpointer();
+      const checkpointer = await getCheckpointer(threadId);
       const history = [];
       const config = { configurable: { thread_id: threadId } };
-      for await (const checkpoint of checkpointer2.list(config, { limit: 50 })) {
+      for await (const checkpoint of checkpointer.list(config, { limit: 50 })) {
         history.push(checkpoint);
       }
       return history;
@@ -1637,6 +1792,27 @@ function registerThreadHandlers(ipcMain) {
     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() {

package/out/preload/index.js

@@ -133,6 +133,9 @@ const api = {
     readFile: (threadId, filePath) => {
       return electron.ipcRenderer.invoke("workspace:readFile", { threadId, filePath });
     },
+    readBinaryFile: (threadId, filePath) => {
+      return electron.ipcRenderer.invoke("workspace:readBinaryFile", { threadId, filePath });
+    },
     // Listen for file changes in the workspace
     onFilesChanged: (callback) => {
       const handler = (_, data) => {