Help chat (#1007)

src/ipc/handlers/help_bot_handlers.ts

@@ -0,0 +1,134 @@
+import { ipcMain } from "electron";
+import { streamText } from "ai";
+import { readSettings } from "../../main/settings";
+
+import log from "electron-log";
+import { safeSend } from "../utils/safe_sender";
+import {
+  createOpenAI,
+  openai,
+  OpenAIResponsesProviderOptions,
+} from "@ai-sdk/openai";
+import { StartHelpChatParams } from "../ipc_types";
+
+const logger = log.scope("help-bot");
+
+// In-memory session store for help bot conversations
+type HelpMessage = { role: "user" | "assistant"; content: string };
+const helpSessions = new Map<string, HelpMessage[]>();
+const activeHelpStreams = new Map<string, AbortController>();
+
+export function registerHelpBotHandlers() {
+  ipcMain.handle(
+    "help:chat:start",
+    async (event, params: StartHelpChatParams) => {
+      const { sessionId, message } = params;
+      try {
+        if (!sessionId || !message?.trim()) {
+          throw new Error("Missing sessionId or message");
+        }
+
+        // Clear any existing active streams (only one session at a time)
+        for (const [existingSessionId, controller] of activeHelpStreams) {
+          controller.abort();
+          activeHelpStreams.delete(existingSessionId);
+          helpSessions.delete(existingSessionId);
+        }
+
+        // Append user message to session history
+        const history = helpSessions.get(sessionId) ?? [];
+        const updatedHistory: HelpMessage[] = [
+          ...history,
+          { role: "user", content: message },
+        ];
+
+        const abortController = new AbortController();
+        activeHelpStreams.set(sessionId, abortController);
+        const settings = await readSettings();
+        const apiKey = settings.providerSettings?.["auto"]?.apiKey?.value;
+        const provider = createOpenAI({
+          baseURL: "https://helpchat.dyad.sh/v1",
+          apiKey,
+        });
+
+        let assistantContent = "";
+
+        const stream = streamText({
+          model: provider.responses("gpt-5-nano"),
+          providerOptions: {
+            openai: {
+              reasoningSummary: "auto",
+            } satisfies OpenAIResponsesProviderOptions,
+          },
+          tools: {
+            web_search_preview: openai.tools.webSearchPreview({
+              searchContextSize: "high",
+            }),
+          },
+          messages: updatedHistory as any,
+          maxRetries: 1,
+          onError: (error) => {
+            let errorMessage = (error as any)?.error?.message;
+            logger.error("help bot stream error", errorMessage);
+            safeSend(event.sender, "help:chat:response:error", {
+              sessionId,
+              error: String(errorMessage),
+            });
+          },
+        });
+
+        (async () => {
+          try {
+            for await (const part of stream.fullStream) {
+              if (abortController.signal.aborted) break;
+
+              if (part.type === "text-delta") {
+                assistantContent += part.text;
+                safeSend(event.sender, "help:chat:response:chunk", {
+                  sessionId,
+                  delta: part.text,
+                  type: "text",
+                });
+              }
+            }
+
+            // Finalize session history
+            const finalHistory: HelpMessage[] = [
+              ...updatedHistory,
+              { role: "assistant", content: assistantContent },
+            ];
+            helpSessions.set(sessionId, finalHistory);
+
+            safeSend(event.sender, "help:chat:response:end", { sessionId });
+          } catch (err) {
+            if ((err as any)?.name === "AbortError") {
+              logger.log("help bot stream aborted", sessionId);
+              return;
+            }
+            logger.error("help bot stream loop error", err);
+            safeSend(event.sender, "help:chat:response:error", {
+              sessionId,
+              error: String(err instanceof Error ? err.message : err),
+            });
+          } finally {
+            activeHelpStreams.delete(sessionId);
+          }
+        })();
+
+        return { ok: true } as const;
+      } catch (err) {
+        logger.error("help:chat:start error", err);
+        throw err instanceof Error ? err : new Error(String(err));
+      }
+    },
+  );
+
+  ipcMain.handle("help:chat:cancel", async (_event, sessionId: string) => {
+    const controller = activeHelpStreams.get(sessionId);
+    if (controller) {
+      controller.abort();
+      activeHelpStreams.delete(sessionId);
+    }
+    return { ok: true } as const;
+  });
+}

src/ipc/ipc_client.ts

@@ -104,10 +104,19 @@ export class IpcClient {
   private ipcRenderer: IpcRenderer;
   private chatStreams: Map<number, ChatStreamCallbacks>;
   private appStreams: Map<number, AppStreamCallbacks>;
+  private helpStreams: Map<
+    string,
+    {
+      onChunk: (delta: string) => void;
+      onEnd: () => void;
+      onError: (error: string) => void;
+    }
+  >;
   private constructor() {
     this.ipcRenderer = (window as any).electron.ipcRenderer as IpcRenderer;
     this.chatStreams = new Map();
     this.appStreams = new Map();
+    this.helpStreams = new Map();
     // Set up listeners for stream events
     this.ipcRenderer.on("chat:response:chunk", (data) => {
       if (
@@ -180,6 +189,48 @@ export class IpcClient {
         console.error("[IPC] Invalid error data received:", error);
       }
     });
+
+    // Help bot events
+    this.ipcRenderer.on("help:chat:response:chunk", (data) => {
+      if (
+        data &&
+        typeof data === "object" &&
+        "sessionId" in data &&
+        "delta" in data
+      ) {
+        const { sessionId, delta } = data as {
+          sessionId: string;
+          delta: string;
+        };
+        const callbacks = this.helpStreams.get(sessionId);
+        if (callbacks) callbacks.onChunk(delta);
+      }
+    });
+
+    this.ipcRenderer.on("help:chat:response:end", (data) => {
+      if (data && typeof data === "object" && "sessionId" in data) {
+        const { sessionId } = data as { sessionId: string };
+        const callbacks = this.helpStreams.get(sessionId);
+        if (callbacks) callbacks.onEnd();
+        this.helpStreams.delete(sessionId);
+      }
+    });
+    this.ipcRenderer.on("help:chat:response:error", (data) => {
+      if (
+        data &&
+        typeof data === "object" &&
+        "sessionId" in data &&
+        "error" in data
+      ) {
+        const { sessionId, error } = data as {
+          sessionId: string;
+          error: string;
+        };
+        const callbacks = this.helpStreams.get(sessionId);
+        if (callbacks) callbacks.onError(error);
+        this.helpStreams.delete(sessionId);
+      }
+    });
   }
 
   public static getInstance(): IpcClient {
@@ -1089,4 +1140,28 @@ export class IpcClient {
   public async deletePrompt(id: number): Promise<void> {
     await this.ipcRenderer.invoke("prompts:delete", id);
   }
+
+  // --- Help bot ---
+  public startHelpChat(
+    sessionId: string,
+    message: string,
+    options: {
+      onChunk: (delta: string) => void;
+      onEnd: () => void;
+      onError: (error: string) => void;
+    },
+  ): void {
+    this.helpStreams.set(sessionId, options);
+    this.ipcRenderer
+      .invoke("help:chat:start", { sessionId, message })
+      .catch((err) => {
+        this.helpStreams.delete(sessionId);
+        showError(err);
+        options.onError(String(err));
+      });
+  }
+
+  public cancelHelpChat(sessionId: string): void {
+    this.ipcRenderer.invoke("help:chat:cancel", sessionId).catch(() => {});
+  }
 }

src/ipc/ipc_host.ts

@@ -29,6 +29,7 @@ import { registerAppEnvVarsHandlers } from "./handlers/app_env_vars_handlers";
 import { registerTemplateHandlers } from "./handlers/template_handlers";
 import { registerPortalHandlers } from "./handlers/portal_handlers";
 import { registerPromptHandlers } from "./handlers/prompt_handlers";
+import { registerHelpBotHandlers } from "./handlers/help_bot_handlers";
 
 export function registerIpcHandlers() {
   // Register all IPC handlers by category
@@ -63,4 +64,5 @@ export function registerIpcHandlers() {
   registerTemplateHandlers();
   registerPortalHandlers();
   registerPromptHandlers();
+  registerHelpBotHandlers();
 }

src/ipc/ipc_types.ts

@@ -420,3 +420,30 @@ export interface RevertVersionParams {
 export type RevertVersionResponse =
   | { successMessage: string }
   | { warningMessage: string };
+
+// --- Help Bot Types ---
+export interface StartHelpChatParams {
+  sessionId: string;
+  message: string;
+}
+
+export interface HelpChatResponseChunk {
+  sessionId: string;
+  delta: string;
+  type: "text";
+}
+
+export interface HelpChatResponseReasoning {
+  sessionId: string;
+  delta: string;
+  type: "reasoning";
+}
+
+export interface HelpChatResponseEnd {
+  sessionId: string;
+}
+
+export interface HelpChatResponseError {
+  sessionId: string;
+  error: string;
+}