ocpipe 0.6.8 → 0.6.10

package/README.md

@@ -1,5 +1,5 @@
 <p align="center"><strong>ocpipe</strong></p>
-<p align="center">Build LLM pipelines with <a href="https://github.com/sst/opencode">OpenCode</a>, <a href="https://github.com/anthropics/claude-code">Claude Code</a>, and <a href="https://zod.dev">Zod</a>.</p>
+<p align="center">Build LLM pipelines with <a href="https://github.com/sst/opencode">OpenCode</a>, <a href="https://github.com/anthropics/claude-code">Claude Code</a>, Oh My Pi, Pi, and <a href="https://zod.dev">Zod</a>.</p>
 <p align="center">Inspired by <a href="https://github.com/stanfordnlp/dspy">DSPy</a>.</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/ocpipe"><img alt="npm" src="https://img.shields.io/npm/v/ocpipe?style=flat-square" /></a>
@@ -11,7 +11,7 @@
 - **Type-safe** Define inputs and outputs with Zod schemas
 - **Modular** Compose modules into complex pipelines
 - **Checkpoints** Resume from any step
-- **Multi-backend** Choose between OpenCode (75+ providers) or Claude Code SDK
+- **Multi-backend** Choose between OpenCode (75+ providers), Claude Code SDK, Codex SDK, Oh My Pi, or Pi
 - **Auto-correction** Fixes schema mismatches automatically
 
 ### Quick Start
@@ -49,7 +49,7 @@ type GreetOut = InferOutputs<typeof Greet> // { greeting: string }
 
 ### Backends
 
-ocpipe supports three backends for running LLM agents:
+ocpipe supports five backends for running LLM agents:
 
 **OpenCode** (default) - Requires `opencode` CLI in your PATH. Supports 75+ providers.
 
