@agentex/agent 0.0.24 → 0.0.26

package/src/providers/opencode/parse.ts

@@ -0,0 +1,203 @@
+import type { BaseStreamEventFields, StreamEvent } from "../../types.js";
+
+const PROVIDER_TYPE = "opencode";
+
+function stubBase(event: Record<string, unknown>, sessionId: string | null = null): BaseStreamEventFields {
+  return {
+    timestamp: new Date().toISOString(),
+    providerType: PROVIDER_TYPE,
+    sessionId,
+    messageId: null,
+    eventId: null,
+    turnId: null,
+    parentToolCallId: null,
+    raw: event,
+  };
+}
+
+export interface OpenCodeParsedResult {
+  sessionId: string | null;
+  model: string | null;
+  usage: { inputTokens: number; outputTokens: number; cachedInputTokens: number } | null;
+  costUsd: number | null;
+  summary: string | null;
+  isError: boolean;
+  errorMessage: string | null;
+}
+
+function parseJson(line: string): Record<string, unknown> | null {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+  } catch {
+    // Skip malformed lines
+  }
+  return null;
+}
+
+function asString(value: unknown, fallback: string): string {
+  return typeof value === "string" ? value : fallback;
+}
+
+function asNumber(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function parseObject(value: unknown): Record<string, unknown> {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  return {};
+}
+
+export function parseOpenCodeJsonl(stdout: string): OpenCodeParsedResult {
+  let sessionId: string | null = null;
+  const messages: string[] = [];
+  const errors: string[] = [];
+  const usage = { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0 };
+  let costUsd = 0;
+  let hasUsage = false;
+
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    const event = parseJson(line);
+    if (!event) continue;
+
+    const currentSessionId = asString(event["sessionID"], "").trim();
+    if (currentSessionId) sessionId = currentSessionId;
+
+    const type = asString(event["type"], "");
+
+    if (type === "text") {
+      const part = parseObject(event["part"]);
+      const text = asString(part["text"], "").trim();
+      if (text) messages.push(text);
+      continue;
+    }
+
+    if (type === "step_finish") {
+      const part = parseObject(event["part"]);
+      const tokens = parseObject(part["tokens"]);
+      const cache = parseObject(tokens["cache"]);
+      usage.inputTokens += asNumber(tokens["input"], 0);
+      usage.cachedInputTokens += asNumber(cache["read"], 0);
+      usage.outputTokens += asNumber(tokens["output"], 0) + asNumber(tokens["reasoning"], 0);
+      costUsd += asNumber(part["cost"], 0);
+      hasUsage = true;
+      continue;
+    }
+
+    if (type === "tool_use") {
+      const part = parseObject(event["part"]);
+      const state = parseObject(part["state"]);
+      if (asString(state["status"], "") === "error") {
+        const text = asString(state["error"], "").trim();
+        if (text) errors.push(text);
+      }
+      continue;
+    }
+
+    if (type === "error") {
+      const text = asString(event["message"] as string ?? event["error"] as string, "").trim();
+      if (text) errors.push(text);
+      continue;
+    }
+  }
+
+  return {
+    sessionId,
+    model: null,
+    usage: hasUsage ? usage : null,
+    costUsd: costUsd > 0 ? costUsd : null,
+    summary: messages.join("\n\n").trim() || null,
+    isError: errors.length > 0,
+    errorMessage: errors.length > 0 ? errors.join("\n") : null,
+  };
+}
+
+export function parseOpenCodeStreamLine(line: string): StreamEvent | null {
+  const event = parseJson(line);
+  if (!event) return null;
+
+  const type = asString(event["type"], "");
+  const sessionId = asString(event["sessionID"], "").trim() || null;
+  const base = stubBase(event, sessionId);
+
+  if (type === "text") {
+    const part = parseObject(event["part"]);
+    const text = asString(part["text"], "");
+    if (text) return { type: "assistant", text, ...base };
+  }
+
+  if (type === "tool_use") {
+    const part = parseObject(event["part"]);
+    const name = asString(part["name"], "");
+    const state = parseObject(part["state"]);
+    const status = asString(state["status"], "");
+    if (status === "error" || status === "completed") {
+      return {
+        type: "tool_result",
+        toolCallId: asString(part["id"], "") || asString(part["tool_use_id"], "") || null,
+        toolName: name || null,
+        content: status === "error" ? asString(state["error"], "") : asString(state["result"], ""),
+        isError: status === "error",
+        exitCode: null,
+        ...base,
+      };
+    }
+    return {
+      type: "tool_call",
+      toolCallId: asString(part["id"], "") || asString(part["tool_use_id"], "") || null,
+      name,
+      input: part["input"],
+      ...base,
+    };
+  }
+
+  if (type === "step_finish") {
+    return {
+      type: "result",
+      text: "",
+      costUsd: null,
+      isError: false,
+      stopReason: null,
+      terminalReason: null,
+      numTurns: null,
+      durationMs: null,
+      ...base,
+    };
+  }
+
+  if (type === "error") {
+    return {
+      type: "result",
+      text: asString(event["message"], ""),
+      costUsd: null,
+      isError: true,
+      stopReason: null,
+      terminalReason: null,
+      numTurns: null,
+      durationMs: null,
+      ...base,
+    };
+  }
+
+  // Forward-compat: surface unknown wire events rather than dropping them.
+  return { type: "unknown", subtype: type, ...base };
+}
+
+const OPENCODE_UNKNOWN_SESSION_RE = /unknown\s+session|session\b.*\bnot\s+found|no session/i;
+
+export function isOpenCodeUnknownSessionError(stdout: string, stderr: string): boolean {
+  return OPENCODE_UNKNOWN_SESSION_RE.test(stdout) || OPENCODE_UNKNOWN_SESSION_RE.test(stderr);
+}
+
+const OPENCODE_AUTH_RE = /api[_ ]?key\s+(?:required|missing|not\s+set|invalid)|unauthorized|authentication.*required/i;
+
+export function isOpenCodeAuthRequired(stdout: string, stderr: string): boolean {
+  return OPENCODE_AUTH_RE.test(stdout) || OPENCODE_AUTH_RE.test(stderr);
+}

