assistme 0.3.2 → 0.3.4

package/src/db/event.ts

@@ -2,6 +2,36 @@ import { callMcpHandler } from "./api-client.js";
 import { log } from "../utils/logger.js";
 import type { EventType } from "./types.js";
 
+const MAX_EMIT_RETRIES = 2;
+const EMIT_RETRY_DELAY_MS = 500;
+
+async function emitWithRetry(
+  messageId: string,
+  eventType: EventType,
+  eventData: Record<string, unknown>,
+  seq: number
+): Promise<void> {
+  for (let attempt = 0; attempt <= MAX_EMIT_RETRIES; attempt++) {
+    try {
+      await callMcpHandler("event.emit", {
+        message_id: messageId,
+        event_type: eventType,
+        event_data: eventData,
+        seq,
+      });
+      return;
+    } catch (err) {
+      if (attempt < MAX_EMIT_RETRIES) {
+        await new Promise((r) => setTimeout(r, EMIT_RETRY_DELAY_MS * (attempt + 1)));
+      } else {
+        log.warn(
+          `Failed to emit event after ${MAX_EMIT_RETRIES + 1} attempts: ${err instanceof Error ? err.message : err}`
+        );
+      }
+    }
+  }
+}
+
 /**
  * Per-task event emitter. Each task gets its own sequence counter
  * to avoid cross-task sequence number collisions.
@@ -13,16 +43,7 @@ export class TaskEventEmitter {
 
   async emit(eventType: EventType, eventData: Record<string, unknown>): Promise<void> {
     this.sequence++;
-    try {
-      await callMcpHandler("event.emit", {
-        message_id: this.messageId,
-        event_type: eventType,
-        event_data: eventData,
-        seq: this.sequence,
-      });
-    } catch (err) {
-      log.warn(`Failed to emit event: ${err instanceof Error ? err.message : err}`);
-    }
+    await emitWithRetry(this.messageId, eventType, eventData, this.sequence);
   }
 }
 
@@ -39,14 +60,5 @@ export async function emitEvent(
   eventData: Record<string, unknown>
 ): Promise<void> {
   eventSequence++;
-  try {
-    await callMcpHandler("event.emit", {
-      message_id: messageId,
-      event_type: eventType,
-      event_data: eventData,
-      seq: eventSequence,
-    });
-  } catch (err) {
-    log.warn(`Failed to emit event: ${err instanceof Error ? err.message : err}`);
-  }
+  await emitWithRetry(messageId, eventType, eventData, eventSequence);
 }

package/src/mcp/agent-tools-server.ts

@@ -25,10 +25,14 @@ export interface AgentToolsDeps {
   skillManager: SkillManager;
   taskId: string;
   sessionId?: string;
+  /** Called when the agent starts waiting for user input (pauses task timeout). */
+  onUserWaitStart?: () => void;
+  /** Called when user input completes or times out (resumes task timeout). */
+  onUserWaitEnd?: () => void;
 }
 
 export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfigWithInstance {
-  const { memoryManager, skillManager, taskId, sessionId } = deps;
+  const { memoryManager, skillManager, taskId, sessionId, onUserWaitStart, onUserWaitEnd } = deps;
 
   return createSdkMcpServer({
     name: "assistme-agent",
@@ -582,56 +586,65 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
             await setActionRequest(taskId, actionData);
             log.info(`Ask user ${actionId}: "${args.question.slice(0, 80)}..."`);
 
-            emitEvent(taskId, "user_action_request", actionData).catch(() => {});
-            // Emit waiting_for_user status so the web UI can show a waiting indicator
-            emitEvent(taskId, "status_change", {
+            // Await event emissions to ensure they reach the DB before we start polling
+            await emitEvent(taskId, "user_action_request", actionData);
+            await emitEvent(taskId, "status_change", {
               status: "waiting_for_user",
               message: args.question,
-            }).catch(() => {});
+            });
+
+            // Pause the task wall-clock timeout while waiting for user
+            onUserWaitStart?.();
 
             const startTime = Date.now();
             const pollInterval = 2000;
 
-            while (Date.now() - startTime < timeout) {
-              const response = await pollActionResponse(taskId);
-              if (response && (!response.action_id || response.action_id === actionId)) {
-                // Response can be either an option click or free-text input
-                const actionKey = (response.action_key || "") as string;
-                const text = (response.text || "") as string;
-                const label = (response.label || actionKey || text) as string;
-                log.info(`User responded: "${label}"`);
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: JSON.stringify({
-                        status: "responded",
-                        action_key: actionKey || "custom_input",
-                        label,
-                        text: text || label,
-                      }),
-                    },
-                  ],
-                };
+            try {
+              while (Date.now() - startTime < timeout) {
+                const response = await pollActionResponse(taskId);
+                if (response && (!response.action_id || response.action_id === actionId)) {
+                  const actionKey = (response.action_key || "") as string;
+                  const text = (response.text || "") as string;
+                  const label = (response.label || actionKey || text) as string;
+                  log.info(`User responded: "${label}"`);
+                  return {
+                    content: [
+                      {
+                        type: "text",
+                        text: JSON.stringify({
+                          status: "responded",
+                          action_key: actionKey || "custom_input",
+                          label,
+                          text: text || label,
+                        }),
+                      },
+                    ],
+                  };
+                }
+
+                await new Promise((resolve) => setTimeout(resolve, pollInterval));
               }
 
-              await new Promise((resolve) => setTimeout(resolve, pollInterval));
+              log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify({
+                      status: "timeout",
+                      message:
+                        "User did not respond within the timeout period. Continue the task with a reasonable default or skip the step that required user input.",
+                    }),
+                  },
+                ],
+              };
+            } finally {
+              // Resume the task timeout regardless of outcome
+              onUserWaitEnd?.();
             }
