pullfrog 0.0.200 → 0.0.202

package/dist/agents/index.d.ts

@@ -2,5 +2,5 @@ import type { Agent } from "./shared.ts";
 export type { Agent, AgentUsage } from "./shared.ts";
 export declare const agents: {
     claude: Agent;
-    opentoad: Agent;
+    opencode: Agent;
 };

package/dist/agents/opencode.d.ts

@@ -0,0 +1 @@
+export declare const opencode: import("./shared.ts").Agent;

package/dist/agents/shared.d.ts

@@ -7,16 +7,31 @@ export declare const MAX_COMMIT_RETRIES = 3;
 export declare function getGitStatus(): string;
 export declare function buildCommitPrompt(_agentId: AgentId, status: string): string;
 /**
- * token/cost usage data from a single agent run
+ * token/cost usage data from a single agent run.
+ *
+ * NOTE on semantics: `inputTokens` here is the *total* billable input for the
+ * run — non-cached input + cache read + cache write — matching the per-agent
+ * SDK conventions. This is what gets persisted to `WorkflowRun.inputTokens`.
+ *
+ * The stdout token table and markdown step summary display a different "Input"
+ * column that shows only the non-cached portion (derivable as
+ * `inputTokens - cacheReadTokens - cacheWriteTokens`) so humans can see the
+ * cache hit ratio at a glance. Dashboards that query `WorkflowRun.inputTokens`
+ * directly are seeing the full total, not the log column.
  */
 export interface AgentUsage {
     agent: string;
+    /** full billable input: non-cached + cache read + cache write */
     inputTokens: number;
     outputTokens: number;
     cacheReadTokens?: number | undefined;
     cacheWriteTokens?: number | undefined;
     costUsd?: number | undefined;
 }
+export interface AgentToolUseEvent {
+    toolName: string;
+    input: unknown;
+}
 /**
  * Result returned by agent execution
  */
@@ -37,6 +52,13 @@ export interface AgentRunContext {
     tmpdir: string;
     instructions: ResolvedInstructions;
     todoTracker?: TodoTracker | undefined;
+    /**
+     * called synchronously when the agent subprocess is killed for inner
+     * activity timeout. lets main.ts tear down shared resources (MCP HTTP
+     * server) so lingering SSE reconnects don't keep the outer timer alive.
+     */
+    onActivityTimeout?: (() => void) | undefined;
+    onToolUse?: ((event: AgentToolUseEvent) => void) | undefined;
 }
 export interface Agent {
     name: AgentId;
@@ -44,3 +66,45 @@ export interface Agent {
     run: (ctx: AgentRunContext) => Promise<AgentResult>;
 }
 export declare const agent: (input: Agent) => Agent;
+/** format a USD cost to 4 decimal places, always showing the leading zero */
+export declare function formatCostUsd(costUsd: number): string;
+/**
+ * merge two AgentUsage snapshots into one running total.
+ *
+ * both agent harnesses invoke their runner multiple times per `run()` when the
+ * post-run dirty-tree loop kicks in (MAX_COMMIT_RETRIES). each invocation
+ * produces its own AgentUsage; we sum them so downstream callers (usage
+ * summary, WorkflowRun persistence) see the whole session — not just the
+ * final retry's slice.
+ *
+ * returns `undefined` when both sides are empty so callers can short-circuit
+ * without a special case. zero-valued cache / cost fields are dropped to
+ * `undefined` for symmetry with each harness's `buildUsage`.
+ */
+export declare function mergeAgentUsage(a: AgentUsage | undefined, b: AgentUsage | undefined): AgentUsage | undefined;
+/**
+ * unified per-run token table used by every agent harness.
+ *
+ * columns are kept stable across agents and models so downstream log parsers
+ * (scripts/token-usage.ts, cost dashboards) only have to understand one format:
+ *
+ *   Input       non-cached input tokens sent this run
+ *   Cache Read  input tokens served from prompt cache (Anthropic, etc.)
+ *   Cache Write input tokens written to prompt cache this run
+ *   Output      assistant output tokens
+ *   Total       sum of the four columns — the real billable quantity
+ *   Cost ($)    USD cost reported by the provider (only rendered when known)
+ *
+ * models that don't report prompt caching leave Cache Read / Write at 0.
+ * OpenCode emits per-step `part.cost` sourced from models.dev (works across
+ * Anthropic, OpenAI, Google, xAI, DeepSeek, Moonshot, OpenRouter, etc.);
+ * Claude CLI emits `total_cost_usd` on its final `result` event. pass the
+ * accumulated value via `costUsd` to render the Cost column.
+ */
+export declare function logTokenTable(t: {
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    output: number;
+    costUsd?: number | undefined;
+}): void;