wispy-cli 2.7.7 → 2.7.9

package/core/subagent-worker.mjs

@@ -0,0 +1,325 @@
+/**
+ * core/subagent-worker.mjs — Worker thread code for sub-agent isolation
+ *
+ * Runs inside a worker_threads Worker. Receives task/config via workerData,
+ * communicates back to the main thread via parentPort.postMessage().
+ *
+ * Message protocol (worker → main):
+ *   { type: 'progress',     agentId, round, content }
+ *   { type: 'tool_call',    agentId, round, call: { name, args, id } }
+ *   { type: 'tool_result',  agentId, round, toolName, result }
+ *   { type: 'completed',    agentId, result }
+ *   { type: 'failed',       agentId, error }
+ *
+ * Message protocol (main → worker):
+ *   { type: 'tool_result',  callId, result }
+ *   { type: 'steer',        message }
+ *   { type: 'kill' }
+ */
+
+import { workerData, parentPort } from "node:worker_threads";
+
+if (!parentPort) {
+  throw new Error("subagent-worker.mjs must be run as a Worker thread");
+}
+
+const { agentId, task, systemPrompt, model, timeout, providerConfig, toolDefs } = workerData;
+
+const MAX_ROUNDS = 30;
+const TOKEN_LIMIT = 128_000;
+const COMPACT_THRESHOLD = 0.8; // compact at 80%
+
+/** Estimate token count as chars/4 */
+function estimateTokens(text) {
+  return Math.ceil((text?.length ?? 0) / 4);
+}
+
+function estimateMessages(msgs) {
+  return msgs.reduce((sum, m) => {
+    const content = m.content ?? JSON.stringify(m);
+    return sum + estimateTokens(content);
+  }, 0);
+}
+
+/** Pending tool call resolvers: callId → { resolve, reject } */
+const pendingToolCalls = new Map();
+/** Pending steer messages */
+const steerMessages = [];
+let killed = false;
+
+// Listen for messages from the main thread
+parentPort.on("message", (msg) => {
+  if (msg.type === "tool_result") {
+    const pending = pendingToolCalls.get(msg.callId);
+    if (pending) {
+      pendingToolCalls.delete(msg.callId);
+      if (msg.error) {
+        pending.reject(new Error(msg.error));
+      } else {
+        pending.resolve(msg.result);
+      }
+    }
+  } else if (msg.type === "steer") {
+    steerMessages.push(msg.message);
+  } else if (msg.type === "kill") {
+    killed = true;
+  }
+});
+
+/**
+ * Request a tool call from the main thread.
+ * Returns a Promise that resolves when the main thread sends back the result.
+ */
+function requestToolCall(call, round) {
+  return new Promise((resolve, reject) => {
+    const callId = call.id ?? `${call.name}-${Date.now()}`;
+    pendingToolCalls.set(callId, { resolve, reject });
+
+    parentPort.postMessage({
+      type: "tool_call",
+      agentId,
+      round,
+      call: { name: call.name, args: call.args, id: callId },
+    });
+
+    // Tool timeout: 60s
+    setTimeout(() => {
+      if (pendingToolCalls.has(callId)) {
+        pendingToolCalls.delete(callId);
+        reject(new Error(`Tool '${call.name}' timed out in worker`));
+      }
+    }, 60_000);
+  });
+}
+
+/**
+ * Compact messages when approaching token limit.
+ * Keep system prompt + last 3 rounds, summarize the middle.
+ *
+ * @param {Array} messages
+ * @returns {Array} compacted messages
+ */
+function compactMessages(messages) {
+  const system = messages.filter(m => m.role === "system");
+  const nonSystem = messages.filter(m => m.role !== "system");
+
+  // Keep last 6 messages (≈3 rounds of user+assistant)
+  const keepTail = nonSystem.slice(-6);
+  const toSummarize = nonSystem.slice(0, -6);
+
+  if (toSummarize.length === 0) {
+    return messages; // Nothing to compact
+  }
+
+  const summaryContent = toSummarize
+    .filter(m => m.role === "user" || m.role === "assistant")
+    .map(m => `[${m.role}]: ${(m.content ?? "").slice(0, 300)}`)
+    .join("\n");
+
+  const summaryMsg = {
+    role: "user",
+    content: `[Context summary from earlier in this conversation]\n${summaryContent}\n[End of summary]`,
+  };
+
+  return [...system, summaryMsg, ...keepTail];
+}
+
+/**
+ * Make an HTTP call to the provider API.
+ * Uses the providerConfig passed from the main thread.
+ */
+async function callProvider(messages) {
+  const { provider, apiKey, model: configModel, endpoint } = providerConfig;
+  const useModel = model ?? configModel;
+
+  // Build request based on provider
+  if (provider === "anthropic") {
+    const systemMsg = messages.find(m => m.role === "system")?.content ?? "";
+    const nonSystem = messages.filter(m => m.role !== "system");
+
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify({
+        model: useModel ?? "claude-3-5-haiku-20241022",
+        max_tokens: 4096,
+        system: systemMsg,
+        messages: nonSystem.map(m => ({
+          role: m.role === "tool_result" ? "user" : m.role,
+          content: m.role === "tool_result"
+            ? [{ type: "tool_result", tool_use_id: m.toolUseId, content: JSON.stringify(m.result) }]
+            : m.role === "assistant" && m.toolCalls?.length
+              ? m.toolCalls.map(tc => ({ type: "tool_use", id: tc.id, name: tc.name, input: tc.args ?? tc.input ?? {} }))
+              : [{ type: "text", text: m.content ?? "" }],
+        })),
+        tools: (toolDefs ?? []).map(t => ({
+          name: t.name,
+          description: t.description,
+          input_schema: t.parameters,
+        })),
+      }),
+    });
+
+    const data = await response.json();
+    if (!response.ok) throw new Error(data.error?.message ?? `API error ${response.status}`);
+
+    const textBlock = data.content?.find(b => b.type === "text");
+    const toolUseBlocks = data.content?.filter(b => b.type === "tool_use") ?? [];
+
+    if (toolUseBlocks.length > 0) {
+      return {
+        type: "tool_calls",
+        calls: toolUseBlocks.map(b => ({ id: b.id, name: b.name, args: b.input })),
+      };
+    }
+    return { type: "text", text: textBlock?.text ?? "" };
+  }
+
+  // Default: OpenAI-compat
+  const url = endpoint ?? "https://api.openai.com/v1/chat/completions";
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model: useModel ?? "gpt-4o-mini",
+      messages: messages.map(m => {
+        if (m.role === "tool_result") {
+          return { role: "tool", tool_call_id: m.toolUseId, content: JSON.stringify(m.result) };
+        }
+        if (m.role === "assistant" && m.toolCalls?.length) {
+          return {
+            role: "assistant",
+            content: m.content ?? null,
+            tool_calls: m.toolCalls.map(tc => ({
+              id: tc.id,
+              type: "function",
+              function: { name: tc.name, arguments: JSON.stringify(tc.args ?? {}) },
+            })),
+          };
+        }
+        return { role: m.role, content: m.content ?? "" };
+      }),
+      tools: (toolDefs ?? []).map(t => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters },
+      })),
+    }),
+  });
+
+  const data = await response.json();
+  if (!response.ok) throw new Error(data.error?.message ?? `API error ${response.status}`);
+
+  const choice = data.choices?.[0];
+  const msg = choice?.message;
+
+  if (msg?.tool_calls?.length) {
+    return {
+      type: "tool_calls",
+      calls: msg.tool_calls.map(tc => ({
+        id: tc.id,
+        name: tc.function.name,
+        args: JSON.parse(tc.function.arguments ?? "{}"),
+      })),
+    };
+  }
+  return { type: "text", text: msg?.content ?? "" };
+}
+
+/** Main agent loop */
+async function runLoop() {
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: task },
+  ];
+
+  for (let round = 0; round < MAX_ROUNDS; round++) {
+    if (killed) {
+      parentPort.postMessage({ type: "failed", agentId, error: "killed" });
+      return;
+    }
+
+    // Inject steer messages
+    while (steerMessages.length > 0) {
+      const steer = steerMessages.shift();
+      messages.push({ role: "user", content: `[Guidance from orchestrator]: ${steer}` });
+    }
+
+    // Context compaction
+    const totalTokens = estimateMessages(messages);
+    if (totalTokens > TOKEN_LIMIT * COMPACT_THRESHOLD) {
+      const compacted = compactMessages(messages);
+      messages.length = 0;
+      messages.push(...compacted);
+    }
+
+    // Emit progress
+    parentPort.postMessage({ type: "progress", agentId, round, content: `Starting round ${round + 1}` });
+
+    // Provider call with retry + fallback handled by main thread
+    // Here we just call via the providerConfig directly
+    let result;
+    try {
+      result = await callProvider(messages);
+    } catch (err) {
+      parentPort.postMessage({ type: "failed", agentId, error: err.message });
+      return;
+    }
+
+    if (result.type === "text") {
+      parentPort.postMessage({ type: "completed", agentId, result: result.text });
+      return;
+    }
+
+    // Handle tool calls
+    messages.push({ role: "assistant", toolCalls: result.calls, content: "" });
+
+    for (const call of result.calls) {
+      if (killed) {
+        parentPort.postMessage({ type: "failed", agentId, error: "killed" });
+        return;
+      }
+
+      let toolResult;
+      try {
+        toolResult = await requestToolCall(call, round);
+      } catch (err) {
+        toolResult = { error: err.message, success: false };
+      }
+
+      parentPort.postMessage({
+        type: "tool_result",
+        agentId,
+        round,
+        toolName: call.name,
+        result: toolResult,
+      });
+
+      messages.push({
+        role: "tool_result",
+        toolName: call.name,
+        toolUseId: call.id ?? call.name,
+        result: toolResult,
+      });
+    }
+  }
+
+  // Max rounds
+  parentPort.postMessage({ type: "completed", agentId, result: "(max rounds reached — partial work above)" });
+}
+
+// Start the loop with a timeout
+const timeoutMs = timeout ?? 300_000;
+const timeoutPromise = new Promise((_, reject) =>
+  setTimeout(() => reject(new Error("Sub-agent timed out")), timeoutMs)
+);
+
+Promise.race([runLoop(), timeoutPromise]).catch((err) => {
+  parentPort.postMessage({ type: "failed", agentId, error: err.message ?? String(err) });
+});