opencode-wake-plugin 0.1.0

package/src/wake-dispatcher.ts

@@ -0,0 +1,167 @@
+import { buildWakeMessage } from "./contract.js";
+import { logger } from "./logger.js";
+
+type PromptPart = { type: "text"; text: string };
+
+export type PathBodyPromptAsyncArgs = {
+  path: { id: string };
+  body: {
+    parts: PromptPart[];
+    noReply: false;
+    model?: { providerID: string; modelID: string };
+  };
+  query: { directory: string };
+};
+
+export type PromptAsyncArgs = PathBodyPromptAsyncArgs;
+
+type PromptAsyncResult = { error?: unknown } | undefined;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object";
+}
+
+export type WakeDispatcherClient = {
+  session: {
+    messages(args: {
+      path: { id: string };
+      query: { directory: string };
+    }): Promise<unknown>;
+    promptAsync(args: PromptAsyncArgs): Promise<PromptAsyncResult>;
+    status?(args: { query: { directory: string } }): Promise<unknown>;
+  };
+};
+
+export type WakeDispatcherOpts = {
+  client: WakeDispatcherClient;
+  directory: string;
+  /** Delays applied before retry attempts 1, 2, 3 (attempt 0 has zero delay). */
+  backoffMs: [number, number, number];
+};
+
+/**
+ * WakeDispatcher sends a chat.message-style wake to the parent session
+ * when subagent activity has been observed.
+ *
+ * Retries with exponential backoff (1s / 3s / 9s default) up to 3 retries
+ * (4 attempts total) before giving up. Survives `promptAsync` network
+ * failures without propagating the error to the plugin runtime.
+ */
+export class WakeDispatcher {
+  private readonly client: WakeDispatcherClient;
+  private readonly directory: string;
+  private readonly backoffMs: [number, number, number];
+
+  constructor(opts: WakeDispatcherOpts) {
+    this.client = opts.client;
+    this.directory = opts.directory;
+    this.backoffMs = opts.backoffMs;
+  }
+
+  private async prompt(
+    parentSessionID: string,
+    parts: PromptPart[],
+    model?: { providerID: string; modelID: string },
+  ): Promise<void> {
+    const response = await this.client.session.promptAsync({
+      path: { id: parentSessionID },
+      body: { parts, noReply: false, ...(model ? { model } : {}) },
+      query: { directory: this.directory },
+    });
+    if (response?.error !== undefined && response.error !== null) {
+      throw response.error instanceof Error ? response.error : new Error(String(response.error));
+    }
+  }
+
+  private async resolveParentModel(
+    parentSessionID: string,
+  ): Promise<{ providerID: string; modelID: string } | undefined> {
+    try {
+      const response = await this.client.session.messages({
+        path: { id: parentSessionID },
+        query: { directory: this.directory },
+      });
+      const messages = isRecord(response) && Array.isArray(response["data"])
+        ? response["data"]
+        : Array.isArray(response)
+          ? response
+          : [];
+      for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        const info = isRecord(message) ? message["info"] : undefined;
+        if (!isRecord(info) || info["role"] !== "assistant") continue;
+        const providerID = info["providerID"];
+        const modelID = info["modelID"];
+        if (typeof providerID === "string" && typeof modelID === "string") {
+          return { providerID, modelID };
+        }
+      }
+    } catch (error) {
+      logger.debug("parent model lookup failed; preserving fallback wake", {
+        parentID: parentSessionID,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+    return undefined;
+  }
+
+  private async parentIsActive(parentSessionID: string): Promise<boolean> {
+    if (!this.client.session.status) return false;
+    try {
+      const response = await this.client.session.status({ query: { directory: this.directory } });
+      const statuses = isRecord(response) && isRecord(response["data"])
+        ? response["data"]
+        : response;
+      const status = isRecord(statuses) ? statuses[parentSessionID] : undefined;
+      const type = isRecord(status) ? status["type"] : undefined;
+      return type === "busy" || type === "retry" || type === "running";
+    } catch (error) {
+      logger.debug("parent status lookup failed; preserving fallback wake", {
+        parentID: parentSessionID,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return false;
+    }
+  }
+
+  async dispatch(parentSessionID: string, childSessionIDs: string[]): Promise<void> {
+    if (await this.parentIsActive(parentSessionID)) {
+      logger.debug("skipping fallback wake; parent already active", { parentID: parentSessionID });
+      return;
+    }
+    logger.info("wake fired", {
+      parentID: parentSessionID,
+      childCount: childSessionIDs.length,
+      sessionIDs: childSessionIDs,
+    });
+    const msg = buildWakeMessage({
+      parentSessionID,
+      childSessionIDs,
+      timestamp: Date.now(),
+    });
+    const model = await this.resolveParentModel(parentSessionID);
+    const delays = [0, this.backoffMs[0], this.backoffMs[1], this.backoffMs[2]] as const;
+    for (let attempt = 0; attempt < delays.length; attempt++) {
+      if (delays[attempt]! > 0) {
+        await new Promise<void>((r) => setTimeout(r, delays[attempt]!));
+      }
+      logger.debug("dispatch attempt", {
+        parentID: parentSessionID,
+        attempt,
+        childCount: childSessionIDs.length,
+        willRetry: attempt < delays.length - 1,
+      });
+      try {
+        await this.prompt(parentSessionID, msg.parts, model);
+        return;
+      } catch (e) {
+        if (attempt === delays.length - 1) {
+          logger.error("dispatch gave up after 4 attempts", {
+            parentID: parentSessionID,
+            error: e instanceof Error ? e.message : String(e),
+          });
+        }
+      }
+    }
+  }
+}