opencode-async-agent 1.0.1 → 1.0.2

package/dist/async-agent.js

@@ -38,10 +38,106 @@ function formatDuration(startedAt, completedAt) {
 var MAX_RUN_TIME_MS = 15 * 60 * 1e3;
 
 // src/plugin/manager.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
 function parseModel(model) {
   const [providerID, ...rest] = model.split("/");
   return { providerID, modelID: rest.join("/") };
 }
+var ANALYSIS_PROMPT = `You are a session analyst. Analyze the following AI task execution comprehensively so the main agent can make informed next decisions.
+
+## Analysis Criteria
+
+### 1. Anything AI Missed Based on Initial Prompt
+- Compare the original user prompt against what was actually accomplished
+- Identify any requirements, questions, or requests that were never addressed
+- List promises made by the agent that were left unfulfilled
+
+### 2. Wrong Doings
+- Identify incorrect assumptions or bad approaches taken
+- Note any factual errors or wrong technical decisions
+- Call out misinterpretations of the original prompt
+
+### 3. Gave Up / Shortcuts
+- Did the agent abandon parts of the task prematurely?
+- Were steps skipped or incomplete solutions used?
+- Did the agent stop without exhausting reasonable options?
+- Any signs of "good enough" attitude instead of thorough completion?
+
+### 4. Messed Up
+- Did the agent break existing functionality?
+- Were new problems introduced during the task?
+- Any destructive actions or unintended side effects?
+
+### 5. Good Points / Choices
+- What technical decisions were sound and should be replicated?
+- What approaches worked well that future tasks should follow?
+- Notable strengths in this session's execution
+
+### 6. Session Ended Properly or Stream Cut Out
+- **Proper finish:** Agent concluded with clear result or summary
+- **Stream cut out:** Session interrupted mid-task with no conclusion
+- **Ambiguous end:** Final state unclear or incomplete explanation
+
+### 7. Overall Status on the Session
+- Give the main agent a complete picture of what happened
+- Was this session successful, partial, or a failure?
+- Is the output reliable enough to base next decisions on?
+
+## Output Format
+
+Provide your analysis in **markdown** with these exact sections:
+
+### Summary
+[2-3 sentence summary of what happened]
+
+### What the AI Missed Based on Initial Prompt
+[List anything not covered from the original prompt]
+
+### Wrong Doings
+[Incorrect assumptions, bad approaches, factual errors]
+
+### Gave Up / Shortcuts
+[Premature abandonment, skipped steps, incomplete solutions]
+
+### Messed Up
+[Broke things, created new problems, unintended side effects]
+
+### Good Points / Choices
+[Sound decisions, approaches worth replicating, notable strengths]
+
+### Session Completion
+- **Status:** [Proper finish / Stream cut out / Ambiguous]
+- **Details:** [explanation of how the session ended]
+
+### Overall Status
+[Complete assessment: Is this session's output reliable for next decisions? What's the verdict?]
+
+### Next Action for Main Agent
+[Specific recommendation on what the main agent should do next based on this session's outcome]
+
+---
+
+## Session Data
+
+### Initial User Prompt
+\`\`\`
+\${initialPrompt}
+\`\`\`
+
+### Full Conversation
+\`\`\`
+\${formattedMessages}
+\`\`\`
+
+### Session Metadata
+- Agent: \${agent}
+- Model: \${model}
+- Duration: \${duration}
+- Status: \${status}
+- Started: \${startTime}
+- Completed: \${completedTime}
+`;
 var DelegationManager = class {
   delegations = /* @__PURE__ */ new Map();
   client;
@@ -54,6 +150,29 @@ var DelegationManager = class {
   calculateDuration(delegation) {
     return formatDuration(delegation.startedAt, delegation.completedAt);
   }
+  // ---- Parent session model ----
+  async getParentModel(parentSessionID) {
+    try {
+      const messagesResult = await this.client.session.messages({
+        path: { id: parentSessionID }
+      });
+      const messageData = messagesResult.data;
+      if (!messageData || messageData.length === 0) {
+        return null;
+      }
+      const lastUserMessage = [...messageData].reverse().find((m) => m.info.role === "user");
+      if (!lastUserMessage || !lastUserMessage.info.model) {
+        return null;
+      }
+      const model = lastUserMessage.info.model;
+      const modelString = `${model.providerID}/${model.modelID}`;
+      await this.debugLog(`Got parent model: ${modelString}`);
+      return modelString;
+    } catch (error) {
+      this.log.debug(`Failed to get parent model: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return null;
+    }
+  }
   // ---- Core operations ----
   async delegate(input) {
     await this.debugLog(`delegate() called`);
@@ -80,12 +199,14 @@ ${available || "(none)"}`
       throw new Error("Failed to create delegation session");
     }
     const sessionID = sessionResult.data.id;
+    const parentModel = await this.getParentModel(input.parentSessionID);
     const delegation = {
       id: sessionID,
       sessionID,
       parentSessionID: input.parentSessionID,
       parentMessageID: input.parentMessageID,
       parentAgent: input.parentAgent,
+      parentModel,
       prompt: input.prompt,
       agent: input.agent,
       model: input.model,
@@ -279,6 +400,14 @@ ${available || "(none)"}`
 Use delegation_list() to see available delegations.`);
     }
     if (delegation.status === "running") {
+      if (args.ai) {
+        return `Delegation "${args.id}" is still running.
+
+Status: ${delegation.status}
+Started: ${delegation.startedAt.toISOString()}
+
+Wait for completion notification, then call delegation_read() again. AI analysis only available for completed sessions.`;
+      }
       return `Delegation "${args.id}" is still running.
 
 Status: ${delegation.status}
@@ -296,6 +425,16 @@ Error: ${delegation.error}`;
 Duration: ${delegation.duration}`;
       return statusMessage;
     }
+    if (args.ai) {
+      let model = args.ai_model;
+      if (!model) {
+        model = delegation.parentModel || await this.getDefaultModel();
+        if (!model) {
+          return "\u274C ai_model required when ai=true and no default model configured (parent session has no model)";
+        }
+      }
+      return await this.analyzeSessionWithAI(delegation, model);
+    }
     if (!args.mode || args.mode === "simple") {
       return await this.getSimpleResult(delegation);
     }
@@ -528,6 +667,221 @@ To inspect session content(human): opencode -s ${delegation.id}`;
   async debugLog(msg) {
     this.log.debug(msg);
   }
+  // ---- AI Analysis ----
+  async getDefaultModel() {
+    try {
+      const result = await this.client.config.get();
+      const config = result.data;
+      return config?.model || null;
+    } catch (error) {
+      this.log.debug(`Failed to get default model: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return null;
+    }
+  }
+  getModelInfo(modelId) {
+    const [provider, ...rest] = modelId.split("/");
+    if (!provider) {
+      throw new Error(`Invalid model format: "${modelId}". Expected "provider/model"`);
+    }
+    const modelIdOnly = rest.join("/");
+    try {
+      const modelJsonPath = join(process.env.HOME || "", ".cache", "opencode", "models.json");
+      const content = readFileSync(modelJsonPath, "utf-8");
+      const modelsData = JSON.parse(content);
+      if (!modelsData[provider]) {
+        throw new Error(`Provider "${provider}" not found in models.json`);
+      }
+      const providerData = modelsData[provider];
+      const apiUrl = providerData.api || providerData.baseUrl;
+      if (!apiUrl) {
+        throw new Error(`No API URL found for provider "${provider}"`);
+      }
+      return { provider, apiUrl, modelId: modelIdOnly };
+    } catch (error) {
+      if (error instanceof Error) throw error;
+      throw new Error(`Failed to parse models.json: ${error}`);
+    }
+  }
+  getApiKey(provider) {
+    try {
+      const authJsonPath = join(process.env.HOME || "", ".local", "share", "opencode", "auth.json");
+      const content = readFileSync(authJsonPath, "utf-8");
+      const authData = JSON.parse(content);
+      if (!authData[provider]) {
+        throw new Error(`Provider "${provider}" not found in auth.json`);
+      }
+      const providerAuth = authData[provider];
+      if (providerAuth.type !== "api") {
+        throw new Error(`Provider "${provider}" is not an API key type`);
+      }
+      return providerAuth.key;
+    } catch (error) {
+      if (error instanceof Error) throw error;
+      throw new Error(`Failed to parse auth.json: ${error}`);
+    }
+  }
+  formatSessionForAI(messages, delegation) {
+    let initialPrompt = delegation.prompt;
+    const parts = [];
+    for (const msg of messages) {
+      const role = msg.info.role.toUpperCase();
+      const timestamp = msg.info.time?.created ? new Date(msg.info.time.created).toISOString() : "unknown";
+      parts.push(`[${role}] ${timestamp}`);
+      for (const part of msg.parts) {
+        switch (part.type) {
+          case "text":
+            if (part.text) {
+              parts.push(part.text.trim());
+            }
+            break;
+          case "reasoning":
+          case "thinking":
+            const thinkingText = part.thinking || part.text || "";
+            if (thinkingText) {
+              parts.push(`[REASONING] ${thinkingText.slice(0, 2e3)}`);
+            }
+            break;
+          case "tool":
+            if (part.state) {
+              const toolInput = part.state.status === "pending" || part.state.status === "running" ? JSON.stringify(part.state.input || {}) : JSON.stringify(part.state.input || {});
+              parts.push(`[TOOL CALL] ${part.tool}: ${toolInput}`);
+            }
+            break;
+          case "tool_result":
+            const content = part.content || part.output || "";
+            parts.push(`[TOOL RESULT] ${content}`);
+            break;
+          case "file":
+            parts.push(`[FILE] ${part.filename || "unknown file"} (${part.mime})`);
+            break;
+          case "patch":
+            parts.push(`[PATCH] Code diff applied`);
+            break;
+          case "snapshot":
+            parts.push(`[SNAPSHOT] State snapshot`);
+            break;
+          case "agent":
+            parts.push(`[AGENT] Switched to: ${part.name || "unknown"}`);
+            break;
+          default:
+            parts.push(`[${part.type}] ${JSON.stringify(part).slice(0, 200)}`);
+        }
+      }
+      parts.push("");
+    }
+    return `# Full Conversation
+
+${parts.join("\n")}`;
+  }
+  async callAIForAnalysis(apiUrl, apiKey, model, prompt, timeoutMs = 6e4) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const url = apiUrl.endsWith("/") ? `${apiUrl}chat/completions` : `${apiUrl}/chat/completions`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model,
+          messages: [{ role: "user", content: prompt }],
+          max_tokens: 4e3,
+          temperature: 0.3
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`API request failed: ${response.status} ${response.statusText}
+${errorText}`);
+      }
+      const data = await response.json();
+      if (!data.choices || !data.choices[0] || !data.choices[0].message) {
+        throw new Error("Invalid API response format");
+      }
+      return data.choices[0].message.content;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error("AI analysis timed out after 60 seconds");
+      }
+      throw error;
+    }
+  }
+  logAnalysis(delegationId, model, result, error, duration) {
+    if (process.env.OC_ASYNC_DEBUG !== "true") {
+      return;
+    }
+    try {
+      const logDir = join(process.env.HOME || "", ".cache", "opencode-delegation-ai");
+      if (!existsSync(logDir)) {
+        mkdirSync(logDir, { recursive: true });
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const filename = `analysis-${delegationId}-${timestamp}.json`;
+      const logEntry = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        delegationId,
+        model,
+        status: error ? "error" : "success",
+        durationMs: duration,
+        result: error ? void 0 : result,
+        error: error || void 0
+      };
+      writeFileSync(join(logDir, filename), JSON.stringify(logEntry, null, 2));
+    } catch (err) {
+      this.log.debug(`Failed to log analysis: ${err}`);
+    }
+  }
+  async analyzeSessionWithAI(delegation, model) {
+    const startTime = Date.now();
+    try {
+      const modelInfo = this.getModelInfo(model);
+      const apiKey = this.getApiKey(modelInfo.provider);
+      const messagesResult = await this.client.session.messages({
+        path: { id: delegation.sessionID }
+      });
+      const messageData = messagesResult.data;
+      if (!messageData || messageData.length === 0) {
+        return `Delegation "${delegation.id}" has no messages to analyze.`;
+      }
+      const formattedMessages = this.formatSessionForAI(messageData, delegation);
+      const initialPrompt = messageData.find((m) => m.info.role === "user")?.parts.filter((p) => p.type === "text").map((p) => p.text).join("\n") || delegation.prompt;
+      const sessionMetadata = `
+### Session Metadata
+- Agent: ${delegation.agent}
+- Model: ${delegation.model || "unknown"}
+- Duration: ${delegation.duration || "N/A"}
+- Status: ${delegation.status}
+- Started: ${delegation.startedAt.toISOString()}
+- Completed: ${delegation.completedAt?.toISOString() || "N/A"}
+`;
+      const fullPrompt = ANALYSIS_PROMPT.replace("${initialPrompt}", initialPrompt).replace("${formattedMessages}", formattedMessages).replace("${agent}", delegation.agent).replace("${model}", delegation.model || "unknown").replace("${duration}", delegation.duration || "N/A").replace("${status}", delegation.status).replace("${startTime}", delegation.startedAt.toISOString()).replace("${completedTime}", delegation.completedAt?.toISOString() || "N/A");
+      const analysis = await this.callAIForAnalysis(modelInfo.apiUrl, apiKey, modelInfo.modelId, fullPrompt);
+      const duration = Date.now() - startTime;
+      this.logAnalysis(delegation.id, model, analysis, void 0, duration);
+      const header = `# AI Analysis for Delegation: ${delegation.id}
+
+**Agent:** ${delegation.agent}
+**Analysis Model:** ${model}
+**Duration:** ${delegation.duration || "N/A"}
+**Analysis Time:** ${(duration / 1e3).toFixed(2)}s
+
+---
+
+`;
+      return header + analysis;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logAnalysis(delegation.id, model, "", errorMessage, duration);
+      return `\u274C AI analysis failed:
+
+${errorMessage}`;
+    }
+  }
 };
 
 // src/plugin/tools.ts
@@ -598,6 +952,7 @@ function createDelegationRead(manager) {
 Modes:
 - simple (default): Returns just the final result
 - full: Returns all messages in the session with timestamps
+- ai (requires ai=true): Use AI to analyze and summarize the entire session execution
 
 Use filters to get specific parts of the conversation.`,
     args: {
@@ -606,7 +961,9 @@ Use filters to get specific parts of the conversation.`,
       include_thinking: tool.schema.boolean().optional().describe("Include thinking/reasoning blocks in full mode"),
       include_tools: tool.schema.boolean().optional().describe("Include tool results in full mode"),
       since_message_id: tool.schema.string().optional().describe("Return only messages after this message ID (full mode only)"),
-      limit: tool.schema.number().optional().describe("Max messages to return, capped at 100 (full mode only)")
+      limit: tool.schema.number().optional().describe("Max messages to return, capped at 100 (full mode only)"),
+      ai: tool.schema.boolean().optional().describe("Use AI to analyze and summarize the session"),
+      ai_model: tool.schema.string().optional().describe("Model for AI analysis (e.g. 'minimax/MiniMax-M2.5'). Required when ai=true if no default model configured")
     },
     async execute(args, toolCtx) {
       if (!toolCtx?.sessionID) {
@@ -749,11 +1106,11 @@ You WILL be notified via \`<system-reminder>\`. Polling wastes tokens.
 async function readBgAgentsConfig() {
   const { homedir } = await import("os");
   const { readFile } = await import("fs/promises");
-  const { join } = await import("path");
-  const configDir = join(homedir(), ".config", "opencode");
+  const { join: join2 } = await import("path");
+  const configDir = join2(homedir(), ".config", "opencode");
   for (const name of ["async-agents.md", "async-agent.md"]) {
     try {
-      return await readFile(join(configDir, name), "utf-8");
+      return await readFile(join2(configDir, name), "utf-8");
     } catch {
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-async-agent",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "main": "dist/async-agent.js",
   "files": ["dist"],
   "scripts": {