-
-            log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({
-                    status: "timeout",
-                    message: "User did not respond within the timeout period.",
-                  }),
-                },
-              ],
-            };
           } catch (err) {
             log.error(`ask_user failed: ${err}`);
+            onUserWaitEnd?.();
             return {
               content: [
                 {

package/src/mcp/browser-server.ts

@@ -9,11 +9,15 @@ import { getLimiterForTool } from "../utils/rate-limiter.js";
 
 // ── Helper ──────────────────────────────────────────────────────────
 
+/** MCP content block — text or image. */
+type ContentBlock =
+  | { type: "text"; text: string }
+  | { type: "image"; data: string; mimeType: string };
+
+type ToolResult = { content: ContentBlock[] };
+
 /** Wrap executeTool with rate limiting and text result. */
-async function callTool(
-  name: string,
-  input: Record<string, unknown>
-): Promise<{ content: Array<{ type: "text"; text: string }> }> {
+async function callTool(name: string, input: Record<string, unknown>): Promise<ToolResult> {
   const limiter = getLimiterForTool(name);
   if (limiter) await limiter.acquire();
   const result = await executeTool(name, input);
@@ -31,7 +35,6 @@ export const BROWSER_TOOL_NAMES = [
   "browser_type",
   "browser_press_key",
   "browser_scroll",
-  "browser_get_elements",
   "browser_select",
   "browser_snapshot",
   "browser_act",
@@ -69,19 +72,13 @@ export function createBrowserMcpServer(): McpSdkServerConfigWithInstance {
         "browser_screenshot",
         "Take a screenshot of the current browser page. Returns a base64-encoded PNG image.",
         {},
-        async () => {
+        async (): Promise<ToolResult> => {
           const limiter = getLimiterForTool("browser_screenshot");
           if (limiter) await limiter.acquire();
           const base64 = await executeTool("browser_screenshot", {});
           if (base64.length > 100) {
             return {
-              content: [
-                {
-                  type: "image" as const,
-                  data: base64,
-                  mimeType: "image/png",
-                } as unknown as { type: "text"; text: string },
-              ],
+              content: [{ type: "image", data: base64, mimeType: "image/png" }],
             };
           }
           return { content: [{ type: "text", text: base64 }] };
@@ -114,12 +111,6 @@ export function createBrowserMcpServer(): McpSdkServerConfigWithInstance {
         { direction: z.string().describe("'down' or 'up'") },
         async (args) => callTool("browser_scroll", args)
       ),
-      tool(
-        "browser_get_elements",
-        "Find all interactive elements (links, buttons, inputs) on the current page.",
-        {},
-        async () => callTool("browser_get_elements", {})
-      ),
       tool(
         "browser_select",
         "Select an option from a dropdown menu. Handles both native <select> elements and custom dropdowns (Material Design, React, Angular). Use this instead of manually clicking dropdown items.",
@@ -149,7 +140,7 @@ export function createBrowserMcpServer(): McpSdkServerConfigWithInstance {
               "Overlay ref badges on the screenshot. Default false. Use true for simple pages where visual context helps."
             ),
         },
-        async (args) => {
+        async (args): Promise<ToolResult> => {
           const limiter = getLimiterForTool("browser_snapshot");
           if (limiter) await limiter.acquire();
           const result = await executeTool("browser_snapshot", args);
@@ -159,13 +150,9 @@ export function createBrowserMcpServer(): McpSdkServerConfigWithInstance {
           const refTable = parts[0];
           const imageData = parts[1] || "";
 
-          const content: Array<{ type: "text"; text: string }> = [];
+          const content: ContentBlock[] = [];
           if (imageData.length > 100) {
-            content.push({
-              type: "image" as const,
-              data: imageData,
-              mimeType: "image/png",
-            } as unknown as { type: "text"; text: string });
+            content.push({ type: "image", data: imageData, mimeType: "image/png" });
           }
           content.push({ type: "text", text: refTable });
 
@@ -197,7 +184,7 @@ export function createBrowserMcpServer(): McpSdkServerConfigWithInstance {
             .optional()
             .describe("Take screenshot after actions (default: false)"),
         },
-        async (args) => {
+        async (args): Promise<ToolResult> => {
           const limiter = getLimiterForTool("browser_act");
           if (limiter) await limiter.acquire();
           const result = await executeTool("browser_act", {
@@ -210,14 +197,10 @@ export function createBrowserMcpServer(): McpSdkServerConfigWithInstance {
           const actionText = parts[0];
           const screenshotData = parts[1] || "";
 
-          const content: Array<{ type: "text"; text: string }> = [];
+          const content: ContentBlock[] = [];
           content.push({ type: "text", text: actionText });
           if (screenshotData.length > 100) {
-            content.push({
-              type: "image" as const,
-              data: screenshotData,
-              mimeType: "image/png",
-            } as unknown as { type: "text"; text: string });
+            content.push({ type: "image", data: screenshotData, mimeType: "image/png" });
           }
 
           return { content };

package/src/tools/browser.ts

@@ -14,6 +14,7 @@ export type {
   SnapshotResult,
   ActionSpec,
   ActionResult,
+  RefActionResult,
   AutoLaunchResult,
 } from "../browser/types.js";
 

package/src/tools/index.ts

@@ -169,9 +169,6 @@ export async function executeTool(name: string, input: Record<string, unknown>):
     case "browser_scroll":
       await ensureConnected(browser);
       return (input.direction as string) === "up" ? browser.scrollUp() : browser.scrollDown();
-    case "browser_get_elements":
-      await ensureConnected(browser);
-      return browser.getInteractiveElements();
     case "browser_select":
       await ensureConnected(browser);
       return browser.selectOption(input.selector as string, input.option as string);