acmecode 1.0.0

package/packages/core/src/agent/index.ts

@@ -0,0 +1,588 @@
+import { streamText, tool as createTool } from "ai";
+import { existsSync, readFileSync, promises as fs } from "fs";
+import { resolve } from "path";
+import { getModel, ProviderType } from "../llm/provider.js";
+import { builtInTools, toolExecutors, isCommandSafe } from "../tools/index.js";
+import { getMcpTools } from "../mcp/index.js";
+import { getSystemPrompt } from "../prompt/index.js";
+import { ReasoningLevel, AgentMode } from "../config/index.js";
+
+// ── Structured event types ──
+export type AgentEvent =
+  | { type: "text"; text: string }
+  | {
+      type: "tool-call";
+      name: string;
+      args: Record<string, unknown>;
+      toolCallId?: string;
+    }
+  | {
+      type: "tool-call-delta";
+      name: string;
+      args: Record<string, unknown>;
+      partial?: boolean;
+      toolCallId?: string;
+    }
+  | { type: "tool-result"; name: string; result: string; toolCallId?: string }
+  | { type: "tool-generating"; name: string; args: Record<string, unknown> }
+  | {
+      type: "tool-approval-required";
+      name: string;
+      args: Record<string, unknown>;
+      riskLevel?: string;
+      isLocalGuard?: boolean;
+    }
+  | { type: "messages"; messages: any[]; promptLength?: number }
+  | { type: "step"; step: number; maxSteps: number }
+  | { type: "finish"; usage: any }
+  | { type: "mode-changed"; mode: AgentMode; planFile?: string };
+
+// ── Configuration ──
+const MAX_STEPS = 80;
+const MAX_OUTPUT_LENGTH = 30000;
+const MAX_RETRIES = 2;
+
+// ── Model-specific output token limits ──
+function getMaxOutputTokens(
+  modelName: string,
+  level: ReasoningLevel,
+): number | undefined {
+  const lower = modelName.toLowerCase();
+  const isReasoningModel =
+    lower.includes("o1") || lower.includes("o3") || lower.includes("o4");
+
+  if (isReasoningModel) {
+    if (level === "max" || level === "xhigh") return 100000;
+    if (level === "high") return 64000;
+    return 32000;
+  }
+
+  if (lower.includes("4-6") || lower.includes("4.6")) {
+    // User specified Opus 4.6 (relay variant) supports 16000
+    return 16000;
+  }
+  if (lower.includes("claude-3-5") || lower.includes("sonnet")) {
+    return 8192;
+  }
+  if (lower.includes("claude")) {
+    // Standard Opus and other Claude models usually have a 4096 output limit.
+    return 4096;
+  }
+  if (lower.includes("gpt-4")) return 16384;
+  if (lower.includes("gemini")) return 65536;
+  if (lower.includes("deepseek")) return 16384;
+  return 4096; // Safe default for most models
+}
+
+// ── Reasoning Attempt Mapping ──
+function getReasoningEffort(
+  level: ReasoningLevel,
+): "low" | "medium" | "high" | undefined {
+  switch (level) {
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+      return "high";
+    case "max":
+      return "high";
+    case "xhigh":
+      return "high";
+    default:
+      return undefined;
+  }
+}
+
+// ── Temperature defaults ──
+function getDefaultTemperature(modelName: string): number | undefined {
+  const lower = modelName.toLowerCase();
+  // Reasoning models and Claude don't support temperature or it's better to let provider decide
+  if (lower.includes("o1") || lower.includes("o3") || lower.includes("o4"))
+    return undefined;
+  if (lower.includes("claude")) return undefined;
+  if (lower.includes("deepseek-r1") || lower.includes("deepseek-reasoner"))
+    return undefined;
+  return 0;
+}
+
+/**
+ * Run the AI agent with streaming, multi-step tool calls, and structured events.
+ * Inspired by opencode's LLM.stream() pattern.
+ */
+export async function* runAgent(
+  provider: ProviderType,
+  modelName: string,
+  messages: any[],
+  systemPrompt?: string,
+  abortSignal?: AbortSignal,
+  reasoningLevel: ReasoningLevel = "medium",
+  agentMode: AgentMode = "agent",
+  activePlanFile?: string,
+  activeSkillContent?: string,
+): AsyncGenerator<AgentEvent, any[], unknown> {
+  const model = getModel(provider, modelName);
+  const mcpTools = await getMcpTools();
+
+  let currentMessages = [...messages];
+  let stepCount = 0;
+  const globalCalledSet = new Set<string>();
+
+  const temperature = getDefaultTemperature(modelName);
+  const maxOutputTokens = getMaxOutputTokens(modelName, reasoningLevel);
+  const reasoningEffort = getReasoningEffort(reasoningLevel);
+
+  let currentMode = agentMode;
+  let currentPlanFile = activePlanFile;
+
+  // We keep system dynamic so it updates properly if the agent switches mode mid-loop.
+  let system =
+    systemPrompt ||
+    (await getSystemPrompt(
+      provider,
+      modelName,
+      currentMode,
+      currentPlanFile,
+      activeSkillContent,
+    ));
+  yield {
+    type: "messages",
+    messages: [...messages],
+    promptLength: system.length,
+  };
+
+  let consecutiveErrors = 0;
+
+  while (stepCount < MAX_STEPS) {
+    stepCount++;
+    yield { type: "step", step: stepCount, maxSteps: MAX_STEPS };
+
+    const currentTools: Record<string, any> = {
+      ...builtInTools,
+      ...mcpTools,
+    };
+
+    if (currentMode === "plan") {
+      delete currentTools["run_command"];
+      delete currentTools["edit_file"];
+      delete currentTools["lsp"];
+      delete currentTools["grep_search"];
+    }
+
+    let stepText = "";
+    const collectedToolCalls: {
+      name: string;
+      args: Record<string, unknown>;
+    }[] = [];
+    const collectedToolResults: { name: string; result: string }[] = [];
+    let modeDidSwitch = false;
+
+    // ── Message cleaning (especially for Anthropic) ──
+    const purifiedMessages = currentMessages
+      .map((msg) => {
+        if (typeof msg.content === "string") return msg;
+        if (!Array.isArray(msg.content)) return msg;
+
+        return {
+          ...msg,
+          content: msg.content.filter((part: any) => {
+            if (part.type === "text")
+              return part.text && part.text.trim().length > 0;
+            if (part.type === "tool-call" || part.type === "tool-result") {
+              // Normalize tool call IDs to alphanumeric + underscores
+              if (part.toolCallId) {
+                part.toolCallId = part.toolCallId.replace(
+                  /[^a-zA-Z0-9_-]/g,
+                  "_",
+                );
+              }
+            }
+            return true;
+          }),
+        };
+      })
+      .filter((msg) => {
+        if (!msg.content) return false;
+        if (Array.isArray(msg.content) && msg.content.length === 0)
+          return false;
+        return true;
+      });
+
+    try {
+      const result = await streamText({
+        model,
+        messages: purifiedMessages,
+        system,
+        tools: currentTools,
+        maxSteps: 1,
+        maxRetries: MAX_RETRIES,
+        temperature,
+        maxOutputTokens,
+        abortSignal,
+        experimental_toolCallStreaming: true,
+        providerOptions: {
+          openai: reasoningEffort ? { reasoningEffort } : undefined,
+          anthropic:
+            provider === "anthropic" &&
+            (modelName.includes("sonnet") || modelName.includes("opus"))
+              ? {
+                  thinking: {
+                    type: "enabled",
+                    budgetTokens: Math.min(maxOutputTokens || 4096, 16000),
+                  },
+                }
+              : undefined,
+          google:
+            provider === "google" && modelName.includes("thinking")
+              ? {
+                  thinkingConfig: { includeThoughts: true },
+                }
+              : undefined,
+        },
+
+        // ── Tool name repair (from opencode) ──
+        async experimental_repairToolCall(failed: any) {
+          const lower = failed.toolCall.toolName.toLowerCase();
+          if (lower !== failed.toolCall.toolName && currentTools[lower]) {
+            return { ...failed.toolCall, toolName: lower };
+          }
+          return {
+            ...failed.toolCall,
+            input: JSON.stringify({
+              tool: failed.toolCall.toolName,
+              error: failed.error?.message || "Unknown tool",
+            }),
+            toolName: "invalid",
+          };
+        },
+      } as any);
+
+      let lastFinishReason: string | undefined;
+      const yieldedToolCalls = new Set<string>();
+
+      for await (const chunk of result.fullStream) {
+        if (abortSignal?.aborted) {
+          yield { type: "text", text: "\n[Aborted by user]\n" };
+          yield { type: "messages", messages: currentMessages };
+          return [];
+        }
+
+        if (chunk.type === "text-delta") {
+          const text = (chunk as any).textDelta || (chunk as any).text || "";
+          if (text) {
+            stepText += text;
+            if (stepText.length > MAX_OUTPUT_LENGTH) {
+              yield {
+                type: "text",
+                text: "\n[Error: Output exceeded maximum length]\n",
+              };
+              break;
+            }
+            yield { type: "text", text };
+          }
+        } else if (chunk.type === "tool-call") {
+          const name = (chunk as any).toolName || "";
+          const rawArgs = (chunk as any).input || (chunk as any).args;
+          const args =
+            typeof rawArgs?.toObject === "function"
+              ? rawArgs.toObject()
+              : rawArgs || {};
+          const id = (chunk as any).toolCallId;
+          if (name && id && !yieldedToolCalls.has(id)) {
+            yieldedToolCalls.add(id);
+            collectedToolCalls.push({ name, args });
+            yield { type: "tool-call", name, args, toolCallId: id };
+          }
+        } else if ((chunk as any).type === "tool-call-delta") {
+          const name = (chunk as any).toolName || "";
+          const rawArgs = (chunk as any).input || (chunk as any).args;
+          const args =
+            typeof rawArgs?.toObject === "function"
+              ? rawArgs.toObject()
+              : rawArgs || {};
+          const id = (chunk as any).toolCallId;
+          if (name && id) {
+            yield {
+              type: "tool-call-delta",
+              name,
+              args,
+              partial: !!(chunk as any).partial,
+            };
+          }
+        } else if (chunk.type === "tool-result") {
+          const name = (chunk as any).toolName || "";
+          const toolCallId = (chunk as any).toolCallId;
+          const rawResult =
+            (chunk as any).result ?? (chunk as any).output ?? "";
+          const resultStr =
+            typeof rawResult === "string"
+              ? rawResult
+              : JSON.stringify(rawResult);
+          collectedToolResults.push({ name, result: resultStr });
+          yield { type: "tool-result", name, result: resultStr, toolCallId };
+
+          if (name === "switch_mode") {
+            try {
+              const parsed =
+                typeof rawResult === "object"
+                  ? rawResult
+                  : JSON.parse(resultStr);
+              if (parsed.switched_mode) {
+                currentMode = parsed.switched_mode;
+                currentPlanFile = parsed.contextFile;
+                modeDidSwitch = true;
+                yield {
+                  type: "mode-changed",
+                  mode: currentMode as AgentMode,
+                  planFile: currentPlanFile,
+                };
+              }
+            } catch {}
+          }
+        } else if (chunk.type === "finish") {
+          lastFinishReason = (chunk as any).finishReason || "unknown";
+        }
+      }
+
+      // Proactive checks for silent stream drops (graceful socket close but incomplete thought)
+      const isAbruptDrop =
+        !lastFinishReason ||
+        ["unknown", "error", "length"].includes(lastFinishReason);
+      if (isAbruptDrop && collectedToolCalls.length === 0) {
+        // Ignore abrupt drops if it's obvious a tool was meant to be used but we couldn't parse it?
+        // Actually, if we couldn't parse it, we want the LLM to resume and finish the syntax.
+        throw new Error(
+          `Stream terminated prematurely with finish_reason: ${lastFinishReason || "No finish chunk received"}`,
+        );
+      }
+
+      consecutiveErrors = 0; // Reset upon successful stream completion
+    } catch (err: any) {
+      if (err.name === "AbortError" || abortSignal?.aborted) {
+        yield { type: "text", text: "\n[Aborted by user]\n" };
+        yield { type: "messages", messages: currentMessages };
+        return [];
+      } else {
+        yield {
+          type: "text",
+          text: `\n[Error: ${err.message}]\n[Auto-recovering from stream drop...]\n`,
+        };
+
+        if (stepText.trim()) {
+          currentMessages.push({ role: "assistant", content: stepText });
+        }
+
+        consecutiveErrors++;
+        if (consecutiveErrors >= 3) {
+          yield {
+            type: "text",
+            text: `\n[Fatal Error: Stream dropped ${consecutiveErrors} times consecutively. Halting agent to prevent infinite loops.]\n`,
+          };
+          yield { type: "messages", messages: currentMessages };
+          return [];
+        }
+
+        currentMessages.push({
+          role: "user",
+          content: `[System Error: The network stream disconnected prematurely with error: ${err.message || err}. Please carefully analyze the incomplete text you just generated, and continue your thought or tool execution precisely from where it was cut off without repeating yourself.]`,
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        continue;
+      }
+    }
+
+    if (collectedToolCalls.length === 0) {
+      const parseText = stepText
+        .replace(/<think>[\s\S]*?<\/think>/g, "")
+        .trim();
+
+      for (const [toolName, toolFn] of Object.entries(toolExecutors)) {
+        const patterns = [
+          new RegExp(`<${toolName}>([\\s\\S]*?)<\\/${toolName}>`, "g"),
+          new RegExp(`\\[${toolName}\\(([^\\[\\]]*)\\)\\]`, "g"),
+        ];
+
+        for (const regex of patterns) {
+          regex.lastIndex = 0;
+          let match;
+          while ((match = regex.exec(parseText)) !== null) {
+            const innerText = match[1].trim();
+            const args: Record<string, string> = {};
+
+            const argRegex = /<(\w+)>([\s\S]*?)<\/\1>/g;
+            let argMatch;
+            let foundInnerArgs = false;
+            while ((argMatch = argRegex.exec(innerText)) !== null) {
+              args[argMatch[1]] = argMatch[2].trim();
+              foundInnerArgs = true;
+            }
+
+            if (!foundInnerArgs && innerText) {
+              if (toolName === "list_dir" || toolName === "read_file") {
+                args.path = innerText.replace(/^["']|["']$/g, "").trim();
+              } else if (toolName === "run_command") {
+                args.command = innerText.replace(/^["']|["']$/g, "").trim();
+                if (!args.riskLevel) {
+                  // Default to high if model didn't self-assess in fallback tag
+                  args.riskLevel = "high";
+                }
+              }
+            }
+
+            const firstArgValue = Object.values(args)[0] as string | undefined;
+            if (!firstArgValue) continue;
+
+            const dedupKey = `${toolName}:${JSON.stringify(args)}`;
+            if (globalCalledSet.has(dedupKey)) continue;
+            globalCalledSet.add(dedupKey);
+
+            collectedToolCalls.push({ name: toolName, args });
+
+            // Safety Check for run_command
+            if (toolName === "run_command") {
+              const localDanger = !isCommandSafe(args.command);
+              const modelRisk = args.riskLevel as string;
+              const needsApproval =
+                localDanger || modelRisk === "medium" || modelRisk === "high";
+
+              if (needsApproval) {
+                const approved = yield {
+                  type: "tool-approval-required",
+                  name: toolName,
+                  args,
+                  riskLevel: modelRisk,
+                  isLocalGuard: localDanger,
+                };
+                if (!approved) {
+                  const resultStr =
+                    "Error: User denied execution of dangerous command.";
+                  collectedToolResults.push({
+                    name: toolName,
+                    result: resultStr,
+                  });
+                  yield { type: "tool-call", name: toolName, args };
+                  yield {
+                    type: "tool-result",
+                    name: toolName,
+                    result: resultStr,
+                  };
+                  continue;
+                }
+              }
+            }
+
+            yield { type: "tool-call", name: toolName, args };
+            yield { type: "tool-generating", name: toolName, args };
+
+            try {
+              const result = await toolFn(args as any);
+              const resultStr =
+                typeof result === "string" ? result : JSON.stringify(result);
+              collectedToolResults.push({ name: toolName, result: resultStr });
+              yield { type: "tool-result", name: toolName, result: resultStr };
+
+              if (toolName === "switch_mode") {
+                try {
+                  const parsed =
+                    typeof result === "object" ? result : JSON.parse(resultStr);
+                  if (parsed.switched_mode) {
+                    currentMode = parsed.switched_mode;
+                    currentPlanFile = parsed.contextFile;
+                    modeDidSwitch = true;
+                    yield {
+                      type: "mode-changed",
+                      mode: currentMode as AgentMode,
+                      planFile: currentPlanFile,
+                    };
+                  }
+                } catch {}
+              }
+            } catch (err: any) {
+              const resultStr = `Error: ${err.message}`;
+              collectedToolResults.push({ name: toolName, result: resultStr });
+              yield { type: "tool-call", name: toolName, args }; // Emitted after error for history mapping
+              yield { type: "tool-result", name: toolName, result: resultStr };
+            }
+          }
+        }
+      }
+    }
+
+    if (collectedToolCalls.length === 0) {
+      if (!stepText.trim()) {
+        consecutiveErrors++;
+        if (consecutiveErrors < 3) {
+          yield {
+            type: "text",
+            text: `\n[System Notice: The model returned an empty response. Auto-retrying (${consecutiveErrors}/3)...]\n`,
+          };
+          currentMessages.push({
+            role: "user",
+            content: `[System] Your previous response was empty. Please continue your task or provide a status update.`,
+          });
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+          continue;
+        } else {
+          yield {
+            type: "text",
+            text: `\n[Fatal Error: Model returned empty response 3 times consecutively. Halting.]\n`,
+          };
+          currentMessages.push({ role: "assistant", content: stepText });
+          yield { type: "messages", messages: currentMessages };
+          return [];
+        }
+      }
+
+      currentMessages.push({ role: "assistant", content: stepText });
+      yield { type: "messages", messages: currentMessages };
+      return [];
+    }
+
+    yield { type: "text", text: "\n" };
+
+    const toolSummary = collectedToolResults
+      .map((tr, i) => {
+        const tc = collectedToolCalls[i];
+        const argsStr = tc
+          ? Object.entries(tc.args)
+              .filter(([k]) => k !== "content")
+              .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+              .join(", ")
+          : "";
+        const resultBody =
+          tr.result.length > 10000
+            ? tr.result.slice(0, 10000) + "\n... (truncated)"
+            : tr.result;
+        return `### Tool: ${tr.name}(${argsStr})\n\`\`\`\n${resultBody}\n\`\`\``;
+      })
+      .join("\n\n");
+
+    currentMessages.push({ role: "assistant", content: stepText });
+    currentMessages.push({
+      role: "user",
+      content: `[SYSTEM] Tool results:\n\n${toolSummary}\n\nContinue with your task. Do NOT re-call the same tools.`,
+    });
+
+    // Recompute system prompt immediately if mode changed so the next loop has the right persona/length
+    if (modeDidSwitch && !systemPrompt) {
+      system = await getSystemPrompt(
+        provider,
+        modelName,
+        currentMode as AgentMode,
+        currentPlanFile,
+        activeSkillContent,
+      );
+    }
+
+    yield {
+      type: "messages",
+      messages: currentMessages,
+      promptLength: system.length,
+    };
+  }
+
+  yield { type: "text", text: "\n[Reached maximum steps]\n" };
+  yield { type: "messages", messages: currentMessages };
+  return [];
+}