package/src/providers/pi/codec.ts

@@ -0,0 +1,44 @@
+import type { SessionCodec } from "../../types.js";
+
+function readNonEmptyString(value: unknown): string | null {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+function parseAsObject(raw: unknown): Record<string, unknown> | null {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+  return raw as Record<string, unknown>;
+}
+
+/**
+ * Pi uses file-path-based sessions (e.g. ~/.pi/paperclips/2024-01-01T00-00-00-agentId.jsonl).
+ * The sessionId stored here is the file path to the session file.
+ */
+export const piSessionCodec: SessionCodec = {
+  deserialize(raw: unknown): Record<string, unknown> | null {
+    const obj = parseAsObject(raw);
+    if (!obj) return null;
+    const sessionId = readNonEmptyString(obj["sessionId"]) ?? readNonEmptyString(obj["session_id"]);
+    if (!sessionId) return null;
+    const cwd = readNonEmptyString(obj["cwd"]);
+    return {
+      sessionId,
+      ...(cwd ? { cwd } : {}),
+    };
+  },
+
+  serialize(params: Record<string, unknown> | null): Record<string, unknown> | null {
+    if (!params) return null;
+    const sessionId = readNonEmptyString(params["sessionId"]) ?? readNonEmptyString(params["session_id"]);
+    if (!sessionId) return null;
+    const cwd = readNonEmptyString(params["cwd"]);
+    return {
+      sessionId,
+      ...(cwd ? { cwd } : {}),
+    };
+  },
+
+  getDisplayId(params: Record<string, unknown> | null): string | null {
+    if (!params) return null;
+    return readNonEmptyString(params["sessionId"]) ?? readNonEmptyString(params["session_id"]);
+  },
+};

package/src/providers/pi/execute.ts

@@ -0,0 +1,297 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import type { ExecutionContext, ExecutionResult } from "../../types.js";
+import { findBinary } from "../../utils/binary.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { runChildProcess, deriveErrorCode } from "../../utils/process.js";
+import { injectHomeSkills } from "../../utils/skills.js";
+import { resolveInstructions } from "../../utils/instructions.js";
+import { prepareWorkspace } from "../../utils/workspace.js";
+import type { PreparedWorkspace } from "../../utils/workspace.js";
+import { uuidv7 } from "../../utils/uuid.js";
+import { parsePiJsonl, parsePiStreamLine, isPiUnknownSessionError } from "./parse.js";
+
+const PI_SESSIONS_DIR = path.join(os.homedir(), ".pi", "sessions");
+
+function parseModelProvider(model: string | null): string | null {
+  if (!model) return null;
+  const trimmed = model.trim();
+  if (!trimmed.includes("/")) return null;
+  return trimmed.slice(0, trimmed.indexOf("/")).trim() || null;
+}
+
+function parseModelId(model: string | null): string | null {
+  if (!model) return null;
+  const trimmed = model.trim();
+  if (!trimmed.includes("/")) return trimmed || null;
+  return trimmed.slice(trimmed.indexOf("/") + 1).trim() || null;
+}
+
+function buildSessionPath(runId: string): string {
+  const safeTimestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  return path.join(PI_SESSIONS_DIR, `${safeTimestamp}-${runId}.jsonl`);
+}
+
+export async function executePiProvider(ctx: ExecutionContext): Promise<ExecutionResult> {
+  const runId = ctx.runId ?? uuidv7();
+  let cwd = ctx.cwd ?? process.cwd();
+  const model = ctx.model ?? ctx.config?.model ?? "";
+  const config = ctx.config ?? {};
+  const startedAt = new Date().toISOString();
+
+  // 1. Resolve binary
+  ctx.onLifecycle?.({ phase: "preparing", step: "binary" });
+  let resolvedBinary;
+  try {
+    resolvedBinary = await findBinary("pi", config.command);
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : "Binary not found";
+    ctx.onLifecycle?.({ phase: "error", message: errorMessage });
+    return {
+      runId,
+      exitCode: null,
+      signal: null,
+      status: "failed" as const,
+      startedAt,
+      completedAt: new Date().toISOString(),
+      durationMs: Date.now() - new Date(startedAt).getTime(),
+      errorMessage,
+      errorCode: "binary_not_found",
+      costUsd: null,
+      model: null,
+      summary: null,
+      sessionParams: null,
+      sessionDisplayId: null,
+      clearSession: false,
+      billingType: null,
+    };
+  }
+
+  // 2. Workspace isolation
+  let workspace: PreparedWorkspace | undefined;
+  if (config.workspace) {
+    ctx.onLifecycle?.({ phase: "preparing", step: "workspace" });
+    workspace = await prepareWorkspace(cwd, config.workspace);
+    cwd = workspace.cwd;
+  }
+
+  // 3. Build env
+  const env = buildEnv(ctx.env);
+  ensurePathInEnv(env);
+
+  // 3. Resolve instructions — Pi uses native --append-system-prompt flag,
+  // but we still validate the file exists early so failures are clear.
+  ctx.onLifecycle?.({ phase: "preparing", step: "instructions" });
+  if (config.instructionsFile) await resolveInstructions(config.instructionsFile);
+
+  // 4. Inject skills into ~/.pi/agent/skills/
+  ctx.onLifecycle?.({ phase: "preparing", step: "skills" });
+  let piSkillsDir: string | null = null;
+  if (config.skillDirs && config.skillDirs.length > 0) {
+    try {
+      piSkillsDir = await injectHomeSkills(config.skillDirs, "pi");
+    } catch {
+      // Non-fatal
+    }
+  }
+
+  // 4. Ensure sessions directory exists
+  await fs.mkdir(PI_SESSIONS_DIR, { recursive: true });
+
+  // 5. Determine session resume
+  const sessionParams = ctx.sessionParams ?? null;
+  const existingSessionId = (() => {
+    if (!sessionParams) return null;
+    const id =
+      (sessionParams["sessionId"] as string | undefined) ??
+      (sessionParams["session_id"] as string | undefined);
+    if (!id || typeof id !== "string") return null;
+    const sessionCwd = sessionParams["cwd"] as string | undefined;
+    if (sessionCwd && path.resolve(sessionCwd) !== path.resolve(cwd)) return null;
+    return id;
+  })();
+  const canResume = existingSessionId !== null;
+  const sessionPath = canResume ? existingSessionId! : buildSessionPath(runId);
+
+  // Create session file if new
+  if (!canResume) {
+    try {
+      await fs.writeFile(sessionPath, "", { flag: "wx" });
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "EEXIST") {
+        // Non-fatal, Pi may handle it
+      }
+    }
+  }
+
+  // 6. Parse model into provider/modelId
+  const provider = parseModelProvider(model || null);
+  const modelId = parseModelId(model || null);
+
+  // 7. Build args
+  const buildArgs = (sessionFile: string): string[] => {
+    const args = [...resolvedBinary.prefixArgs, "--mode", "rpc"];
+    if (provider) args.push("--provider", provider);
+    if (modelId) args.push("--model", modelId);
+    if (config.thinking) args.push("--thinking", config.thinking);
+    args.push("--tools", "read,bash,edit,write,grep,find,ls");
+    args.push("--session", sessionFile);
+    if (piSkillsDir) args.push("--skill", piSkillsDir);
+    if (config.instructionsFile) args.push("--append-system-prompt", config.instructionsFile);
+    if (config.extraArgs) args.push(...config.extraArgs);
+    return args;
+  };
+
+  // 8. Build RPC stdin
+  const rpcStdin = JSON.stringify({ type: "prompt", message: ctx.prompt }) + "\n";
+
+  // 9. Run attempt
+  const runAttempt = async (sessionFile: string) => {
+    const args = buildArgs(sessionFile);
+    let stdoutBuffer = "";
+
+    ctx.onLifecycle?.({ phase: "spawning" });
+    const proc = await runChildProcess({
+      runId,
+      command: resolvedBinary.bin,
+      args,
+      cwd,
+      env,
+      stdin: rpcStdin,
+      timeoutSec: config.timeoutSec,
+      graceSec: config.graceSec,
+      onStart: (pid) => {
+        ctx.onLifecycle?.({ phase: "running", pid });
+        ctx.onStart?.(pid);
+      },
+      signal: ctx.signal,
+      onOutput: async (stream, chunk) => {
+        if (stream === "stderr") {
+          if (ctx.onOutput) {
+            try { await ctx.onOutput(stream, chunk); } catch { /* swallow */ }
+          }
+          return;
+        }
+
+        // Buffer stdout by lines for JSONL parsing
+        stdoutBuffer += chunk;
+        const lines = stdoutBuffer.split("\n");
+        stdoutBuffer = lines.pop() || "";
+
+        for (const line of lines) {
+          if (!line) continue;
+          if (ctx.onOutput) {
+            try { await ctx.onOutput(stream, line + "\n"); } catch { /* swallow */ }
+          }
+          if (ctx.onEvent) {
+            const event = parsePiStreamLine(line);
+            if (event) {
+              try { await ctx.onEvent(event); } catch { /* swallow */ }
+            }
+          }
+        }
+      },
+    });
+
+    // Flush remaining buffer
+    if (stdoutBuffer) {
+      if (ctx.onOutput) {
+        try { await ctx.onOutput("stdout", stdoutBuffer); } catch { /* swallow */ }
+      }
+      if (ctx.onEvent) {
+        const event = parsePiStreamLine(stdoutBuffer);
+        if (event) {
+          try { await ctx.onEvent(event); } catch { /* swallow */ }
+        }
+      }
+    }
+
+    return proc;
+  };
+
+  // 10. Initial attempt
+  let proc = await runAttempt(sessionPath);
+  let clearSession = false;
+  let finalSessionPath = sessionPath;
+
+  // 11. Check for unknown session — retry once with new session
+  if (
+    canResume &&
+    !proc.timedOut &&
+    (proc.exitCode ?? 0) !== 0 &&
+    isPiUnknownSessionError(proc.stdout, proc.stderr)
+  ) {
+    finalSessionPath = buildSessionPath(runId + "-retry");
+    try {
+      await fs.writeFile(finalSessionPath, "", { flag: "wx" });
+    } catch {
+      // Non-fatal
+    }
+    proc = await runAttempt(finalSessionPath);
+    clearSession = true;
+  }
+
+  // 12. Parse result
+  const parsed = parsePiJsonl(proc.stdout);
+  const processErrorCode = deriveErrorCode(proc);
+
+  let errorCode = processErrorCode;
+  if (!errorCode && parsed.errorMessage) {
+    errorCode = "execution_error";
+  }
+
+  const errorMessage = (() => {
+    if (proc.timedOut) return `Timed out after ${config.timeoutSec ?? 0}s`;
+    if (parsed.errorMessage) return parsed.errorMessage;
+    if ((proc.exitCode ?? 0) !== 0 && !parsed.summary) {
+      const stderrLine = proc.stderr.split(/\r?\n/).map((l) => l.trim()).find(Boolean);
+      return stderrLine ?? `Pi exited with code ${proc.exitCode ?? -1}`;
+    }
+    return null;
+  })();
+
+  // Always return the current session path so callers can continue.
+  // clearSession tells callers the OLD session was invalid, but we still
+  // provide the NEW session handle from the retry.
+  const resultSessionParams = { sessionId: finalSessionPath, cwd };
+
+  const completedAt = new Date().toISOString();
+  const resolvedModel = model || null;
+  const status = proc.aborted ? "aborted" as const
+    : proc.timedOut ? "timeout" as const
+    : (errorCode || errorMessage) ? "failed" as const
+    : "completed" as const;
+
+  if (status === "completed") {
+    ctx.onLifecycle?.({ phase: "completed" });
+  } else if (status === "aborted") {
+    ctx.onLifecycle?.({ phase: "cancelled" });
+  } else {
+    ctx.onLifecycle?.({ phase: "error", message: errorMessage ?? "Unknown error" });
+  }
+
+  return {
+    runId,
+    exitCode: proc.exitCode,
+    signal: proc.signal ?? null,
+    status,
+    startedAt,
+    completedAt,
+    durationMs: new Date(completedAt).getTime() - new Date(startedAt).getTime(),
+    errorMessage,
+    errorCode,
+    usage: parsed.usage && resolvedModel
+      ? { [resolvedModel]: { inputTokens: parsed.usage.inputTokens, outputTokens: parsed.usage.outputTokens, cachedInputTokens: parsed.usage.cachedInputTokens } }
+      : undefined,
+    costUsd: parsed.usage?.costUsd ?? null,
+    model: resolvedModel,
+    summary: parsed.summary,
+    sessionParams: resultSessionParams,
+    sessionDisplayId: finalSessionPath,
+    clearSession,
+    billingType: "api",
+    raw: null,
+    workspace,
+  };
+}

