@uniqueli/openwork 0.2.1 → 0.2.2

package/out/main/index.js

@@ -107,7 +107,9 @@ const ENV_VAR_NAMES = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY",
   google: "GOOGLE_API_KEY",
-  custom: "CUSTOM_API_KEY"
+  ollama: ""
+  // Ollama doesn't require an API key
+  // Custom providers have their own env var pattern
 };
 function getOpenworkDir() {
   if (!fs.existsSync(OPENWORK_DIR)) {
@@ -156,7 +158,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) {
@@ -271,8 +273,7 @@ const store = new Store({
 const PROVIDERS = [
   { id: "anthropic", name: "Anthropic" },
   { id: "openai", name: "OpenAI" },
-  { id: "google", name: "Google" },
-  { id: "custom", name: "Custom API" }
+  { id: "google", name: "Google" }
 ];
 const AVAILABLE_MODELS = [
   // Anthropic Claude 4.5 series (latest as of Jan 2026)
@@ -417,6 +418,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",
@@ -440,41 +449,27 @@ const AVAILABLE_MODELS = [
     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 () => {
     const customConfigs = getCustomApiConfigs();
-    const models = AVAILABLE_MODELS.filter((m) => m.id !== "custom");
+    const models = AVAILABLE_MODELS.map((model) => ({
+      ...model,
+      available: hasApiKey(model.provider)
+    }));
     for (const config of customConfigs) {
       const modelId = config.model || `custom-${config.id}`;
       models.push({
         id: modelId,
         name: config.model || config.name,
-        // Display the model name or config name
         provider: config.id,
-        // Use config ID as provider ID (dynamic)
         model: modelId,
         description: `${config.name} - ${config.baseUrl}`,
         available: true
       });
     }
-    return models.map((model) => {
-      const isCustom = customConfigs.some((c) => c.id === model.provider);
-      return {
-        ...model,
-        available: isCustom ? true : hasApiKey(model.provider)
-      };
-    });
+    return models;
   });
   ipcMain.handle("models:getDefault", async () => {
     return store.get("defaultModel", "claude-sonnet-4-5-20250929");
@@ -482,12 +477,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;
   });
@@ -495,17 +487,15 @@ function registerModelHandlers(ipcMain) {
     deleteApiKey(provider);
   });
   ipcMain.handle("models:listProviders", async () => {
-    const standardProviders = PROVIDERS.filter((p) => p.id !== "custom").map((provider) => ({
+    const standardProviders = PROVIDERS.map((provider) => ({
       ...provider,
       hasApiKey: hasApiKey(provider.id)
     }));
     const customConfigs = getCustomApiConfigs();
     const customProviders = customConfigs.map((config) => ({
       id: config.id,
-      // Dynamic provider ID
       name: config.name,
       hasApiKey: true
-      // Custom configs always have their API key
     }));
     return [...standardProviders, ...customProviders];
   });
@@ -1367,9 +1357,10 @@ function getModelInstance(modelId) {
         configuration: {
           baseURL: matchingConfig.baseUrl,
           defaultHeaders: {
-            "Authorization": `Bearer ${cleanApiKey}`
+            Authorization: `Bearer ${cleanApiKey}`
           }
         },
+        temperature: 0.3,
         timeout: 6e4,
         maxRetries: 2
       });
@@ -1388,7 +1379,8 @@ function getModelInstance(modelId) {
     }
     return new anthropic.ChatAnthropic({
       model,
-      anthropicApiKey: apiKey
+      anthropicApiKey: apiKey,
+      temperature: 0.3
     });
   } else if (model.startsWith("gpt") || model.startsWith("o1") || model.startsWith("o3") || model.startsWith("o4")) {
     const apiKey = getApiKey("openai");
@@ -1398,7 +1390,8 @@ function getModelInstance(modelId) {
     }
     return new openai.ChatOpenAI({
       model,
-      openAIApiKey: apiKey
+      openAIApiKey: apiKey,
+      temperature: 0.3
     });
   } else if (model.startsWith("gemini")) {
     const apiKey = getApiKey("google");
@@ -1408,7 +1401,8 @@ function getModelInstance(modelId) {
     }
     return new googleGenai.ChatGoogleGenerativeAI({
       model,
-      apiKey
+      apiKey,
+      temperature: 0.3
     });
   }
   return model;
@@ -1630,100 +1624,32 @@ 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;
-        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, {
+  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) : {};
       const workspacePath = metadata.workspacePath;
@@ -1731,32 +1657,157 @@ function registerAgentHandlers(ipcMain) {
       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,
-          modelId: currentModel
-        });
-        const config = {
+      const agent = await createAgentRuntime({
+        threadId,
+        workspacePath,
+        modelId: currentModel || 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;
+    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 || 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 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;
@@ -1769,90 +1820,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;
-      const currentModel = metadata.currentModel;
-      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,
-          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);
       }
+    } finally {
+      activeRuns.delete(threadId);
     }
-  );
+  });
   ipcMain.handle("agent:cancel", async (_event, { threadId }) => {
     const controller = activeRuns.get(threadId);
     if (controller) {
@@ -1923,28 +1906,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);
@@ -1980,27 +1960,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() {