openwork 0.1.3 → 0.2.0

package/README.md

@@ -35,15 +35,16 @@ cd openwork
 npm install
 npm run dev
 ```
+
 Or configure them in-app via the settings panel.
 
 ## Supported Models
 
-| Provider  | Models                                                            |
-| --------- | ----------------------------------------------------------------- |
+| Provider  | Models                                                                                 |
+| --------- | -------------------------------------------------------------------------------------- |
 | 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 |
+| OpenAI    | GPT-5.2, GPT-5.1, o3, o3 Mini, o4 Mini, o1, GPT-4.1, GPT-4o                            |
+| Google    | Gemini 3 Pro Preview, Gemini 3 Flash Preview, Gemini 2.5 Pro, Gemini 2.5 Flash, Gemini 2.5 Flash Lite |
 
 ## Contributing
 

package/bin/cli.js

@@ -4,23 +4,23 @@
  * openwork CLI - Launches the Electron app
  */
 
-const { spawn } = require('child_process')
-const path = require('path')
+const { spawn } = require("child_process")
+const path = require("path")
 
 // Set process title for Activity Monitor
-process.title = 'openwork'
+process.title = "openwork"
 
 const args = process.argv.slice(2)
 
 // Handle --version flag
-if (args.includes('--version') || args.includes('-v')) {
-  const { version } = require('../package.json')
+if (args.includes("--version") || args.includes("-v")) {
+  const { version } = require("../package.json")
   console.log(`openwork v${version}`)
   process.exit(0)
 }
 
 // Handle --help flag
-if (args.includes('--help') || args.includes('-h')) {
+if (args.includes("--help") || args.includes("-h")) {
   console.log(`
 openwork - A tactical agent interface for deepagentsjs
 
@@ -33,31 +33,32 @@ Usage:
 }
 
 // Get the path to electron
-const electron = require('electron')
+const electron = require("electron")
 
 // Launch electron with our main process
-const mainPath = path.join(__dirname, '..', 'out', 'main', 'index.js')
+const mainPath = path.join(__dirname, "..", "out", "main", "index.js")
 
 const child = spawn(electron, [mainPath, ...args], {
-  stdio: 'inherit'
+  stdio: "inherit"
 })
 
 // Forward signals to child process
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function forwardSignal(signal) {
   if (child.pid) {
     process.kill(child.pid, signal)
   }
 }
 
-process.on('SIGINT', () => forwardSignal('SIGINT'))
-process.on('SIGTERM', () => forwardSignal('SIGTERM'))
+process.on("SIGINT", () => forwardSignal("SIGINT"))
+process.on("SIGTERM", () => forwardSignal("SIGTERM"))
 
 // Exit with the same code as the child
