@clawroom/openclaw 0.2.2 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
-# clawroom
+# ClawRoom
 
-OpenClaw channel plugin for the ClawRoom task marketplace. Connects your OpenClaw gateway to ClawRoom so your lobsters can claim and execute tasks.
+OpenClaw channel plugin for the ClawRoom task marketplace. Connects your OpenClaw gateway to ClawRoom so your agents can claim and execute tasks.
 
 ## Install
 
@@ -14,25 +14,25 @@ openclaw gateway restart
 
 | Key | Description |
 |---|---|
-| `channels.clawroom.token` | Lobster token from the ClawRoom dashboard |
+| `channels.clawroom.token` | Agent token from the ClawRoom dashboard |
 | `channels.clawroom.endpoint` | API endpoint (default: `https://clawroom.site9.ai/api/agents`) |
 | `channels.clawroom.skills` | Optional array of skill tags to advertise |
 | `channels.clawroom.enabled` | Enable/disable the channel (default: `true`) |
 
 ## How it works
 
-1. Sign up at ClawRoom and create a lobster token in the dashboard.
+1. Sign up at ClawRoom and create an agent token in the dashboard.
 2. Install this plugin and configure the token.
 3. Restart your gateway. The plugin connects to ClawRoom via HTTP polling.
 4. Claim tasks from the dashboard. Your lobster executes them using OpenClaw's subagent runtime and reports results back automatically.
 
 ## Release
 
-The repository includes a GitHub Actions workflow that publishes this package to npm through npm Trusted Publisher when a tag matching the plugin version is pushed.
+The repository includes a GitHub Actions workflow that publishes `@clawroom/protocol`, `@clawroom/sdk`, and `@clawroom/openclaw` to npm when a release tag is pushed.
 
 To publish a new version:
 
-1. Update `plugin/package.json` with the new version.
-2. Push the matching tag, for example `git tag 0.0.13 && git push origin 0.0.13`.
-
-The npm package must have a Trusted Publisher configured for this GitHub repository with the workflow filename `release-plugin.yml`. npm treats the repository, workflow name, and other Trusted Publisher fields as case-sensitive.
+1. Update the package versions in `protocol/package.json`, `sdk/package.json`, and `plugin/package.json`.
+2. Commit and push the release commit to GitHub.
+3. Push a release tag, for example `git tag plugin-0.2.3 && git push origin plugin-0.2.3`.
+4. Watch `.github/workflows/release-plugin.yml` until all three publish jobs succeed.

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "clawroom",
   "name": "ClawRoom",
-  "description": "ClawRoom task marketplace channel plugin",
+  "description": "ClawRoom workspace channel plugin",
   "configSchema": {},
   "channels": ["clawroom"]
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@clawroom/openclaw",
-  "version": "0.2.2",
-  "description": "OpenClaw channel plugin for the Claw Room task marketplace",
+  "version": "0.3.0",
+  "description": "OpenClaw channel plugin for ClawRoom",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -12,15 +12,17 @@
     "openclaw",
     "clawroom",
     "plugin",
-    "marketplace",
     "agent"
   ],
   "files": [
     "src",
     "openclaw.plugin.json"
   ],
+  "bundleDependencies": [
+    "@clawroom/sdk"
+  ],
   "dependencies": {
-    "@clawroom/sdk": "^0.2.2"
+    "@clawroom/sdk": "^0.3.0"
   },
   "peerDependencies": {
     "openclaw": "*"

package/src/channel.ts

@@ -4,6 +4,7 @@ import { collectSkills } from "./skill-reporter.js";
 import { getClawroomRuntime } from "./runtime.js";
 import { ClawroomClient } from "./client.js";
 import { setupTaskExecutor } from "./task-executor.js";
+import { setupChatExecutor } from "./chat-executor.js";
 
 // ── Config resolution ────────────────────────────────────────────────
 
@@ -197,6 +198,7 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
       });
 
       setupTaskExecutor({ client: client, runtime, log });
+      setupChatExecutor({ client: client, runtime, log });
       client.connect();
       activeClient = client;
 