@@ -83,6 +83,20 @@ defaultModel: { backend: 'codex', modelID: 'gpt-5.4' },
 codex: { sandbox: 'read-only', reasoningEffort: 'high' },
 ```
 
+**Oh My Pi** - Uses the `omp` CLI in headless JSON print mode.
+
+```typescript
+defaultModel: { backend: 'omp', modelID: 'gpt-5.5' },
+omp: { command: 'omp', approvalMode: 'yolo', thinking: 'high' },
+```
+
+**Pi** - Uses the `pi` coding-agent CLI JSONL RPC mode.
+
+```typescript
+defaultModel: { backend: 'pi', modelID: 'gemma' },
+pi: { command: 'pi' },
+```
+
 ### Requirements
 
 **For OpenCode backend:** Currently requires [this OpenCode fork](https://github.com/paralin/opencode). Once the following PRs are merged, the official release will work:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocpipe",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "description": "SDK for LLM pipelines with OpenCode, Codex, and Zod",
   "type": "module",
   "main": "src/index.ts",
@@ -31,8 +31,8 @@
   },
   "peerDependencies": {
     "zod": "4.4.3",
-    "@anthropic-ai/claude-agent-sdk": "0.2.126",
-    "@openai/codex-sdk": "0.130.0"
+    "@anthropic-ai/claude-agent-sdk": "0.3.185",
+    "@openai/codex-sdk": "0.141.0"
   },
   "peerDependenciesMeta": {
     "@anthropic-ai/claude-agent-sdk": {
@@ -43,18 +43,18 @@
     }
   },
   "devDependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.132",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.197",
     "@eslint/js": "^10.0.1",
-    "@openai/codex-sdk": "0.130.0",
-    "@typescript/native-preview": "^7.0.0-dev.20260506.1",
-    "bun-types": "^1.3.13",
-    "eslint": "^10.3.0",
-    "globals": "^17.6.0",
+    "@openai/codex-sdk": "0.142.5",
+    "@typescript/native-preview": "^7.0.0-dev.20260630.1",
+    "bun-types": "^1.3.14",
+    "eslint": "^10.6.0",
+    "globals": "^17.7.0",
     "jiti": "^2.7.0",
-    "prettier": "^3.8.3",
+    "prettier": "^3.9.4",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.2",
-    "vitest": "^4.1.5"
+    "typescript-eslint": "^8.62.1",
+    "vitest": "^4.1.9"
   },
   "scripts": {
     "lint": "eslint .",

package/src/agent.ts

@@ -1,7 +1,7 @@
 /**
  * ocpipe agent integration.
  *
- * Dispatches to OpenCode CLI, Claude Code SDK, or Codex SDK based on backend
+ * Dispatches to OpenCode CLI, Claude Code SDK, Codex SDK, or Pi based on backend
  * configuration.
  */
 
@@ -9,6 +9,8 @@ import { spawn } from 'child_process'
 import { mkdir, writeFile, unlink } from 'fs/promises'
 import { join } from 'path'
 import { PROJECT_ROOT, TMP_DIR } from './paths.js'
+import { runOmpAgent } from './omp.js'
+import { runPiAgent } from './pi.js'
 import type { RunAgentOptions, RunAgentResult } from './types.js'
 
 /** Get command and args to invoke opencode from PATH */
@@ -23,16 +25,25 @@ export async function runAgent(
   const backend = options.model.backend ?? 'opencode'
 
   if (backend === 'claude-code') {
-    // Dynamic import to avoid requiring @anthropic-ai/claude-agent-sdk when using opencode
+    // Dynamic import is required: @anthropic-ai/claude-agent-sdk is an optional peer absent for other backends.
     const { runClaudeCodeAgent } = await import('./claude-code.js')
     return runClaudeCodeAgent(options)
   }
 
   if (backend === 'codex') {
+    // Dynamic import is required: @openai/codex-sdk is an optional peer absent for other backends.
     const { runCodexAgent } = await import('./codex.js')
     return runCodexAgent(options)
   }
 
+  if (backend === 'pi') {
+    return runPiAgent(options)
+  }
+
+  if (backend === 'omp') {
+    return runOmpAgent(options)
+  }
+
   return runOpencodeAgent(options)
 }
 

package/src/index.ts

@@ -92,6 +92,8 @@ export type {
   BackendType,
   PermissionMode,
   ClaudeCodeOptions,
+  PiOptions,
+  OmpOptions,
   CodexApprovalPolicy,
   CodexConfigValue,
   CodexOptions,

package/src/omp.ts

@@ -0,0 +1,313 @@
+/**
+ * ocpipe Oh My Pi integration.
+ *
+ * Runs Oh My Pi through its headless JSON print mode.
+ */
+
+import { spawn, type ChildProcess } from 'child_process'
+import { isAbsolute, join } from 'path'
+import { PROJECT_ROOT } from './paths.js'
+import type { OmpOptions, RunAgentOptions, RunAgentResult } from './types.js'
+
+interface OmpProcessRequest {
+  command: string
+  args: string[]
+  cwd: string
+  env: NodeJS.ProcessEnv
+  signal?: AbortSignal
+}
+
+interface OmpProcessResult {
+  stdout: string
+  stderr: string
+  exitCode: number | null
+  signal: NodeJS.Signals | null
+}
+
+export interface OmpProcess {
+  run(req: OmpProcessRequest): Promise<OmpProcessResult>
+}
+
+interface OmpRunSummary {
+  sawJsonEvent: boolean
+  sessionId: string
+  finalMessage: string
+}
+
+const defaultOmpCommand = 'omp'
+const defaultOmpThinking = 'high'
+const defaultOmpApprovalMode = 'yolo'
+
+/** runOmpAgent executes an Oh My Pi coding-agent turn. */
+export async function runOmpAgent(
+  options: RunAgentOptions,
+  processRunner: OmpProcess = commandOmpProcess,
+): Promise<RunAgentResult> {
+  const {
+    prompt,
+    model,
+    sessionId,
+    timeoutSec = 3600,
+    workdir,
+    omp,
+    signal,
+  } = options
+
+  if (signal?.aborted) {
+    throw new Error('Request aborted')
+  }
+
+  const cwd = workdir ?? PROJECT_ROOT
+  const sessionInfo = sessionId ? `[session:${sessionId}]` : '[new session]'
+  const promptPreview = prompt.slice(0, 50).replace(/\n/g, ' ')
+  console.error(
+    `\n>>> OMP [${model.modelID}] ${sessionInfo}: ${promptPreview}...`,
+  )
+
+  const abort = new AbortController()
+  const abortHandler = () => abort.abort()
+  signal?.addEventListener('abort', abortHandler, { once: true })
+  let timedOut = false
+  const timeout =
+    timeoutSec > 0 ?
+      setTimeout(() => {
+        timedOut = true
+        abort.abort()
+      }, timeoutSec * 1000)
+    : null
+
+  try {
+    const result = await processRunner.run({
+      command: omp?.command ?? defaultOmpCommand,
+      args: buildOmpArgs(model.modelID, cwd, sessionId, prompt, omp),
+      cwd: omp?.processCwd ?? cwd,
+      env: buildOmpEnv(omp),
+      signal: abort.signal,
+    })
+    const summary = parseOmpOutput(result.stdout)
+    const detail =
+      result.signal ? `signal ${result.signal}` : `status ${result.exitCode}`
+    if (result.exitCode !== 0 || result.signal) {
+      const message = firstNonEmpty(
+        summary.finalMessage,
+        result.stderr.trim(),
+        result.stdout.trim(),
+        detail,
+      )
+      throw new Error(`OMP exited with ${detail}: ${message}`)
+    }
+
+    const response = firstNonEmpty(
+      summary.finalMessage,
+      summary.sawJsonEvent ? '' : result.stdout.trim(),
+    )
+    if (!response) {
+      throw new Error('OMP returned an empty final message')
+    }
+
+    const nextSessionId = firstNonEmpty(summary.sessionId, sessionId ?? '')
+    console.error(
+      `<<< OMP done (${response.length} chars)${nextSessionId ? ` [session:${nextSessionId}]` : ''}`,
+    )
+    return {
+      text: response,
+      sessionId: nextSessionId,
+    }
+  } catch (err) {
+    if (timedOut) {
+      throw new Error(`Timeout after ${timeoutSec}s`, { cause: err })
+    }
+    if (signal?.aborted) {
+      throw new Error('Request aborted', { cause: err })
+    }
+    throw err
+  } finally {
+    if (timeout) clearTimeout(timeout)
+    signal?.removeEventListener('abort', abortHandler)
+  }
+}
+
+function buildOmpArgs(
+  modelID: string,
+  cwd: string,
+  sessionId: string | undefined,
+  prompt: string,
+  omp: OmpOptions | undefined,
+): string[] {
+  const args = ['--print', '--mode', 'json', '--cwd', cwd]
+  if (modelID) {
+    args.push('--model', modelID)
+  }
+  if (hasOwn(omp, 'codexHome')) {
+    args.push('--codex-home', omp?.codexHome ?? '')
+  }
+  if (sessionId) {
+    args.push('--resume', sessionId)
+  }
+  if (omp?.goalMode || firstNonEmpty(omp?.goalObjective ?? '')) {
+    const objective = firstNonEmpty(omp?.goalObjective ?? '', prompt)
+    if (objective) {
+      args.push('--goal', objective)
+    }
+  }
+  if (
+    typeof omp?.contextStopPercent === 'number' &&
+    omp.contextStopPercent > 0
+  ) {
+    args.push('--context-stop-percent', String(omp.contextStopPercent))
+  }
+  if (typeof omp?.contextStopTokens === 'number' && omp.contextStopTokens > 0) {
+    args.push('--context-stop-tokens', String(omp.contextStopTokens))
+  }
+  if (omp?.scratchHandoffFile) {
+    args.push(
+      '--scratch-handoff-file',
+      resolveOmpPath(cwd, omp.scratchHandoffFile),
+    )
+  }
+  if (omp?.autoApprove ?? true) {
+    args.push('--auto-approve')
+  }
+  const approvalMode = omp?.approvalMode ?? defaultOmpApprovalMode
+  if (approvalMode) {
+    args.push('--approval-mode', approvalMode)
+  }
+  const thinking = omp?.thinking ?? defaultOmpThinking
+  if (thinking) {
+    args.push('--thinking', thinking)
+  }
+  args.push(...(omp?.extraArgs ?? []))
+  if (prompt) {
+    args.push('--', prompt)
+  }
+  return args
+}
+
+function buildOmpEnv(omp: OmpOptions | undefined): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = { ...process.env, ...omp?.env }
+  if (hasOwn(omp, 'codexHome')) {
+    delete env.CODEX_HOME
+  }
+  if (omp?.home) {
+    env.OMP_HOME = omp.home
+  }
+  return env
+}
+
+function resolveOmpPath(cwd: string, path: string): string {
+  return isAbsolute(path) ? path : join(cwd, path)
+}
+
+function parseOmpOutput(stdout: string): OmpRunSummary {
+  const summary: OmpRunSummary = {
+    sawJsonEvent: false,
+    sessionId: '',
+    finalMessage: '',
+  }
+  for (const rawLine of stdout.split('\n')) {
+    const line = rawLine.trim()
+    if (!line) continue
+    let event: unknown
+    try {
+      event = JSON.parse(line)
+    } catch {
+      continue
+    }
+    if (!isRecord(event)) continue
+    summary.sawJsonEvent = true
+    const type = ompString(event.type)
+    if (type === 'session') {
+      summary.sessionId = firstNonEmpty(
+        ompString(event.id),
+        ompString(event.sessionId),
+        ompString(event.session_id),
+        summary.sessionId,
+      )
+      continue
+    }
+    if (type === 'message_end') {
+      const text = ompAssistantText(event.message)
+      if (text) {
+        summary.finalMessage = text
+      }
+    }
+  }
+  if (!summary.sawJsonEvent) {
+    summary.finalMessage = stdout.trim()
+  }
+  return summary
+}
+
+function ompAssistantText(raw: unknown): string {
+  if (!isRecord(raw) || ompString(raw.role) !== 'assistant') return ''
+  if (Array.isArray(raw.content)) {
+    const parts: string[] = []
+    for (const rawPart of raw.content) {
+      if (!isRecord(rawPart) || ompString(rawPart.type) !== 'text') continue
+      const text = ompString(rawPart.text).trim()
+      if (text) parts.push(text)
+    }
+    return parts.join('\n\n')
+  }
+  return ompString(raw.content).trim()
+}
+
+const commandOmpProcess: OmpProcess = {
+  run(req) {
+    const { promise, resolve, reject } =
+      Promise.withResolvers<OmpProcessResult>()
+    let child: ChildProcess
+    try {
+      child = spawn(req.command, req.args, {
+        cwd: req.cwd,
+        env: req.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+    } catch (err) {
+      reject(err)
+      return promise
+    }
+
+    const stdoutChunks: Buffer[] = []
+    const stderrChunks: Buffer[] = []
+    const abortHandler = () => child.kill()
+    req.signal?.addEventListener('abort', abortHandler, { once: true })
+
+    child.stdout?.on('data', (chunk: Buffer) => stdoutChunks.push(chunk))
+    child.stderr?.on('data', (chunk: Buffer) => stderrChunks.push(chunk))
+    child.on('error', reject)
+    child.on('close', (exitCode, signal) => {
+      req.signal?.removeEventListener('abort', abortHandler)
+      resolve({
+        stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+        stderr: Buffer.concat(stderrChunks).toString('utf8'),
+        exitCode,
+        signal,
+      })
+    })
+    return promise
+  },
+}
+
+function hasOwn<T extends object, K extends PropertyKey>(
+  value: T | undefined,
+  key: K,
+): value is T & Record<K, unknown> {
+  return !!value && Object.prototype.hasOwnProperty.call(value, key)
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function ompString(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function firstNonEmpty(...values: string[]): string {
+  for (const value of values) {
+    const trimmed = value.trim()
+    if (trimmed) return trimmed
+  }
+  return ''
+}

package/src/pi.ts

@@ -0,0 +1,383 @@
+/**
+ * ocpipe Pi coding-agent integration.
+ *
+ * Runs Pi through its JSONL RPC mode.
+ */
+
+import { spawn, type ChildProcess } from 'child_process'
+import { createInterface } from 'readline'
+import { join } from 'path'
+import { homedir } from 'os'
+import { PROJECT_ROOT } from './paths.js'
+import type { PiOptions, RunAgentOptions, RunAgentResult } from './types.js'
+
+interface PiProcessRequest {
+  command: string
+  args: string[]
+  cwd: string
+  env: NodeJS.ProcessEnv
+}
+
+export interface PiConnection {
+  send(line: string): void
+  recv(signal?: AbortSignal): Promise<string>
+  close(): void
+}
+
+export interface PiProcess {
+  start(req: PiProcessRequest): PiConnection
+}
+
+interface PiRPCState {
+  sessionID: string
+  modelSummary: string
+}
+
+const defaultPiCommand = 'pi'
+
+/** runPiAgent executes a Pi coding-agent turn over JSONL RPC. */
+export async function runPiAgent(
+  options: RunAgentOptions,
+  processRunner: PiProcess = commandPiProcess,
+): Promise<RunAgentResult> {
+  const {
+    prompt,
+    model,
+    sessionId,
+    timeoutSec = 3600,
+    workdir,
+    pi,
+    signal,
+  } = options
+
+  if (signal?.aborted) {
+    throw new Error('Request aborted')
+  }
+
+  const cwd = workdir ?? PROJECT_ROOT
+  const sessionInfo = sessionId ? `[session:${sessionId}]` : '[new session]'
+  const promptPreview = prompt.slice(0, 50).replace(/\n/g, ' ')
+  console.error(
+    `\n>>> Pi [${model.modelID}] ${sessionInfo}: ${promptPreview}...`,
+  )
+
+  const abort = new AbortController()
+  const abortHandler = () => abort.abort()
+  signal?.addEventListener('abort', abortHandler, { once: true })
+  let timedOut = false
+  const timeout =
+    timeoutSec > 0 ?
+      setTimeout(() => {
+        timedOut = true
+        abort.abort()
+      }, timeoutSec * 1000)
+    : null
+
+  const conn = processRunner.start({
+    command: pi?.command ?? defaultPiCommand,
+    args: buildPiArgs(model.modelID, sessionId, pi),
+    cwd,
+    env: buildPiEnv(pi),
+  })
+  const client = new PiRPCClient(conn)
+
+  try {
+    const initial = await client.getState(abort.signal)
+    await client.prompt(prompt, abort.signal)
+    await client.waitAgentEnd(abort.signal)
+    const response = await client.getLastAssistantText(abort.signal)
+    const final = await client.getState(abort.signal)
+    const nextSessionId = firstNonEmpty(
+      final.sessionID,
+      initial.sessionID,
+      sessionId ?? '',
+    )
+    if (!nextSessionId) {
+      throw new Error('Pi RPC did not emit a provider session ID')
+    }
+    if (!response) {
+      throw new Error('Pi RPC returned an empty final message')
+    }
+    const modelSummary =
+      final.modelSummary ? ` model=${final.modelSummary}` : ''
+    console.error(
+      `<<< Pi done (${response.length} chars) [session:${nextSessionId}]${modelSummary}`,
+    )
+    return {
+      text: response,
+      sessionId: nextSessionId,
+    }
+  } catch (err) {
+    if (timedOut) {
+      throw new Error(`Timeout after ${timeoutSec}s`, { cause: err })
+    }
+    if (signal?.aborted) {
+      throw new Error('Request aborted', { cause: err })
+    }
+    throw err
+  } finally {
+    if (timeout) clearTimeout(timeout)
+    signal?.removeEventListener('abort', abortHandler)
+    conn.close()
+  }
+}
+
+function buildPiArgs(
+  modelID: string,
+  sessionId: string | undefined,
+  pi: PiOptions | undefined,
+): string[] {
+  const args = ['--mode', 'rpc', '--approve']
+  const sessionDir = piSessionDir(pi)
+  if (sessionDir) {
+    args.push('--session-dir', sessionDir)
+  }
+  if (sessionId) {
+    args.push('--session-id', sessionId)
+  }
+  if (modelID) {
+    args.push('--model', modelID)
+  }
+  return args
+}
+
+function buildPiEnv(pi: PiOptions | undefined): NodeJS.ProcessEnv {
+  const providerHome = piProviderHome(pi)
+  const sessionDir = piSessionDir(pi)
+  return {
+    ...process.env,
+    ...pi?.env,
+    PI_CODING_AGENT_DIR: providerHome,
+    PI_CODING_AGENT_SESSION_DIR: sessionDir,
+    ...(pi?.baseUrl ? { LLAMA_BASE_URL: pi.baseUrl } : {}),
+  }
+}
+
+function piProviderHome(pi: PiOptions | undefined): string {
+  return pi?.providerHome ?? join(homedir(), '.pi-coding-agent')
+}
+
+function piSessionDir(pi: PiOptions | undefined): string {
+  return pi?.sessionDir ?? join(piProviderHome(pi), 'sessions')
+}
+
+class PiRPCClient {
+  private nextID = 0
+
+  constructor(private readonly conn: PiConnection) {}
+
+  async prompt(message: string, signal?: AbortSignal): Promise<void> {
+    const response = await this.request('prompt', { message }, signal)
+    const command = piString(response.command)
+    if (command && command !== 'prompt') {
+      throw new Error(`Pi RPC command mismatch: expected prompt got ${command}`)
+    }
+  }
+
+  async getState(signal?: AbortSignal): Promise<PiRPCState> {
+    const response = await this.request('get_state', {}, signal)
+    const data = piObject(response.data, 'Pi get_state response missing data')
+    return {
+      sessionID: piString(data.sessionId),
+      modelSummary: piModelSummary(data.model),
+    }
+  }
+
+  async getLastAssistantText(signal?: AbortSignal): Promise<string> {
+    const response = await this.request('get_last_assistant_text', {}, signal)
+    const data = piObject(
+      response.data,
+      'Pi get_last_assistant_text response missing data',
+    )
+    return piString(data.text)
+  }
+
+  async waitAgentEnd(signal?: AbortSignal): Promise<void> {
+    for (;;) {
+      const { value } = await this.recv(signal)
+      if (piString(value.type) === 'agent_end') {
+        return
+      }
+    }
+  }
+
+  private async request(
+    type: string,
+    fields: Record<string, string>,
+    signal?: AbortSignal,
+  ): Promise<Record<string, unknown>> {
+    this.nextID++
+    const id = `ocpipe-pi-${this.nextID}`
+    this.conn.send(JSON.stringify({ type, id, ...fields }))
+    for (;;) {
+      const { value, line } = await this.recv(signal)
+      if (piString(value.type) !== 'response' || piString(value.id) !== id) {
+        continue
+      }
+      if (value.success !== true) {
+        const errorText = piString(value.error) || line
+        throw new Error(`Pi RPC ${type} failed: ${errorText}`)
+      }
+      return value
+    }
+  }
+
+  private async recv(
+    signal?: AbortSignal,
+  ): Promise<{ value: Record<string, unknown>; line: string }> {
+    const line = await this.conn.recv(signal)
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(line)
+    } catch (err) {
+      throw new Error(`Parse Pi RPC JSONL failed: ${line}`, { cause: err })
+    }
+    return { value: piObject(parsed, 'Pi RPC line must be an object'), line }
+  }
+}
+
+const commandPiProcess: PiProcess = {
+  start(req) {
+    const child = spawn(req.command, req.args, {
+      cwd: req.cwd,
+      env: req.env,
+      stdio: ['pipe', 'pipe', 'inherit'],
+    })
+    return new CommandPiConnection(child)
+  },
+}
+
+class CommandPiConnection implements PiConnection {
+  private readonly lines: string[] = []
+  private readonly waiters: Array<{
+    resolve: (line: string) => void
+    reject: (err: Error) => void
+    signal?: AbortSignal
+    abort?: () => void
+  }> = []
+  private closedError: Error | null = null
+
+  constructor(private readonly child: ChildProcess) {
+    if (!child.stdout || !child.stdin) {
+      throw new Error('Pi RPC process pipes were not opened')
+    }
+    const rl = createInterface({ input: child.stdout })
+    rl.on('line', (line) => this.push(line))
+    child.on('error', (err) => this.closeWith(err))
+    child.on('close', (code, signal) => {
+      if (this.closedError) return
+      if (code === 0) {
+        this.closeWith(new Error('Pi RPC closed'))
+        return
+      }
+      const detail = signal ? `signal ${signal}` : `status ${code}`
+      this.closeWith(new Error(`Pi RPC exited with ${detail}`))
+    })
+  }
+
+  send(line: string): void {
+    if (!this.child.stdin) {
+      throw new Error('Pi RPC stdin is closed')
+    }
+    this.child.stdin.write(line.trimEnd() + '\n')
+  }
+
+  recv(signal?: AbortSignal): Promise<string> {
+    if (this.lines.length > 0) {
+      return Promise.resolve(this.lines.shift() ?? '')
+    }
+    if (this.closedError) {
+      return Promise.reject(this.closedError)
+    }
+    if (signal?.aborted) {
+      return Promise.reject(new Error('Request aborted'))
+    }
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        resolve,
+        reject,
+        signal,
+        abort: undefined as (() => void) | undefined,
+      }
+      waiter.abort = () => {
+        this.removeWaiter(waiter)
+        reject(new Error('Request aborted'))
+      }
+      signal?.addEventListener('abort', waiter.abort, { once: true })
+      this.waiters.push(waiter)
+    })
+  }
+
+  close(): void {
+    this.child.stdin?.destroy()
+    this.child.kill()
+  }
+
+  private push(line: string): void {
+    const waiter = this.waiters.shift()
+    if (!waiter) {
+      this.lines.push(line)
+      return
+    }
+    if (waiter.abort) {
+      waiter.signal?.removeEventListener('abort', waiter.abort)
+    }
+    waiter.resolve(line)
+  }
+
+  private closeWith(err: Error): void {
+    this.closedError = err
+    for (const waiter of this.waiters.splice(0)) {
+      if (waiter.abort) {
+        waiter.signal?.removeEventListener('abort', waiter.abort)
+      }
+      waiter.reject(err)
+    }
+  }
+
+  private removeWaiter(waiter: (typeof this.waiters)[number]): void {
+    const idx = this.waiters.indexOf(waiter)
+    if (idx >= 0) {
+      this.waiters.splice(idx, 1)
+    }
+  }
+}
+
+function piObject(value: unknown, message: string): Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    throw new Error(message)
+  }
+  return value as Record<string, unknown>
+}
+
+function piString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function piModelSummary(value: unknown): string {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return ''
+  }
+  const model = value as Record<string, unknown>
+  const provider = firstNonEmpty(
+    piString(model.provider),
+    piString(model.providerId),
+  )
+  const id = firstNonEmpty(
+    piString(model.id),
+    piString(model.model),
+    piString(model.name),
+  )
+  if (provider && id) {
+    return `${provider}/${id}`
+  }
+  return firstNonEmpty(id, provider)
+}
+
+function firstNonEmpty(...values: string[]): string {
+  for (const value of values) {
+    const trimmed = value.trim()
+    if (trimmed) return trimmed
+  }
+  return ''
+}

package/src/pipeline.ts

@@ -35,6 +35,8 @@ export class Pipeline<S extends BaseState> {
       workdir: config.workdir,
       claudeCode: config.claudeCode,
       codex: config.codex,
+      pi: config.pi,
+      omp: config.omp,
     }
   }
 

package/src/predict.ts

@@ -78,6 +78,8 @@ export class Predict<S extends AnySignature> {
       workdir: ctx.workdir,
       claudeCode: ctx.claudeCode,
       codex: ctx.codex,
+      pi: ctx.pi,
+      omp: ctx.omp,
       signal: ctx.signal,
     })
 
@@ -209,6 +211,8 @@ export class Predict<S extends AnySignature> {
         workdir: ctx.workdir,
         claudeCode: ctx.claudeCode,
         codex: ctx.codex,
+        pi: ctx.pi,
+        omp: ctx.omp,
         signal: ctx.signal,
       })
 
@@ -287,6 +291,8 @@ export class Predict<S extends AnySignature> {
         workdir: ctx.workdir,
         claudeCode: ctx.claudeCode,
         codex: ctx.codex,
+        pi: ctx.pi,
+        omp: ctx.omp,
         signal: ctx.signal,
       })
 

package/src/types.ts

@@ -9,7 +9,7 @@ import type { z } from 'zod/v4'
 // ============================================================================
 
 /** Backend type for running agents. */
-export type BackendType = 'opencode' | 'claude-code' | 'codex'
+export type BackendType = 'opencode' | 'claude-code' | 'codex' | 'pi' | 'omp'
 
 /** Reasoning effort for Codex SDK threads. */
 export type CodexReasoningEffort =
@@ -119,6 +119,52 @@ export interface CodexOptions {
   webSearchEnabled?: boolean
 }
 
+/** Pi coding agent specific session options. */
+export interface PiOptions {
+  /** Path to the Pi executable (default: `pi` from PATH). */
+  command?: string
+  /** Pi runtime home passed as PI_CODING_AGENT_DIR. */
+  providerHome?: string
+  /** Pi session directory passed by flag and PI_CODING_AGENT_SESSION_DIR. */
+  sessionDir?: string
+  /** Base URL passed as LLAMA_BASE_URL. */
+  baseUrl?: string
+  /** Extra environment variables passed to the Pi subprocess. */
+  env?: Record<string, string>
+}
+
+/** Oh My Pi CLI specific session options. */
+export interface OmpOptions {
+  /** Path to the Oh My Pi executable (default: `omp` from PATH). */
+  command?: string
+  /** Process cwd used to launch Oh My Pi; defaults to the target workdir. */
+  processCwd?: string
+  /** OMP_HOME passed to the Oh My Pi subprocess. */
+  home?: string
+  /** CODEX_HOME value passed via `--codex-home`; set to empty string to clear it. */
+  codexHome?: string
+  /** Extra environment variables passed to the Oh My Pi subprocess. */
+  env?: Record<string, string>
+  /** Add `--auto-approve` (default: true). */
+  autoApprove?: boolean
+  /** Approval mode passed with `--approval-mode` (default: `yolo`). */
+  approvalMode?: string
+  /** Thinking effort passed with `--thinking` (default: `high`). */
+  thinking?: string
+  /** Run Oh My Pi as a continuing headless goal. */
+  goalMode?: boolean
+  /** Goal objective; setting this also enables goal mode. */
+  goalObjective?: string
+  /** Stop when context reaches this percent of the model window. */
+  contextStopPercent?: number
+  /** Stop when context reaches this token count. */
+  contextStopTokens?: number
+  /** Scratch handoff path passed to Oh My Pi; relative paths resolve against workdir. */
+  scratchHandoffFile?: string
+  /** Extra raw Oh My Pi arguments appended before the prompt separator. */
+  extraArgs?: string[]
+}
+
 /** Model configuration for LLM backends. */
 export interface ModelConfig {
   /** Backend to use (default: 'opencode'). */
@@ -152,6 +198,10 @@ export interface ExecutionContext {
   claudeCode?: ClaudeCodeOptions
   /** Codex SDK specific options. */
   codex?: CodexOptions
+  /** Pi coding agent specific options. */
+  pi?: PiOptions
+  /** Oh My Pi specific options. */
+  omp?: OmpOptions
   /** AbortSignal for cancelling in-flight backend requests. */
   signal?: AbortSignal
 }
@@ -372,6 +422,10 @@ export interface PipelineConfig {
   claudeCode?: ClaudeCodeOptions
   /** Codex SDK specific options. */
   codex?: CodexOptions
+  /** Pi coding agent specific options. */
+  pi?: PiOptions
+  /** Oh My Pi specific options. */
+  omp?: OmpOptions
 }
 
 /** Options for running a pipeline step. */
@@ -408,6 +462,10 @@ export interface RunAgentOptions {
   claudeCode?: ClaudeCodeOptions
   /** Codex SDK specific options. */
   codex?: CodexOptions
+  /** Pi coding agent specific options. */
+  pi?: PiOptions
+  /** Oh My Pi specific options. */
+  omp?: OmpOptions
   /** AbortSignal for cancelling the request. */
   signal?: AbortSignal
 }