-child.on('close', (code) => {
+child.on("close", (code) => {
   process.exit(code ?? 0)
 })
 
-child.on('error', (err) => {
-  console.error('Failed to start openwork:', err.message)
+child.on("error", (err) => {
+  console.error("Failed to start openwork:", err.message)
   process.exit(1)
 })

package/out/main/index.js

@@ -106,7 +106,9 @@ const ENV_FILE = path.join(OPENWORK_DIR, ".env");
 const ENV_VAR_NAMES = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY",
-  google: "GOOGLE_API_KEY"
+  google: "GOOGLE_API_KEY",
+  ollama: ""
+  // Ollama doesn't require an API key
 };
 function getOpenworkDir() {
   if (!fs.existsSync(OPENWORK_DIR)) {
@@ -155,7 +157,7 @@ function parseEnvFile() {
 }
 function writeEnvFile(env) {
   getOpenworkDir();
-  const lines = Object.entries(env).filter(([_, v]) => v).map(([k, v]) => `${k}=${v}`);
+  const lines = Object.entries(env).filter((entry) => entry[1]).map(([k, v]) => `${k}=${v}`);
   fs.writeFileSync(getEnvFilePath(), lines.join("\n") + "\n");
 }
 function getApiKey(provider) {
@@ -336,6 +338,14 @@ const AVAILABLE_MODELS = [
     description: "State-of-the-art reasoning and multimodal understanding",
     available: true
   },
+  {
+    id: "gemini-3-flash-preview",
+    name: "Gemini 3 Flash Preview",
+    provider: "google",
+    model: "gemini-3-flash-preview",
+    description: "Fast frontier-class model with low latency and cost",
+    available: true
+  },
   {
     id: "gemini-2.5-pro",
     name: "Gemini 2.5 Pro",
@@ -374,12 +384,9 @@ function registerModelHandlers(ipcMain) {
   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:setApiKey", async (_event, { provider, apiKey }) => {
+    setApiKey(provider, apiKey);
+  });
   ipcMain.handle("models:getApiKey", async (_event, provider) => {
     return getApiKey(provider) ?? null;
   });
@@ -1457,123 +1464,177 @@ const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
 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;
-        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 });
-        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, {
+  ipcMain.on("agent:invoke", async (event, { threadId, message, modelId }) => {
+    const channel = `agent:stream:${threadId}`;
+    const window = electron.BrowserWindow.fromWebContents(event.sender);
+    console.log("[Agent] Received invoke request:", {
       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;
-      }
+      message: message.substring(0, 50),
+      modelId
+    });
+    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) : {};
+      console.log("[Agent] Thread metadata:", metadata);
       const workspacePath = metadata.workspacePath;
       if (!workspacePath) {
         window.webContents.send(channel, {
           type: "error",
-          error: "Workspace path is required"
+          error: "WORKSPACE_REQUIRED",
+          message: "Please select a workspace folder before sending messages."
         });
         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 });
-        const config = {
+      const agent = await createAgentRuntime({ threadId, workspacePath, modelId });
+      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
-        };
-        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] 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, modelId }) => {
+    const channel = `agent:stream:${threadId}`;
+    const window = electron.BrowserWindow.fromWebContents(event.sender);
+    console.log("[Agent] Received resume request:", { threadId, command, modelId });
+    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;
+    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 });
+      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 modelId = metadata.model;
+    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 });
+      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;
@@ -1586,85 +1647,22 @@ function registerAgentHandlers(ipcMain) {
         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;
+      } else if (decision.type === "reject") {
+        window.webContents.send(channel, { type: "done" });
       }
-      const thread = getThread(threadId);
-      const metadata = thread?.metadata ? JSON.parse(thread.metadata) : {};
-      const workspacePath = metadata.workspacePath;
-      if (!workspacePath) {
+    } 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: "Workspace path is required"
+          error: error instanceof Error ? error.message : "Unknown error"
         });
-        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 });
-        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);
       }
+    } finally {
+      activeRuns.delete(threadId);
     }
-  );
+  });
   ipcMain.handle("agent:cancel", async (_event, { threadId }) => {
     const controller = activeRuns.get(threadId);
     if (controller) {
@@ -1735,28 +1733,25 @@ function registerThreadHandlers(ipcMain) {
       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: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);
@@ -1792,27 +1787,6 @@ 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

@@ -20,7 +20,7 @@ const electronAPI = {
 const api = {
   agent: {
     // Send message and receive events via callback
-    invoke: (threadId, message, onEvent) => {
+    invoke: (threadId, message, onEvent, modelId) => {
       const channel = `agent:stream:${threadId}`;
       const handler = (_, data) => {
         onEvent(data);
@@ -29,13 +29,13 @@ const api = {
         }
       };
       electron.ipcRenderer.on(channel, handler);
-      electron.ipcRenderer.send("agent:invoke", { threadId, message });
+      electron.ipcRenderer.send("agent:invoke", { threadId, message, modelId });
       return () => {
         electron.ipcRenderer.removeListener(channel, handler);
       };
     },
     // Stream agent events for useStream transport
-    streamAgent: (threadId, message, command, onEvent) => {
+    streamAgent: (threadId, message, command, onEvent, modelId) => {
       const channel = `agent:stream:${threadId}`;
       const handler = (_, data) => {
         onEvent(data);
@@ -45,9 +45,9 @@ const api = {
       };
       electron.ipcRenderer.on(channel, handler);
       if (command) {
-        electron.ipcRenderer.send("agent:resume", { threadId, command });
+        electron.ipcRenderer.send("agent:resume", { threadId, command, modelId });
       } else {
-        electron.ipcRenderer.send("agent:invoke", { threadId, message });
+        electron.ipcRenderer.send("agent:invoke", { threadId, message, modelId });
       }
       return () => {
         electron.ipcRenderer.removeListener(channel, handler);