ShockVPN/shockbot
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor delegation system, add PR summary comments, and improve code quality (#334)

Browse Source 
* refactor delegation system and add PR summary comments

Delegation system:
- replace mode-based delegation with select_mode → delegate two-step flow
- orchestrator crafts self-contained subagent prompts (clean context — no system/repo/event instructions leak)
- add role-based tool filtering via FastMCP authenticate hook (?role=subagent hides orchestrator-only tools)
- add select_mode tool for orchestrator guidance per mode
- add ask_question tool for lightweight research subagents
- extract shared subagent lifecycle into subagent.ts (create, complete, stdout, instructions)
- route set_output to per-subagent state when activeSubagentId is set
- track per-subagent state (SubagentState Map) replacing boolean delegationActive flag
- capture and aggregate AgentUsage across all agents (claude, codex, gemini, opencode)
- write usage summary table to GitHub job summary
- block built-in subagent spawning (Task for Claude, Task(*) for Cursor)
- increase activity timeout from 60s to 300s (subagent thinking phases)
- fix gh CLI misguidance in system prompt — explicitly forbid usage

PR summary comments:
- add prSummaryComment trigger (DB schema + migrations + Zod + UI toggle)
- dispatch mini-effort summary job alongside PR review on pr.created
- add update_pull_request_body MCP tool
- add defaultEffort option to webhook dispatch

Hardening:
- rewrite delegate/selectMode tests with simulated state management
- add toolFiltering.test.ts for role extraction, canAccess, set_output routing
- remove non-null assertions for PULLFROG_TEMP_DIR (proper error throws)
- use fetchWithRetry for direct tarball downloads
- DRY fix for rate limit check in test runner

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix: add type keyword to Effort import in handleWebhook.ts

Co-authored-by: Cursor <cursoragent@cursor.com>

* clean up delegation system, improve code quality across the codebase

- simplify delegate tool to instructions + effort params with subagent lifecycle in subagent.ts
- add select_mode and ask_question orchestrator-only tools with canAccess filtering
- replace delegate.test.ts/selectMode.test.ts with toolFiltering.test.ts (live MCP integration)
- add set_output routing for subagent context and AgentUsage tracking across all agents
- add PR summary comment trigger (schema, UI, webhook dispatch with silent flag)
- add update_pull_request_body MCP tool
- fix changed-agents.sh to always include claude canary for non-agent action changes
- fix cursor pagination bug in getSelectedInstallationReposPage
- remove destructuring patterns, inline type definitions, and unsafe type casts
- replace non-null assertions with explicit checks in install.ts
- convert multi-param functions to single param objects (postCleanup, runActionLocal, etc.)
- use isHttpError helper in API routes instead of catch-any patterns
- add adhoc test fixtures for delegation scenarios (context isolation, error handling, synthesis, etc.)

Co-authored-by: Cursor <cursoragent@cursor.com>

* no subagent mutation, one mcp per subagent

* address review feedback: parallel-safe usage tracking, subagent isolation, minor improvements

* fix subagent state isolation: replace Object.freeze with shallow copy

Object.freeze throws TypeErrors when subagent tools (checkout_pr,
report_progress) write scalar properties to toolState. A shallow copy
achieves the same isolation for scalar fields while allowing tools to
work normally. Shared references (subagents Map, usageEntries array)
remain shared for coordination.

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: pullfrog[bot] <226033991+pullfrog[bot]@users.noreply.github.com>
This commit is contained in:
David Blass
2026-02-22 14:12:43 +00:00
committed by pullfrog[bot]
parent a90743e9fe
commit cfd38d82fc
43 changed files with 3293 additions and 2158 deletions
Download Patch File Download Diff File Expand all files Collapse all files
agents/claude.ts
+31 -14
View File
@@ -12,7 +12,7 @@ import { log } from "../utils/cli.ts";
import { installFromNpmTarball } from "../utils/install.ts";
import { spawn } from "../utils/subprocess.ts";
import { ThinkingTimer } from "../utils/timer.ts";
import { type AgentRunContext, agent } from "./shared.ts";
import { type AgentRunContext, type AgentUsage, agent } from "./shared.ts";
// model selection based on effort level
// these are aliases that always resolve to the latest version
@@ -40,10 +40,11 @@ function buildDisallowedTools(ctx: AgentRunContext): string[] {
// both "disabled" and "restricted" block native bash
// "restricted" means use MCP bash tool instead
const bash = ctx.payload.bash;
if (bash !== "enabled") disallowed.push("Bash", "Task(Bash)");
if (bash !== "enabled") disallowed.push("Bash");
// always block native file tools (use MCP file_read/file_write instead)
disallowed.push("Read", "Write", "Edit", "MultiEdit");
disallowed.push("Task(Read)", "Task(Write)", "Task(Edit)", "Task(MultiEdit)");
// block built-in subagent spawning — delegation is handled by gh_pullfrog/delegate
disallowed.push("Task");
return disallowed;
}
@@ -128,6 +129,7 @@ export const claude = agent({
let stdoutBuffer = "";
let finalOutput = "";
const usageContainer: UsageContainer = { value: null };
// Track bash tool IDs to identify when bash tool results come back
const bashToolIds = new Set<string>();
@@ -139,7 +141,7 @@ export const claude = agent({
cwd: process.cwd(),
env: process.env,
stdio: ["ignore", "pipe", "pipe"],
activityTimeout: 0, // disabled: process-level timeout in main.ts handles this (subprocess timeout would kill orchestrator during delegation)
activityTimeout: 0, // process-level activity timeout (5min) is the single authority
onStdout: async (chunk) => {
finalOutput += chunk;
markActivity(); // reset activity timeout on any CLI output
@@ -162,7 +164,7 @@ export const claude = agent({
const handler = messageHandlers[message.type];
if (handler) {
await handler(message as never, bashToolIds, thinkingTimer);
await handler(message as never, bashToolIds, thinkingTimer, usageContainer);
}
} catch {
// ignore parse errors - might be non-JSON output
@@ -190,6 +192,7 @@ export const claude = agent({
success: false,
error: errorMessage,
output: finalOutput || result.stdout || "",
usage: usageContainer.value ?? undefined,
};
}
@@ -198,16 +201,21 @@ export const claude = agent({
return {
success: true,
output: finalOutput || result.stdout || "",
usage: usageContainer.value ?? undefined,
};
},
});
// run-local usage container — passed to handlers via closure for parallel-safe runs
type UsageContainer = { value: AgentUsage | null };
type SDKMessageType = SDKMessage["type"];
type SDKMessageHandler<type extends SDKMessageType = SDKMessageType> = (
data: Extract<SDKMessage, { type: type }>,
bashToolIds: Set<string>,
thinkingTimer: ThinkingTimer
thinkingTimer: ThinkingTimer,
usageContainer: UsageContainer
) => void | Promise<void>;
type SDKMessageHandlers = {
@@ -215,7 +223,7 @@ type SDKMessageHandlers = {
};
const messageHandlers: SDKMessageHandlers = {
assistant: (data, bashToolIds, thinkingTimer) => {
assistant: (data, bashToolIds, thinkingTimer, _usageContainer) => {
if (data.message?.content) {
for (const content of data.message.content) {
if (content.type === "text" && content.text?.trim()) {
@@ -235,7 +243,7 @@ const messageHandlers: SDKMessageHandlers = {
}
}
},
user: (data, bashToolIds, thinkingTimer) => {
user: (data, bashToolIds, thinkingTimer, _usageContainer) => {
if (data.message?.content) {
for (const content of data.message.content) {
if (typeof content === "string") {
@@ -283,7 +291,7 @@ const messageHandlers: SDKMessageHandlers = {
}
}
},
result: async (data) => {
result: async (data, _bashToolIds, _thinkingTimer, usageContainer) => {
if (data.subtype === "success") {
const usage = data.usage;
const inputTokens = usage?.input_tokens || 0;
@@ -292,6 +300,15 @@ const messageHandlers: SDKMessageHandlers = {
const outputTokens = usage?.output_tokens || 0;
const totalInput = inputTokens + cacheRead + cacheWrite;
usageContainer.value = {
agent: "claude",
inputTokens: totalInput,
outputTokens,
cacheReadTokens: cacheRead,
cacheWriteTokens: cacheWrite,
costUsd: data.total_cost_usd ?? undefined,
};
log.table([
[
{ data: "Cost", header: true },
@@ -316,9 +333,9 @@ const messageHandlers: SDKMessageHandlers = {
log.info(`Failed: ${JSON.stringify(data)}`);
}
},
system: () => {},
stream_event: () => {},
tool_progress: () => {},
tool_use_summary: () => {},
auth_status: () => {},
system: (_data, _bashToolIds, _thinkingTimer, _usageContainer) => {},
stream_event: (_data, _bashToolIds, _thinkingTimer, _usageContainer) => {},
tool_progress: (_data, _bashToolIds, _thinkingTimer, _usageContainer) => {},
tool_use_summary: (_data, _bashToolIds, _thinkingTimer, _usageContainer) => {},
auth_status: (_data, _bashToolIds, _thinkingTimer, _usageContainer) => {},
};
agents/codex.ts
+123 -95
View File
@@ -12,7 +12,7 @@ import { installFromNpmTarball } from "../utils/install.ts";
import { filterEnv } from "../utils/secrets.ts";
import { spawn } from "../utils/subprocess.ts";
import { ThinkingTimer } from "../utils/timer.ts";
import { type AgentRunContext, agent } from "./shared.ts";
import { type AgentRunContext, type AgentUsage, agent } from "./shared.ts";
// pinned CLI version — no 1-1 package.json dependency for the CLI package
// (package.json has @openai/codex-sdk which is the SDK, not the CLI)
@@ -200,6 +200,8 @@ export const codex = agent({
`» Codex options: sandboxMode=${sandboxMode}, networkAccess=${networkAccessEnabled}, webSearch=${webSearchEnabled}`
);
log.info("» running Codex CLI...");
const runState: CodexRunState = { usage: null };
const messageHandlers = createMessageHandlers();
let stdoutBuffer = "";
let finalOutput = "";
@@ -228,7 +230,7 @@ export const codex = agent({
cwd: process.cwd(),
env,
stdio: ["ignore", "pipe", "pipe"],
activityTimeout: 0, // disabled: process-level timeout in main.ts handles this (subprocess timeout would kill orchestrator during delegation)
activityTimeout: 0, // process-level activity timeout (5min) is the single authority
onStdout: async (chunk) => {
finalOutput += chunk;
markActivity(); // reset activity timeout on any CLI output
@@ -251,7 +253,7 @@ export const codex = agent({
const handler = messageHandlers[event.type as keyof typeof messageHandlers];
if (handler) {
await handler(event as never, commandExecutionIds, thinkingTimer);
await handler(event as never, commandExecutionIds, thinkingTimer, runState);
}
} catch {
// ignore parse errors - might be non-JSON output
@@ -276,6 +278,7 @@ export const codex = agent({
success: false,
error: errorMessage,
output: finalOutput || result.stdout || "",
usage: runState.usage ?? undefined,
};
}
@@ -284,109 +287,134 @@ export const codex = agent({
return {
success: true,
output: finalOutput || result.stdout || "",
usage: runState.usage ?? undefined,
};
},
});
// run-local usage accumulator — passed to handlers via closure for parallel-safe runs.
// codex fires turn.completed per-turn (not once at the end like claude/gemini),
// so we must accumulate rather than overwrite.
type CodexRunState = { usage: AgentUsage | null };
type ThreadEventHandler<type extends ThreadEvent["type"]> = (
event: Extract<ThreadEvent, { type: type }>,
commandExecutionIds: Set<string>,
thinkingTimer: ThinkingTimer
thinkingTimer: ThinkingTimer,
runState: CodexRunState
) => void | Promise<void>;
const messageHandlers: {
function createMessageHandlers(): {
[type in ThreadEvent["type"]]: ThreadEventHandler<type>;
} = {
"thread.started": () => {
// No logging needed
},
"turn.started": () => {
// No logging needed
},
"turn.completed": async (event) => {
log.table([
[
{ data: "Input Tokens", header: true },
{ data: "Cached Input Tokens", header: true },
{ data: "Output Tokens", header: true },
],
[
String(event.usage.input_tokens || 0),
String(event.usage.cached_input_tokens || 0),
String(event.usage.output_tokens || 0),
],
]);
},
"turn.failed": (event) => {
log.info(`Turn failed: ${event.error.message}`);
},
"item.started": (event, commandExecutionIds, thinkingTimer) => {
const item = event.item;
if (item.type === "command_execution") {
commandExecutionIds.add(item.id);
thinkingTimer.markToolCall();
log.toolCall({
toolName: item.command,
input: (item as any).args || {},
});
} else if (item.type === "agent_message") {
// Will be handled on completion
} else if (item.type === "mcp_tool_call") {
thinkingTimer.markToolCall();
log.toolCall({
toolName: item.tool,
input: {
server: item.server,
...((item as any).arguments || {}),
},
});
}
// Reasoning items are handled on completion for better readability
},
"item.updated": (event) => {
const item = event.item;
if (item.type === "command_execution") {
if (item.status === "in_progress" && item.aggregated_output) {
// Command is still running, could show progress if needed
} {
return {
"thread.started": () => {
// No logging needed
},
"turn.started": () => {
// No logging needed
},
"turn.completed": async (event, _commandExecutionIds, _thinkingTimer, runState) => {
const inputTokens = event.usage.input_tokens ?? 0;
const cachedInputTokens = event.usage.cached_input_tokens ?? 0;
const outputTokens = event.usage.output_tokens ?? 0;
// accumulate across turns (codex fires turn.completed per-turn, not once at end).
// note: openai's input_tokens already includes cached tokens (unlike claude's API),
// so we do not add cachedInputTokens to inputTokens — that would double-count.
if (runState.usage) {
runState.usage.inputTokens += inputTokens;
runState.usage.outputTokens += outputTokens;
runState.usage.cacheReadTokens = (runState.usage.cacheReadTokens ?? 0) + cachedInputTokens;
} else {
runState.usage = {
agent: "codex",
inputTokens,
outputTokens,
cacheReadTokens: cachedInputTokens,
};
}
}
},
"item.completed": (event, commandExecutionIds, thinkingTimer) => {
const item = event.item;
if (item.type === "agent_message") {
log.box(item.text.trim(), { title: "Codex" });
} else if (item.type === "command_execution") {
const isTracked = commandExecutionIds.has(item.id);
if (isTracked) {
thinkingTimer.markToolResult();
log.startGroup(`bash output`);
if (item.status === "failed" || (item.exit_code !== undefined && item.exit_code !== 0)) {
log.info(item.aggregated_output || "Command failed");
} else {
log.info(item.aggregated_output || "");
log.table([
[
{ data: "Input Tokens", header: true },
{ data: "Cached Input Tokens", header: true },
{ data: "Output Tokens", header: true },
],
[String(inputTokens), String(cachedInputTokens), String(outputTokens)],
]);
},
"turn.failed": (event) => {
log.info(`Turn failed: ${event.error.message}`);
},
"item.started": (event, commandExecutionIds, thinkingTimer) => {
const item = event.item;
if (item.type === "command_execution") {
commandExecutionIds.add(item.id);
thinkingTimer.markToolCall();
log.toolCall({
toolName: item.command,
input: (item as any).args || {},
});
} else if (item.type === "agent_message") {
// Will be handled on completion
} else if (item.type === "mcp_tool_call") {
thinkingTimer.markToolCall();
log.toolCall({
toolName: item.tool,
input: {
server: item.server,
...((item as any).arguments || {}),
},
});
}
// Reasoning items are handled on completion for better readability
},
"item.updated": (event) => {
const item = event.item;
if (item.type === "command_execution") {
if (item.status === "in_progress" && item.aggregated_output) {
// Command is still running, could show progress if needed
}
log.endGroup();
commandExecutionIds.delete(item.id);
}
} else if (item.type === "mcp_tool_call") {
thinkingTimer.markToolResult();
if (item.status === "failed" && item.error) {
log.info(`MCP tool call failed: ${item.error.message}`);
} else if ((item as any).output) {
// log successful MCP tool call output so it appears in captured output
const output = (item as any).output;
const outputStr = typeof output === "string" ? output : JSON.stringify(output);
log.debug(`tool output: ${outputStr}`);
},
"item.completed": (event, commandExecutionIds, thinkingTimer) => {
const item = event.item;
if (item.type === "agent_message") {
log.box(item.text.trim(), { title: "Codex" });
} else if (item.type === "command_execution") {
const isTracked = commandExecutionIds.has(item.id);
if (isTracked) {
thinkingTimer.markToolResult();
log.startGroup(`bash output`);
if (item.status === "failed" || (item.exit_code !== undefined && item.exit_code !== 0)) {
log.info(item.aggregated_output || "Command failed");
} else {
log.info(item.aggregated_output || "");
}
log.endGroup();
commandExecutionIds.delete(item.id);
}
} else if (item.type === "mcp_tool_call") {
thinkingTimer.markToolResult();
if (item.status === "failed" && item.error) {
log.info(`MCP tool call failed: ${item.error.message}`);
} else if ((item as any).output) {
// log successful MCP tool call output so it appears in captured output
const output = (item as any).output;
const outputStr = typeof output === "string" ? output : JSON.stringify(output);
log.debug(`tool output: ${outputStr}`);
}
} else if (item.type === "reasoning") {
// Display reasoning in a human-readable format
const reasoningText = item.text.trim();
// Remove markdown bold markers if present for cleaner output
const cleanText = reasoningText.replace(/\*\*/g, "");
log.box(cleanText, { title: "Codex" });
}
} else if (item.type === "reasoning") {
// Display reasoning in a human-readable format
const reasoningText = item.text.trim();
// Remove markdown bold markers if present for cleaner output
const cleanText = reasoningText.replace(/\*\*/g, "");
log.box(cleanText, { title: "Codex" });
}
},
error: (event) => {
log.info(`Error: ${event.message}`);
},
};
},
error: (event) => {
log.info(`Error: ${event.message}`);
},
};
}
agents/cursor.ts
+2
View File
@@ -421,6 +421,8 @@ function configureCursorTools(ctx: AgentRunContext): void {
if (bash !== "enabled") deny.push("Shell(*)");
// always block native file tools (use MCP file_read/file_write instead)
deny.push("Read(*)", "Write(*)", "StrReplace(*)", "EditNotebook(*)", "Delete(*)");
// block built-in subagent spawning — delegation is handled by gh_pullfrog/delegate
deny.push("Task(*)");
const config: CursorCliConfig = {
permissions: {
agents/gemini.ts
+107 -86
View File
@@ -12,7 +12,7 @@ import { installFromGithub } from "../utils/install.ts";
import { spawn } from "../utils/subprocess.ts";
import { ThinkingTimer } from "../utils/timer.ts";
import { getGitHubInstallationToken } from "../utils/token.ts";
import { type AgentRunContext, agent } from "./shared.ts";
import { type AgentRunContext, type AgentUsage, agent } from "./shared.ts";
// effort configuration: model + thinking level
// thinkingLevel is set via settings.json modelConfig.generateContentConfig.thinkingConfig
@@ -105,91 +105,108 @@ function isTransientApiError(output: string): boolean {
const MAX_ATTEMPTS = 2;
const RETRY_DELAY_MS = 5_000;
let assistantMessageBuffer = "";
const messageHandlers = {
init: (_event: GeminiInitEvent) => {
log.debug(JSON.stringify(_event, null, 2));
// initialization event - no logging needed
assistantMessageBuffer = "";
},
message: (event: GeminiMessageEvent) => {
log.debug(JSON.stringify(event, null, 2));
if (event.role === "assistant" && event.content?.trim()) {
if (event.delta) {
// accumulate delta messages
assistantMessageBuffer += event.content;
} else {
// final message - log it
const message = event.content.trim();
if (message) {
log.box(message, { title: "Gemini" });
}
assistantMessageBuffer = "";
}
} else if (event.role === "assistant" && !event.delta && assistantMessageBuffer.trim()) {
// if we have buffered content and get a non-delta message, log the buffer
log.box(assistantMessageBuffer.trim(), { title: "Gemini" });
assistantMessageBuffer = "";
}
},
tool_use: (event: GeminiToolUseEvent, thinkingTimer: ThinkingTimer) => {
log.debug(JSON.stringify(event, null, 2));
if (event.tool_name) {
thinkingTimer.markToolCall();
log.toolCall({
toolName: event.tool_name,
input: event.parameters || {},
});
}
},
tool_result: (event: GeminiToolResultEvent, thinkingTimer: ThinkingTimer) => {
log.debug(JSON.stringify(event, null, 2));
thinkingTimer.markToolResult();
if (event.status === "error") {
const errorMsg =
typeof event.output === "string" ? event.output : JSON.stringify(event.output);
log.info(`Tool call failed: ${errorMsg}`);
} else if (event.output) {
// log successful tool result so it appears in output
const outputStr =
typeof event.output === "string" ? event.output : JSON.stringify(event.output);
log.debug(`tool output: ${outputStr}`);
}
},
result: async (event: GeminiResultEvent) => {
log.debug(JSON.stringify(event, null, 2));
// log any remaining buffered assistant message
if (assistantMessageBuffer.trim()) {
log.box(assistantMessageBuffer.trim(), { title: "Gemini" });
assistantMessageBuffer = "";
}
if (event.status === "success" && event.stats) {
const stats = event.stats;
const rows: Array<Array<{ data: string; header?: boolean } | string>> = [
[
{ data: "Input Tokens", header: true },
{ data: "Output Tokens", header: true },
{ data: "Total Tokens", header: true },
{ data: "Tool Calls", header: true },
{ data: "Duration (ms)", header: true },
],
[
String(stats.input_tokens || 0),
String(stats.output_tokens || 0),
String(stats.total_tokens || 0),
String(stats.tool_calls || 0),
String(stats.duration_ms || 0),
],
];
log.table(rows);
} else if (event.status === "error") {
log.error(`Gemini CLI failed: ${JSON.stringify(event)}`);
}
},
// run-local state container — passed to handlers via closure for parallel-safe runs
type GeminiRunState = {
assistantMessageBuffer: string;
usage: AgentUsage | null;
};
function createMessageHandlers(runState: GeminiRunState) {
return {
init: (_event: GeminiInitEvent) => {
log.debug(JSON.stringify(_event, null, 2));
// initialization event - no logging needed
runState.assistantMessageBuffer = "";
},
message: (event: GeminiMessageEvent) => {
log.debug(JSON.stringify(event, null, 2));
if (event.role === "assistant" && event.content?.trim()) {
if (event.delta) {
// accumulate delta messages
runState.assistantMessageBuffer += event.content;
} else {
// final message - log it
const message = event.content.trim();
if (message) {
log.box(message, { title: "Gemini" });
}
runState.assistantMessageBuffer = "";
}
} else if (
event.role === "assistant" &&
!event.delta &&
runState.assistantMessageBuffer.trim()
) {
// if we have buffered content and get a non-delta message, log the buffer
log.box(runState.assistantMessageBuffer.trim(), { title: "Gemini" });
runState.assistantMessageBuffer = "";
}
},
tool_use: (event: GeminiToolUseEvent, thinkingTimer: ThinkingTimer) => {
log.debug(JSON.stringify(event, null, 2));
if (event.tool_name) {
thinkingTimer.markToolCall();
log.toolCall({
toolName: event.tool_name,
input: event.parameters || {},
});
}
},
tool_result: (event: GeminiToolResultEvent, thinkingTimer: ThinkingTimer) => {
log.debug(JSON.stringify(event, null, 2));
thinkingTimer.markToolResult();
if (event.status === "error") {
const errorMsg =
typeof event.output === "string" ? event.output : JSON.stringify(event.output);
log.info(`Tool call failed: ${errorMsg}`);
} else if (event.output) {
// log successful tool result so it appears in output
const outputStr =
typeof event.output === "string" ? event.output : JSON.stringify(event.output);
log.debug(`tool output: ${outputStr}`);
}
},
result: async (event: GeminiResultEvent) => {
log.debug(JSON.stringify(event, null, 2));
// log any remaining buffered assistant message
if (runState.assistantMessageBuffer.trim()) {
log.box(runState.assistantMessageBuffer.trim(), { title: "Gemini" });
runState.assistantMessageBuffer = "";
}
if (event.status === "success" && event.stats) {
const stats = event.stats;
runState.usage = {
agent: "gemini",
inputTokens: stats.input_tokens ?? 0,
outputTokens: stats.output_tokens ?? 0,
};
const rows: Array<Array<{ data: string; header?: boolean } | string>> = [
[
{ data: "Input Tokens", header: true },
{ data: "Output Tokens", header: true },
{ data: "Total Tokens", header: true },
{ data: "Tool Calls", header: true },
{ data: "Duration (ms)", header: true },
],
[
String(stats.input_tokens || 0),
String(stats.output_tokens || 0),
String(stats.total_tokens || 0),
String(stats.tool_calls || 0),
String(stats.duration_ms || 0),
],
];
log.table(rows);
} else if (event.status === "error") {
log.error(`Gemini CLI failed: ${JSON.stringify(event)}`);
}
},
};
}
async function installGemini(githubInstallationToken?: string): Promise<string> {
return await installFromGithub({
owner: "google-gemini",
@@ -227,7 +244,8 @@ export const gemini = agent({
for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
let finalOutput = "";
let stdoutBuffer = "";
assistantMessageBuffer = "";
const runState: GeminiRunState = { assistantMessageBuffer: "", usage: null };
const messageHandlers = createMessageHandlers(runState);
const thinkingTimer = new ThinkingTimer();
try {
@@ -235,7 +253,7 @@ export const gemini = agent({
cmd: "node",
args: [cliPath, ...args],
env: process.env,
activityTimeout: 0, // disabled: process-level timeout in main.ts handles this (subprocess timeout would kill orchestrator during delegation)
activityTimeout: 0, // process-level activity timeout (5min) is the single authority
onStdout: async (chunk) => {
const text = chunk.toString();
finalOutput += text;
@@ -297,6 +315,7 @@ export const gemini = agent({
success: false,
error: errorMessage,
output: finalOutput || result.stdout || "",
usage: runState.usage ?? undefined,
};
}
@@ -306,6 +325,7 @@ export const gemini = agent({
return {
success: true,
output: finalOutput,
usage: runState.usage ?? undefined,
};
} catch (error) {
const errorMessage = error instanceof Error ? error.message : String(error);
@@ -324,6 +344,7 @@ export const gemini = agent({
success: false,
error: errorMessage,
output: finalOutput || "",
usage: runState.usage ?? undefined,
};
}
}
agents/index.ts
+1 -1
View File
@@ -6,7 +6,7 @@ import { gemini } from "./gemini.ts";
import { opencode } from "./opencode.ts";
import type { Agent } from "./shared.ts";
export type { Agent } from "./shared.ts";
export type { Agent, AgentUsage } from "./shared.ts";
export const agents = {
claude,
agents/opencode.ts
+25 -3
View File
@@ -10,7 +10,7 @@ import { log } from "../utils/cli.ts";
import { installFromNpmTarball } from "../utils/install.ts";
import { spawn } from "../utils/subprocess.ts";
import { ThinkingTimer } from "../utils/timer.ts";
import { type AgentRunContext, agent } from "./shared.ts";
import { type AgentRunContext, type AgentUsage, agent } from "./shared.ts";
// pinned CLI version — no 1-1 package.json dependency for the CLI package
// (package.json has @opencode-ai/sdk which is the SDK, not the CLI)
@@ -104,6 +104,13 @@ export const opencode = agent({
let eventCount = 0;
const thinkingTimer = new ThinkingTimer();
// reset module-level state before each run (same pattern as claude/codex/gemini).
// without this, a failed subprocess that never emits an init event would
// carry stale token counts or output from a prior delegation run.
finalOutput = "";
accumulatedTokens = { input: 0, output: 0 };
tokensLogged = false;
// track recent stderr lines for provider error diagnosis.
// when OpenCode goes silent on stdout, these are the only clue.
const recentStderr: string[] = [];
@@ -119,8 +126,7 @@ export const opencode = agent({
args,
cwd: repoDir,
env,
timeout: 600000, // 10 minutes timeout to prevent infinite hangs
activityTimeout: 0, // disabled: process-level timeout in main.ts handles this (subprocess timeout would kill orchestrator during delegation)
activityTimeout: 0, // process-level activity timeout (5min) is the single authority
stdio: ["ignore", "pipe", "pipe"],
onStdout: async (chunk) => {
const text = chunk.toString();
@@ -226,6 +232,8 @@ export const opencode = agent({
]);
}
const usage = buildOpenCodeUsage();
// return result
if (result.exitCode !== 0) {
const errorContext = lastProviderError ? ` (${lastProviderError})` : "";
@@ -242,12 +250,14 @@ export const opencode = agent({
success: false,
output: finalOutput || output,
error: errorMessage,
usage,
};
}
return {
success: true,
output: finalOutput || output,
usage,
};
} catch (error) {
// activity timeout or process timeout - surface the real cause
@@ -277,6 +287,7 @@ export const opencode = agent({
success: false,
output: finalOutput || output,
error: `${errorMessage} [${diagnosis}]`,
usage: buildOpenCodeUsage(),
};
}
},
@@ -474,6 +485,17 @@ type OpenCodeEvent =
let finalOutput = "";
let accumulatedTokens: { input: number; output: number } = { input: 0, output: 0 };
let tokensLogged = false;
function buildOpenCodeUsage(): AgentUsage | undefined {
return accumulatedTokens.input > 0 || accumulatedTokens.output > 0
? {
agent: "opencode",
inputTokens: accumulatedTokens.input,
outputTokens: accumulatedTokens.output,
}
: undefined;
}
const toolCallTimings = new Map<string, number>();
let currentStepId: string | null = null;
let currentStepType: string | null = null;
agents/shared.ts
+13
View File
@@ -4,6 +4,18 @@ import { log } from "../utils/cli.ts";
import type { ResolvedInstructions } from "../utils/instructions.ts";
import type { ResolvedPayload } from "../utils/payload.ts";
/**
* token/cost usage data from a single agent run
*/
export interface AgentUsage {
agent: string;
inputTokens: number;
outputTokens: number;
cacheReadTokens?: number | undefined;
cacheWriteTokens?: number | undefined;
costUsd?: number | undefined;
}
/**
* Result returned by agent execution
*/
@@ -12,6 +24,7 @@ export interface AgentResult {
output?: string | undefined;
error?: string | undefined;
metadata?: Record<string, unknown>;
usage?: AgentUsage | undefined;
}
/**