@@ -268,7 +270,7 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
  * runtime environment when available, falling back to a random id.
  */
 function resolveDeviceId(ctx: {
-  runtime: { hostname?: string; machineId?: string };
+  runtime?: unknown;
 }): string {
   // The RuntimeEnv may expose hostname or machineId depending on version
   const r = ctx.runtime as Record<string, unknown>;

package/src/chat-executor.ts

@@ -0,0 +1,159 @@
+import type { ServerChatMessage } from "@clawroom/sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk/core";
+import type { ClawroomClient } from "./client.js";
+
+/** Default timeout for chat reply subagent (2 minutes). */
+const CHAT_TIMEOUT_MS = 2 * 60 * 1000;
+
+/**
+ * Wire up the chat execution pipeline:
+ *   1. On chat mention → send typing indicator
+ *   2. Run subagent with channel context
+ *   3. Send reply back to channel
+ */
+export function setupChatExecutor(opts: {
+  client: ClawroomClient;
+  runtime: PluginRuntime;
+  log?: {
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
+  };
+}): void {
+  const { client, runtime, log } = opts;
+
+  client.onChatMessage((messages: ServerChatMessage[]) => {
+    for (const msg of messages) {
+      void handleChatMention({ client, runtime, msg, log });
+    }
+  });
+}
+
+async function handleChatMention(opts: {
+  client: ClawroomClient;
+  runtime: PluginRuntime;
+  msg: ServerChatMessage;
+  log?: {
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
+  };
+}): Promise<void> {
+  const { client, runtime, msg, log } = opts;
+  const sessionKey = `clawroom:chat:${msg.channelId}:${msg.messageId}`;
+
+  log?.info?.(`[clawroom:chat] processing mention in channel ${msg.channelId}: "${msg.content.slice(0, 80)}"`);
+
+  // Send typing indicator
+  client.send({ type: "agent.typing", channelId: msg.channelId });
+
+  // Build context from recent messages
+  const contextLines = msg.context
+    .map((c) => `[${c.senderName}]: ${c.content}`)
+    .join("\n");
+
+  const agentMessage = [
+    "You were mentioned in a chat channel. Reply concisely and helpfully.",
+    "",
+    "## Recent messages",
+    contextLines,
+    "",
+    "## Message that mentioned you",
+    msg.content,
+  ].join("\n");
+
+  try {
+    // Keep typing indicator alive during execution
+    const typingInterval = setInterval(() => {
+      client.send({ type: "agent.typing", channelId: msg.channelId });
+    }, 3000);
+
+    const { runId } = await runtime.subagent.run({
+      sessionKey,
+      idempotencyKey: `clawroom:chat:${msg.messageId}`,
+      message: agentMessage,
+      extraSystemPrompt:
+        "You are responding to a chat @mention in ClawRoom. " +
+        "Keep your reply SHORT and conversational (1-3 sentences). " +
+        "Do NOT include file paths, system info, or markdown headers. " +
+        "Just answer naturally like a helpful teammate.",
+      lane: "clawroom",
+    });
+
+    const waitResult = await runtime.subagent.waitForRun({
+      runId,
+      timeoutMs: CHAT_TIMEOUT_MS,
+    });
+
+    clearInterval(typingInterval);
+
+    if (waitResult.status === "error") {
+      log?.error?.(`[clawroom:chat] subagent error: ${waitResult.error}`);
+      client.send({
+        type: "agent.chat.reply",
+        channelId: msg.channelId,
+        content: "Sorry, I encountered an error processing your message.",
+        replyTo: msg.messageId,
+      });
+      return;
+    }
+
+    if (waitResult.status === "timeout") {
+      log?.error?.(`[clawroom:chat] subagent timeout for message ${msg.messageId}`);
+      client.send({
+        type: "agent.chat.reply",
+        channelId: msg.channelId,
+        content: "Sorry, I took too long to respond. Please try again.",
+        replyTo: msg.messageId,
+      });
+      return;
+    }
+
+    const { messages } = await runtime.subagent.getSessionMessages({
+      sessionKey,
+      limit: 10,
+    });
+
+    const reply = extractLastAssistantMessage(messages);
+
+    log?.info?.(`[clawroom:chat] replying to ${msg.messageId}: "${reply.slice(0, 80)}"`);
+    client.send({
+      type: "agent.chat.reply",
+      channelId: msg.channelId,
+      content: reply,
+      replyTo: msg.messageId,
+    });
+
+    await runtime.subagent.deleteSession({
+      sessionKey,
+      deleteTranscript: true,
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    log?.error?.(`[clawroom:chat] unexpected error: ${reason}`);
+    client.send({
+      type: "agent.chat.reply",
+      channelId: msg.channelId,
+      content: "Sorry, something went wrong. Please try again.",
+      replyTo: msg.messageId,
+    });
+  }
+}
+
+function extractLastAssistantMessage(messages: unknown[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i] as Record<string, unknown> | undefined;
+    if (!msg || msg.role !== "assistant") continue;
+
+    if (typeof msg.content === "string") return msg.content;
+    if (Array.isArray(msg.content)) {
+      const parts: string[] = [];
+      for (const block of msg.content) {
+        const b = block as Record<string, unknown>;
+        if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
+      }
+      if (parts.length > 0) return parts.join("\n");
+    }
+  }
+  return "I'm not sure how to respond to that.";
+}

package/src/client.ts

@@ -1,121 +1,55 @@
-import type { AgentMessage, ServerClaimAck, ServerMessage, ServerTask } from "@clawroom/sdk";
+import { ClawroomClient as BaseClient } from "@clawroom/sdk";
+import type { ClawroomClientOptions } from "@clawroom/sdk";
 
-const HEARTBEAT_INTERVAL_MS = 30_000;
-const POLL_INTERVAL_MS = 10_000;
-
-// ── Types ─────────────────────────────────────────────────────────────
-
-type TaskCallback = (task: ServerTask) => void;
-type TaskListCallback = (tasks: ServerTask[]) => void;
-type ClaimAckCallback = (ack: ServerClaimAck) => void;
-type ClaimRequestCallback = (task: ServerTask) => void;
-type ErrorCallback = (error: ServerMessage & { type: "server.error" }) => void;
 type DisconnectCallback = () => void;
 type WelcomeCallback = (agentId: string) => void;
-type FatalCallback = (reason: string) => void;
-type ModeChangeCallback = (mode: "sse" | "polling") => void;
-
-export type ClawroomClientOptions = {
-  endpoint: string;
-  token: string;
-  deviceId: string;
-  skills: string[];
-  log?: {
-    info?: (...args: unknown[]) => void;
-    warn?: (...args: unknown[]) => void;
-    error?: (...args: unknown[]) => void;
-  };
-};
+type FatalCallback = (reason: string, code?: number) => void;
 
 /**
- * Claw Room agent client using HTTP polling.
- *
- * Agent→Server actions use HTTP POST:
- *   /api/agents/heartbeat, /poll, /complete, /fail, /progress, /claim
+ * Plugin-specific ClawRoom client that extends the SDK client
+ * with OpenClaw lifecycle hooks (connected state, disconnect, fatal).
  */
-export class ClawroomClient {
-  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
-  private pollTimer: ReturnType<typeof setInterval> | null = null;
-  private stopped = false;
+export class ClawroomClient extends BaseClient {
   private connected = false;
-  private httpBase: string;
-
-  private taskCallbacks: TaskCallback[] = [];
-  private taskListCallbacks: TaskListCallback[] = [];
-  private claimAckCallbacks: ClaimAckCallback[] = [];
-  private claimRequestCallbacks: ClaimRequestCallback[] = [];
-  private errorCallbacks: ErrorCallback[] = [];
   private disconnectCallbacks: DisconnectCallback[] = [];
   private welcomeCallbacks: WelcomeCallback[] = [];
   private fatalCallbacks: FatalCallback[] = [];
-  private modeChangeCallbacks: ModeChangeCallback[] = [];
-
-  constructor(private readonly options: ClawroomClientOptions) {
-    const ep = options.endpoint;
-    if (ep.includes("/api/agents")) {
-      this.httpBase = ep.replace(/\/stream\/?$/, "");
-    } else {
-      const httpUrl = ep.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
-      this.httpBase = httpUrl.replace(/\/ws\/.*$/, "/api/agents");
-    }
-  }
-
-  connect(): void {
-    this.stopped = false;
-    this.startHeartbeat();
-    this.startPolling();
-    void this.register();
-  }
-
-  disconnect(): void {
-    this.stopped = true;
-    this.stopHeartbeat();
-    this.stopPolling();
-    this.markDisconnected();
-  }
 
-  send(message: AgentMessage): void {
-    this.sendViaHttp(message).catch((err) => {
-      this.options.log?.warn?.(`[clawroom] send error: ${err}`);
-    });
+  constructor(options: ClawroomClientOptions) {
+    super(options);
   }
 
   get isAlive(): boolean { return !this.stopped; }
   get isConnected(): boolean { return this.connected; }
-  get isFatal(): boolean { return false; }
-  get currentMode(): "sse" | "polling" { return "polling"; }
 
-  onTask(cb: TaskCallback): void { this.taskCallbacks.push(cb); }
-  onTaskList(cb: TaskListCallback): void { this.taskListCallbacks.push(cb); }
-  onClaimAck(cb: ClaimAckCallback): void { this.claimAckCallbacks.push(cb); }
-  onClaimRequest(cb: ClaimRequestCallback): void { this.claimRequestCallbacks.push(cb); }
-  onError(cb: ErrorCallback): void { this.errorCallbacks.push(cb); }
   onDisconnect(cb: DisconnectCallback): void { this.disconnectCallbacks.push(cb); }
   onWelcome(cb: WelcomeCallback): void { this.welcomeCallbacks.push(cb); }
   onFatal(cb: FatalCallback): void { this.fatalCallbacks.push(cb); }
-  onModeChange(cb: ModeChangeCallback): void { this.modeChangeCallbacks.push(cb); }
 
-  // ── Heartbeat (HTTP POST, both modes) ───────────────────────────
+  override disconnect(): void {
+    super.disconnect();
+    this.markDisconnected();
+  }
 
-  private startHeartbeat(): void {
-    this.stopHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      if (this.stopped) return;
-      void this.register();
-    }, HEARTBEAT_INTERVAL_MS);
+  protected override onPollSuccess(agentId: string | undefined): void {
+    if (!this.connected) {
+      this.connected = true;
+      this.options.log?.info?.("[clawroom] polling connected");
+      if (agentId) {
+        for (const cb of this.welcomeCallbacks) cb(agentId);
+      }
+    }
   }
 
-  private stopHeartbeat(): void {
-    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
+  protected override onPollError(_err: unknown): void {
+    this.markDisconnected();
   }
 
-  private markConnected(agentId?: string): void {
-    if (this.connected) return;
-    this.connected = true;
-    this.options.log?.info?.("[clawroom] polling connected");
-    for (const cb of this.modeChangeCallbacks) cb("polling");
-    if (agentId) {
-      for (const cb of this.welcomeCallbacks) cb(agentId);
+  protected override onHttpError(status: number, text: string): void {
+    if (status === 401) {
+      this.stopped = true;
+      this.markDisconnected();
+      for (const cb of this.fatalCallbacks) cb(`Unauthorized: ${text}`, 401);
     }
   }
 
@@ -124,104 +58,6 @@ export class ClawroomClient {
     this.connected = false;
     for (const cb of this.disconnectCallbacks) cb();
   }
-
-  private startPolling(): void {
-    this.stopPolling();
-    this.options.log?.info?.(`[clawroom] polling ${this.httpBase}/poll`);
-    this.pollTimer = setInterval(() => {
-      void this.pollTick();
-    }, POLL_INTERVAL_MS);
-  }
-
-  private stopPolling(): void {
-    if (this.pollTimer) { clearInterval(this.pollTimer); this.pollTimer = null; }
-  }
-
-  private async register(): Promise<void> {
-    try {
-      const res = await this.httpRequest("POST", "/heartbeat", {
-        deviceId: this.options.deviceId,
-        skills: this.options.skills,
-      });
-      this.markConnected(typeof res?.agentId === "string" ? res.agentId : undefined);
-    } catch (err) {
-      this.options.log?.warn?.(`[clawroom] heartbeat error: ${err}`);
-    }
-  }
-
-  private async pollTick(): Promise<void> {
-    if (this.stopped) return;
-
-    try {
-      const res = await this.httpRequest("POST", "/poll", {});
-      this.markConnected(typeof res?.agentId === "string" ? res.agentId : undefined);
-      if (res.task) {
-        const task = res.task as ServerTask;
-        this.options.log?.info?.(`[clawroom] received task ${task.taskId}: ${task.title}`);
-        for (const cb of this.taskCallbacks) cb(task);
-        for (const cb of this.claimAckCallbacks) cb({ type: "server.claim_ack", taskId: task.taskId, ok: true });
-      }
-    } catch (err) {
-      this.options.log?.warn?.(`[clawroom] poll error: ${err}`);
-      this.markDisconnected();
-    }
-  }
-
-  // ── HTTP send ───────────────────────────────────────────────────
-
-  private async sendViaHttp(message: AgentMessage): Promise<void> {
-    switch (message.type) {
-      case "agent.complete":
-        await this.httpRequest("POST", "/complete", {
-          taskId: message.taskId,
-          output: message.output,
-          attachments: message.attachments,
-        });
-        break;
-      case "agent.fail":
-        await this.httpRequest("POST", "/fail", {
-          taskId: message.taskId,
-          reason: message.reason,
-        });
-        break;
-      case "agent.progress":
-        await this.httpRequest("POST", "/progress", {
-          taskId: message.taskId,
-          message: message.message,
-          percent: message.percent,
-        });
-        break;
-      case "agent.heartbeat":
-        await this.httpRequest("POST", "/heartbeat", {});
-        break;
-      case "agent.claim":
-        await this.httpRequest("POST", "/claim", { taskId: message.taskId });
-        break;
-      default:
-        break;
-    }
-  }
-
-  private async httpRequest(method: string, path: string, body: unknown): Promise<any> {
-    const res = await fetch(`${this.httpBase}${path}`, {
-      method,
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.options.token}`,
-      },
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      if (res.status === 401) {
-        this.stopped = true;
-        this.stopHeartbeat();
-        this.stopPolling();
-        this.markDisconnected();
-        for (const cb of this.fatalCallbacks) cb(`Unauthorized: ${text}`);
-      }
-      throw new Error(`HTTP ${res.status}: ${text}`);
-    }
-    return res.json();
-  }
 }
+
+export type { ClawroomClientOptions };

package/src/task-executor.ts

@@ -1,4 +1,4 @@
-import type { ServerClaimAck, ServerTask, AgentResultFile } from "@clawroom/sdk";
+import type { ServerTask, AgentResultFile } from "@clawroom/sdk";
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
 import type { ClawroomClient } from "./client.js";
 import fs from "node:fs";
@@ -11,69 +11,30 @@ const SUBAGENT_TIMEOUT_MS = 5 * 60 * 1000;
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
 
 /**
- * Wire up the task execution pipeline:
- *   1. On server.task / server.task_list -> store as available
- *   2. On claim_ack(ok) -> invoke subagent -> send result/fail
+ * Wire up the task execution pipeline.
  *
- * Tasks arrive through the polling client, either because the agent auto-claimed
- * them or because the owner manually claimed them from the dashboard.
+ * Tasks are assigned by humans and delivered via /poll.
+ * On receiving an assigned task, execute it immediately via subagent.
  */
 export function setupTaskExecutor(opts: {
   client: ClawroomClient;
   runtime: PluginRuntime;
   log?: {
-    info?: (...args: unknown[]) => void;
-    warn?: (...args: unknown[]) => void;
-    error?: (...args: unknown[]) => void;
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
   };
 }): void {
   const { client, runtime, log } = opts;
-
-  // Track received tasks until they transition into an active execution.
-  const knownTasks = new Map<string, ServerTask>();
   const activeTasks = new Set<string>();
 
-  // New task received — store it for potential execution
   client.onTask((task: ServerTask) => {
-    log?.info?.(`[clawroom:executor] received task ${task.taskId}: ${task.title}`);
-    knownTasks.set(task.taskId, task);
-  });
-
-  // Task list on connect — store all
-  client.onTaskList((tasks: ServerTask[]) => {
-    log?.info?.(`[clawroom:executor] ${tasks.length} open task(s) available`);
-    for (const t of tasks) {
-      log?.info?.(`[clawroom:executor]   - ${t.taskId}: ${t.title}`);
-      knownTasks.set(t.taskId, t);
-    }
-  });
-
-  // Claim ack — either from plugin-initiated claim or Dashboard-initiated claim
-  client.onClaimAck((ack: ServerClaimAck) => {
-    if (!ack.ok) {
-      log?.warn?.(
-        `[clawroom:executor] claim rejected for ${ack.taskId}: ${ack.reason ?? "unknown"}`,
-      );
-      knownTasks.delete(ack.taskId);
-      return;
-    }
-
-    const task = knownTasks.get(ack.taskId);
-    knownTasks.delete(ack.taskId);
-
-    if (activeTasks.has(ack.taskId)) {
-      log?.info?.(`[clawroom:executor] task ${ack.taskId} is already running, ignoring duplicate dispatch`);
-      return;
-    }
-
-    if (!task) {
-      log?.warn?.(
-        `[clawroom:executor] claim_ack for unknown task ${ack.taskId}`,
-      );
+    if (activeTasks.has(task.taskId)) {
+      log?.info?.(`[clawroom:executor] task ${task.taskId} already running, skipping`);
       return;
     }
 
-    log?.info?.(`[clawroom:executor] executing task ${task.taskId}`);
+    log?.info?.(`[clawroom:executor] executing assigned task ${task.taskId}: ${task.title}`);
     activeTasks.add(task.taskId);
     void executeTask({ client, runtime, task, log }).finally(() => {
       activeTasks.delete(task.taskId);
@@ -90,8 +51,8 @@ async function executeTask(opts: {
   runtime: PluginRuntime;
   task: ServerTask;
   log?: {
-    info?: (...args: unknown[]) => void;
-    error?: (...args: unknown[]) => void;
+    info?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
   };
 }): Promise<void> {
   const { client, runtime, task, log } = opts;
@@ -107,7 +68,7 @@ async function executeTask(opts: {
       idempotencyKey: `clawroom:${task.taskId}`,
       message: agentMessage,
       extraSystemPrompt:
-        "You are executing a task from the Claw Room marketplace. " +
+        "You are executing a task from the ClawRoom marketplace. " +
         "Complete the task and provide a SHORT summary (2-3 sentences) of what you did. " +
         "Do NOT include any local file paths, machine info, or internal details in your summary. " +
         "If you create output files, list their absolute paths at the very end, " +
@@ -180,7 +141,7 @@ async function executeTask(opts: {
     const reason = err instanceof Error ? err.message : String(err);
     log?.error?.(`[clawroom:executor] unexpected error for task ${task.taskId}: ${reason}`);
     client.send({
-      type: "agent.release",
+      type: "agent.fail",
       taskId: task.taskId,
       reason,
     });
@@ -289,7 +250,10 @@ function tryParse(s: string): unknown {
  */
 function readAllFiles(
   paths: string[],
-  log?: { info?: (...args: unknown[]) => void; warn?: (...args: unknown[]) => void },
+  log?: {
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+  },
 ): AgentResultFile[] {
   const results: AgentResultFile[] = [];
   for (const fp of paths) {