package/src/providers/pi/index.ts

@@ -0,0 +1,30 @@
+import type { ProviderModule, SessionContext, AgentSession } from "../../types.js";
+import { piSessionCodec } from "./codec.js";
+import { resolveAuthForProvider } from "../../utils/auth.js";
+import { EMULATED_GOAL_CAPABILITY } from "../../goals/index.js";
+
+export const piProvider: ProviderModule = {
+  type: "pi",
+  capabilities: {
+    sessions: true,
+    modelDiscovery: false,
+    quotaProbing: false,
+    mcp: false,
+    skills: true,
+    instructions: true,
+    workspace: true,
+    planMode: false,
+    concurrentSend: false,
+    cancelQueuedMessage: false,
+    stopTask: false,
+    modes: false,
+    goals: EMULATED_GOAL_CAPABILITY,
+  },
+  // One-shot `pi --mode rpc` for execute(); a persistent `pi --mode rpc` process
+  // across turns for createSession(). Both load lazily on first use.
+  execute: async (ctx) => (await import("./execute.js")).executePiProvider(ctx),
+  createSession: async (ctx: SessionContext): Promise<AgentSession> =>
+    (await import("./session.js")).createPiSession(ctx),
+  resolveAuth: (ctx) => resolveAuthForProvider("pi", ctx),
+  sessionCodec: piSessionCodec,
+};