@ai-devkit/agent-manager 0.33.1 → 0.34.0

package/src/capacity/zai.ts

@@ -0,0 +1,237 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type {
+  Availability,
+  CapacityLimitType,
+  CapacityReport,
+  CapacityWindow,
+} from "./types.js";
+
+const ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
+const MISSING_API_KEY_MESSAGE =
+  "z.ai API key not found; set Z_AI_API_KEY or configure Pi provider zai";
+const LIMIT_METADATA = {
+  TOKENS_LIMIT: { id: "tokens", label: "Tokens" },
+  CREDIT_LIMIT: { id: "credit", label: "Credit" },
+  TIME_LIMIT: { id: "time", label: "Time" },
+} as const satisfies Record<CapacityLimitType, { id: string; label: string }>;
+const UNIT_METADATA = new Map<number, { minutes: number; label: string }>([
+  [1, { minutes: 24 * 60, label: "day" }],
+  [3, { minutes: 60, label: "hour" }],
+  [5, { minutes: 1, label: "minute" }],
+  [6, { minutes: 7 * 24 * 60, label: "week" }],
+]);
+type UnknownRecord = Record<string, unknown>;
+
+export type ZaiCredentialOptions = {
+  env?: NodeJS.ProcessEnv;
+  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
+};
+
+export type ZaiProbeOptions = ZaiCredentialOptions & {
+  checkedAt: string;
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+};
+
+function record(value: unknown): UnknownRecord | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as UnknownRecord)
+    : null;
+}
+
+function nonEmptyText(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function optionalNumber(value: unknown, field: string): number | null {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Invalid z.ai quota ${field}`);
+  }
+  return value;
+}
+
+function clampPercent(value: number): number {
+  return Math.max(0, Math.min(100, value));
+}
+
+function integer(value: unknown): number | null {
+  return typeof value === "number" && Number.isInteger(value) ? value : null;
+}
+
+function isCapacityLimitType(value: string): value is CapacityLimitType {
+  return Object.hasOwn(LIMIT_METADATA, value);
+}
+
+function durationMinutes(
+  unit: number,
+  number: number,
+  type: CapacityLimitType,
+): number | null {
+  if (type === "TIME_LIMIT" && unit === 5 && number === 1) return 30 * 24 * 60;
+  const metadata = UNIT_METADATA.get(unit);
+  return metadata === undefined || number <= 0
+    ? null
+    : metadata.minutes * number;
+}
+
+function windowLabel(
+  type: CapacityLimitType,
+  unit: number,
+  number: number,
+): string {
+  if (type === "TIME_LIMIT" && unit === 5 && number === 1)
+    return "MCP · monthly";
+  const kind = LIMIT_METADATA[type].label;
+  const unitLabel = UNIT_METADATA.get(unit)?.label;
+  if (!unitLabel) return kind;
+  return `${kind} · ${number} ${unitLabel}${number === 1 ? "" : "s"}`;
+}
+
+function resetTime(value: unknown): string | null {
+  const milliseconds = optionalNumber(value, "limit nextResetTime");
+  if (milliseconds === null) return null;
+  const date = new Date(milliseconds);
+  if (Number.isNaN(date.getTime()))
+    throw new Error("Invalid z.ai quota limit nextResetTime");
+  return date.toISOString();
+}
+
+function availability(windows: CapacityWindow[]): Availability {
+  if (windows.length === 0) return "unknown";
+  if (
+    windows.some(
+      (window) => window.usedPercent !== null && window.usedPercent < 100,
+    )
+  ) {
+    return "yes";
+  }
+  return "no";
+}
+
+function parseLimit(value: unknown, index: number): CapacityWindow | null {
+  const limit = record(value);
+  if (!limit) throw new Error("Invalid z.ai quota limit entry");
+  const unit = integer(limit.unit);
+  const count = integer(limit.number);
+  if (typeof limit.type !== "string" || unit === null || count === null) {
+    throw new Error("Invalid z.ai quota limit entry");
+  }
+  const serverPercent = optionalNumber(limit.percentage, "limit percentage");
+  if (serverPercent === null)
+    throw new Error("Invalid z.ai quota limit percentage");
+  if (!isCapacityLimitType(limit.type)) return null;
+
+  const total = optionalNumber(limit.usage, "limit usage");
+  const current = optionalNumber(limit.currentValue, "limit currentValue");
+  const remaining = optionalNumber(limit.remaining, "limit remaining");
+  let consumed =
+    total !== null && remaining !== null ? total - remaining : null;
+  if (current !== null) consumed = Math.max(consumed ?? current, current);
+
+  let usedPercent = serverPercent;
+  if (total !== null && total > 0 && consumed !== null) {
+    usedPercent = (consumed / total) * 100;
+  }
+  const metadata = LIMIT_METADATA[limit.type];
+
+  return {
+    id: `zai:${metadata.id}:${index + 1}`,
+    label: windowLabel(limit.type, unit, count),
+    limitType: limit.type,
+    durationMinutes: durationMinutes(unit, count, limit.type),
+    usedPercent: clampPercent(usedPercent),
+    resetsAt: resetTime(limit.nextResetTime),
+    total,
+    current,
+    remaining,
+  };
+}
+
+export async function resolveZaiApiKey(
+  options: ZaiCredentialOptions = {},
+): Promise<string> {
+  const env = options.env ?? process.env;
+  const environmentKey = nonEmptyText(env.Z_AI_API_KEY);
+  if (environmentKey) return environmentKey;
+
+  const authPath = join(env.HOME || homedir(), ".pi", "agent", "auth.json");
+  let parsed: UnknownRecord;
+  try {
+    const contents = await (options.readFile ?? readFile)(authPath, "utf8");
+    const root = record(JSON.parse(contents));
+    if (!root) throw new Error("invalid");
+    parsed = root;
+  } catch (error) {
+    if (record(error)?.code === "ENOENT") {
+      throw new Error(MISSING_API_KEY_MESSAGE);
+    }
+    throw new Error("z.ai Pi auth file is malformed");
+  }
+
+  const credential = record(parsed.zai);
+  if (!credential) {
+    throw new Error(MISSING_API_KEY_MESSAGE);
+  }
+  const key =
+    credential.type === "api_key" ? nonEmptyText(credential.key) : null;
+  if (!key) throw new Error("z.ai Pi auth file has a malformed zai credential");
+  return key;
+}
+
+export function parseZaiQuota(raw: unknown, checkedAt: string): CapacityReport {
+  const root = record(raw);
+  const data = record(root?.data);
+  if (
+    root?.success !== true ||
+    root.code !== 200 ||
+    !data ||
+    !Array.isArray(data.limits)
+  ) {
+    throw new Error("Invalid z.ai quota response");
+  }
+  const windows = data.limits
+    .map(parseLimit)
+    .filter((window): window is CapacityWindow => window !== null);
+  return {
+    harness: "pi",
+    provider: "zai",
+    generatedAt: checkedAt,
+    authenticated: true,
+    available: availability(windows),
+    windows,
+    creditsRemaining: null,
+  };
+}
+
+export async function probeZaiCapacity(
+  options: ZaiProbeOptions,
+): Promise<CapacityReport> {
+  const key = await resolveZaiApiKey(options);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 5000);
+  let response: Response;
+  try {
+    response = await (options.fetch ?? globalThis.fetch)(ZAI_QUOTA_URL, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+      signal: controller.signal,
+    });
+  } catch {
+    throw new Error("z.ai quota request failed");
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.status !== 200) {
+    throw new Error(`z.ai quota request failed: HTTP ${response.status}`);
+  }
+  let raw: unknown;
+  try {
+    raw = await response.json();
+  } catch {
+    throw new Error("z.ai quota response is not valid JSON");
+  }
+  return parseZaiQuota(raw, options.checkedAt);
+}

package/src/index.ts

@@ -1,6 +1,11 @@
 export { AgentManager, AgentNotRunningError } from "./AgentManager.js";
-export { getCodexCapacityReport } from "./capacity/index.js";
-export type { CapacityProbeOptions, CapacityReport, CapacityWindow } from "./capacity/index.js";
+export { getCodexCapacityReport, getZaiCapacityReport } from "./capacity/index.js";
+export type {
+  CapacityProbeOptions,
+  CapacityReport,
+  CapacityWindow,
+  ZaiCapacityOptions,
+} from "./capacity/index.js";
 export {
   getAgentReadinessReport,
   getAgentReadinessReports,
@@ -25,7 +30,7 @@ export { CodexAdapter } from "./providers/codex/CodexAdapter.js";
 export { CopilotAdapter } from "./providers/copilot/CopilotAdapter.js";
 export { GeminiCliAdapter } from "./providers/gemini/GeminiCliAdapter.js";
 export { GrokCliAdapter } from "./adapters/GrokCliAdapter.js";
-export { OpenCodeAdapter } from "./adapters/OpenCodeAdapter.js";
+export { OpenCodeAdapter } from "./providers/opencode/OpenCodeAdapter.js";
 export { PiAdapter } from "./providers/pi/PiAdapter.js";
 export { AgentStatus } from "./adapters/AgentAdapter.js";
 export type {

package/src/providers/opencode/OpenCodeAdapter.ts

@@ -0,0 +1,112 @@
+/**
+ * OpenCode Adapter
+ *
+ * Detects running OpenCode agents by:
+ * 1. Filtering OpenCode processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
+ * 3. Querying OpenCode's SQLite DB (~/.local/share/opencode/opencode.db) to
+ *    find the session matching each process's CWD and read status from message.time.completed
+ *
+ * sessionFilePath encodes "<dbPath>::<sessionId>" so getConversation() can open the right
+ * DB row without extending the AgentAdapter interface.
+ */
+
+import type {
+  AgentAdapter,
+  AgentInfo,
+  ProcessInfo,
+  ConversationMessage,
+  SessionSummary,
+  ListSessionsOptions,
+  AgentDetectionContext,
+} from "../../adapters/AgentAdapter.js";
+import {
+  captureProcessSnapshot,
+  executableBasename,
+  filterByProcessNames,
+} from "../../utils/process.js";
+import { OpenCodeAgentMapper } from "./OpenCodeAgentMapper.js";
+import { OpenCodeSessionLocator } from "./OpenCodeSessionLocator.js";
+import { OpenCodeSessionParser } from "./OpenCodeSessionParser.js";
+
+const SESSION_REF_SEP = "::";
+
+function decodeSessionRef(ref: string): { sessionId: string } | null {
+  const idx = ref.lastIndexOf(SESSION_REF_SEP);
+  if (idx === -1) return null;
+  return { sessionId: ref.slice(idx + SESSION_REF_SEP.length) };
+}
+
+export class OpenCodeAdapter implements AgentAdapter {
+  readonly type = "opencode" as const;
+  readonly processNames = ["opencode"] as const;
+
+  private readonly parser: OpenCodeSessionParser;
+  private readonly locator: OpenCodeSessionLocator;
+  private readonly mapper: OpenCodeAgentMapper;
+  private readonly cleanup = (): void => this.close();
+
+  constructor(dbPath?: string) {
+    this.parser = new OpenCodeSessionParser();
+    this.locator = new OpenCodeSessionLocator(dbPath, this.parser);
+    this.mapper = new OpenCodeAgentMapper(this.locator.dbFilePath);
+    process.once("exit", this.cleanup);
+    process.once("SIGINT", this.cleanup);
+    process.once("SIGTERM", this.cleanup);
+  }
+
+  close(): void {
+    process.off("exit", this.cleanup);
+    process.off("SIGINT", this.cleanup);
+    process.off("SIGTERM", this.cleanup);
+    this.locator.close();
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    const base = executableBasename(processInfo.command);
+    return base === "opencode" || base === "opencode.exe";
+  }
+
+  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));
+    const relevant = filterByProcessNames(snapshot, this.processNames);
+    const processes = relevant.filter((process) => this.canHandle(process));
+    if (processes.length === 0) return [];
+
+    const db = this.locator.openDb();
+    if (!db) return processes.map((process) => this.mapper.mapProcessOnlyAgent(process));
+
+    const agents: AgentInfo[] = [];
+    for (const proc of processes) {
+      if (!proc.cwd) {
+        agents.push(this.mapper.mapProcessOnlyAgent(proc));
+        continue;
+      }
+
+      const session = this.locator.findSessionForDirectory(db, proc.cwd);
+      if (!session) {
+        agents.push(this.mapper.mapProcessOnlyAgent(proc));
+        continue;
+      }
+
+      const stats = this.parser.getSessionStats(db, session.sessionId);
+      agents.push(this.mapper.mapSessionToAgent(session, stats, proc));
+    }
+
+    return agents;
+  }
+
+  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+    const ref = decodeSessionRef(sessionFilePath);
+    if (!ref) return [];
+
+    const db = this.locator.openDb();
+    if (!db) return [];
+
+    return this.parser.getConversation(db, ref.sessionId, options);
+  }
+
+  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+    return this.locator.listSessions(opts);
+  }
+}

package/src/providers/opencode/OpenCodeAgentMapper.ts

@@ -0,0 +1,61 @@
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+import type { OpenCodeSession } from "./OpenCodeSessionLocator.js";
+import type { OpenCodeSessionStats } from "./OpenCodeSessionParser.js";
+
+const SESSION_REF_SEP = "::";
+const IDLE_THRESHOLD_MINUTES = 5;
+
+function encodeSessionRef(dbPath: string, sessionId: string): string {
+  return `${dbPath}${SESSION_REF_SEP}${sessionId}`;
+}
+
+export class OpenCodeAgentMapper {
+  constructor(private readonly dbPath: string) {}
+
+  mapSessionToAgent(
+    session: OpenCodeSession,
+    stats: OpenCodeSessionStats,
+    proc: ProcessInfo,
+  ): AgentInfo {
+    const lastActive =
+      stats.lastTimeUpdated > 0 ? new Date(stats.lastTimeUpdated) : new Date(session.timeCreated);
+
+    return {
+      name: generateAgentName(session.directory || proc.cwd || "", proc.pid),
+      type: "opencode",
+      status: this.determineStatus(stats, lastActive),
+      summary: stats.summary || "OpenCode session active",
+      pid: proc.pid,
+      projectPath: session.directory || proc.cwd || "",
+      sessionId: session.sessionId,
+      lastActive,
+      sessionFilePath: encodeSessionRef(this.dbPath, session.sessionId),
+    };
+  }
+
+  mapProcessOnlyAgent(proc: ProcessInfo): AgentInfo {
+    return {
+      name: generateAgentName(proc.cwd || "", proc.pid),
+      type: "opencode",
+      status: AgentStatus.RUNNING,
+      summary: "OpenCode process running",
+      pid: proc.pid,
+      projectPath: proc.cwd || "",
+      sessionId: `pid-${proc.pid}`,
+      lastActive: new Date(),
+    };
+  }
+
+  private determineStatus(stats: OpenCodeSessionStats, lastActive: Date): AgentStatus {
+    const ageMin = (Date.now() - lastActive.getTime()) / 60000;
+    if (ageMin > IDLE_THRESHOLD_MINUTES) return AgentStatus.IDLE;
+
+    if (stats.lastRole === "assistant" && !stats.lastAssistantCompleted) {
+      return AgentStatus.RUNNING;
+    }
+    if (stats.lastRole === "assistant") return AgentStatus.WAITING;
+    return AgentStatus.RUNNING;
+  }
+}

package/src/providers/opencode/OpenCodeSessionLocator.ts

@@ -0,0 +1,123 @@
+import * as fs from "fs";
+import * as path from "path";
+import Database from "better-sqlite3";
+import type { ListSessionsOptions, SessionSummary } from "../../adapters/AgentAdapter.js";
+import { OpenCodeSessionParser } from "./OpenCodeSessionParser.js";
+
+const SESSION_REF_SEP = "::";
+
+function encodeOpenCodeSessionRef(dbPath: string, sessionId: string): string {
+  return `${dbPath}${SESSION_REF_SEP}${sessionId}`;
+}
+
+export interface OpenCodeSession {
+  sessionId: string;
+  directory: string;
+  timeCreated: number;
+}
+
+export class OpenCodeSessionLocator {
+  private readonly dbPath: string;
+  private db: Database.Database | null = null;
+
+  constructor(
+    dbPath = OpenCodeSessionLocator.resolveDbPath(),
+    private readonly parser: OpenCodeSessionParser = new OpenCodeSessionParser(),
+  ) {
+    this.dbPath = dbPath;
+  }
+
+  static resolveDbPath(): string {
+    const xdg = process.env.XDG_DATA_HOME;
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    const base = xdg || path.join(home, ".local", "share");
+    return path.join(base, "opencode", "opencode.db");
+  }
+
+  openDb(): Database.Database | null {
+    if (this.db) return this.db;
+    if (!fs.existsSync(this.dbPath)) return null;
+
+    try {
+      this.db = new Database(this.dbPath, { readonly: true });
+      return this.db;
+    } catch {
+      return null;
+    }
+  }
+
+  close(): void {
+    if (this.db) {
+      try {
+        this.db.close();
+      } catch {
+        /* ignore */
+      }
+      this.db = null;
+    }
+  }
+
+  findSessionForDirectory(db: Database.Database, directory: string): OpenCodeSession | null {
+    try {
+      const row = db
+        .prepare<[string], { id: string; directory: string; time_created: number }>(`
+                SELECT id, directory, time_created
+                FROM session
+                WHERE directory = ?
+                ORDER BY time_created DESC
+                LIMIT 1
+            `)
+        .get(directory);
+
+      if (!row) return null;
+      return { sessionId: row.id, directory: row.directory, timeCreated: row.time_created };
+    } catch {
+      return null;
+    }
+  }
+
+  listSessions(opts?: ListSessionsOptions): SessionSummary[] {
+    const db = this.openDb();
+    if (!db) return [];
+
+    try {
+      const rows = db
+        .prepare<[], { id: string; directory: string; timeCreated: number }>(`
+                SELECT id, directory, time_created AS timeCreated
+                FROM session
+                ORDER BY time_created DESC
+            `)
+        .all();
+
+      const summaries: SessionSummary[] = [];
+
+      for (const row of rows) {
+        if (opts?.cwd !== undefined && row.directory !== opts.cwd) continue;
+
+        const stats = this.parser.getSessionStats(db, row.id);
+        const lastActive =
+          stats.lastTimeUpdated > 0 ? new Date(stats.lastTimeUpdated) : new Date(row.timeCreated);
+        const startedAt = new Date(row.timeCreated);
+
+        summaries.push({
+          type: "opencode",
+          sessionId: row.id,
+          cwd: row.directory,
+          firstUserMessage: stats.summary,
+          lastActive,
+          startedAt,
+          sessionFilePath: encodeOpenCodeSessionRef(this.dbPath, row.id),
+        });
+      }
+
+      return summaries;
+    } catch {
+      this.close();
+      return [];
+    }
+  }
+
+  get dbFilePath(): string {
+    return this.dbPath;
+  }
+}

package/src/providers/opencode/OpenCodeSessionParser.ts

@@ -0,0 +1,145 @@
+import type { ConversationMessage } from "../../adapters/AgentAdapter.js";
+import type Database from "better-sqlite3";
+
+export interface OpenCodeSessionStats {
+  lastRole: string | null;
+  lastTimeUpdated: number;
+  /** OpenCode writes `time.completed` on the assistant message only when the turn finishes. */
+  lastAssistantCompleted: boolean;
+  lastAssistantErrored: boolean;
+  summary: string;
+}
+
+interface OpenCodePartData {
+  type?: string;
+  text?: string;
+  reasoning?: string;
+  tool?: string;
+}
+
+const EMPTY_STATS: OpenCodeSessionStats = {
+  lastRole: null,
+  lastTimeUpdated: 0,
+  lastAssistantCompleted: false,
+  lastAssistantErrored: false,
+  summary: "",
+};
+
+export class OpenCodeSessionParser {
+  getConversation(
+    db: Database.Database,
+    sessionId: string,
+    options?: { verbose?: boolean },
+  ): ConversationMessage[] {
+    const verbose = options?.verbose ?? false;
+
+    try {
+      const rows = db
+        .prepare<[string], { role: string; partData: string; timeCreated: number }>(`
+                SELECT json_extract(m.data, '$.role') AS role,
+                       p.data AS partData,
+                       p.time_created AS timeCreated
+                FROM part p
+                JOIN message m ON p.message_id = m.id
+                WHERE p.session_id = ?
+                ORDER BY p.time_created ASC
+            `)
+        .all(sessionId);
+
+      const messages: ConversationMessage[] = [];
+
+      for (const row of rows) {
+        const partData = this.parsePartData(row.partData);
+        if (!partData) continue;
+
+        const role = row.role === "user" ? "user" : "assistant";
+
+        if (partData.type === "text" && partData.text) {
+          messages.push({ role, content: partData.text });
+        } else if (partData.type === "reasoning" && verbose) {
+          const text = partData.reasoning || partData.text || "";
+          if (text) messages.push({ role: "assistant", content: `[thinking] ${text}` });
+        } else if (partData.type === "tool" && verbose) {
+          const toolName = partData.tool || "tool";
+          messages.push({ role: "assistant", content: `[tool: ${toolName}]` });
+        }
+      }
+
+      return messages;
+    } catch {
+      return [];
+    }
+  }
+
+  getSessionStats(db: Database.Database, sessionId: string): OpenCodeSessionStats {
+    try {
+      // Order by time_created — time_updated can lag when OpenCode appends
+      // metadata (e.g. summary diffs) to user messages after a turn finishes.
+      const last = db
+        .prepare<[string], { role: string; timeUpdated: number }>(`
+                SELECT json_extract(data, '$.role') AS role,
+                       time_updated AS timeUpdated
+                FROM message
+                WHERE session_id = ?
+                ORDER BY time_created DESC
+                LIMIT 1
+            `)
+        .get(sessionId);
+
+      const heartbeat = db
+        .prepare<[string], { maxUpdated: number }>(`
+                SELECT MAX(time_updated) AS maxUpdated FROM message WHERE session_id = ?
+            `)
+        .get(sessionId);
+
+      const lastAssistant = db
+        .prepare<
+          [string],
+          {
+            completed: number | null;
+            errored: number | null;
+          }
+        >(`
+                SELECT json_extract(data, '$.time.completed') AS completed,
+                       json_extract(data, '$.time.error') AS errored
+                FROM message
+                WHERE session_id = ? AND json_extract(data, '$.role') = 'assistant'
+                ORDER BY time_created DESC
+                LIMIT 1
+            `)
+        .get(sessionId);
+
+      const first = db
+        .prepare<[string], { text: string }>(`
+                SELECT json_extract(p.data, '$.text') AS text
+                FROM part p
+                JOIN message m ON p.message_id = m.id
+                WHERE p.session_id = ?
+                  AND json_extract(m.data, '$.role') = 'user'
+                  AND json_extract(p.data, '$.type') = 'text'
+                  AND json_extract(p.data, '$.text') IS NOT NULL
+                ORDER BY p.time_created ASC
+                LIMIT 1
+            `)
+        .get(sessionId);
+
+      return {
+        lastRole: last?.role ?? null,
+        lastTimeUpdated: heartbeat?.maxUpdated ?? last?.timeUpdated ?? 0,
+        lastAssistantCompleted: lastAssistant?.completed != null,
+        lastAssistantErrored: lastAssistant?.errored != null,
+        summary: first?.text?.trim() ?? "",
+      };
+    } catch {
+      return EMPTY_STATS;
+    }
+  }
+
+  private parsePartData(partData: string): OpenCodePartData | null {
+    try {
+      return JSON.parse(partData) as OpenCodePartData;
+    } catch {
+      return null;
+    }
+  }
+}