ocpipe 0.6.9 → 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>, Pi, 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), Claude Code SDK, Codex SDK, or Pi
+- **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 four 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,13 @@ 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocpipe",
-  "version": "0.6.9",
+  "version": "0.6.10",
   "description": "SDK for LLM pipelines with OpenCode, Codex, and Zod",
   "type": "module",
   "main": "src/index.ts",
@@ -43,18 +43,18 @@
     }
   },
   "devDependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.197",
     "@eslint/js": "^10.0.1",
-    "@openai/codex-sdk": "0.141.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

@@ -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,21 +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') {
-    const { runPiAgent } = await import('./pi.js')
     return runPiAgent(options)
   }
 
+  if (backend === 'omp') {
+    return runOmpAgent(options)
+  }
+
   return runOpencodeAgent(options)
 }
 

package/src/index.ts

@@ -93,6 +93,7 @@ export type {
   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/pipeline.ts

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

package/src/predict.ts

@@ -79,6 +79,7 @@ export class Predict<S extends AnySignature> {
       claudeCode: ctx.claudeCode,
       codex: ctx.codex,
       pi: ctx.pi,
+      omp: ctx.omp,
       signal: ctx.signal,
     })
 
@@ -211,6 +212,7 @@ export class Predict<S extends AnySignature> {
         claudeCode: ctx.claudeCode,
         codex: ctx.codex,
         pi: ctx.pi,
+        omp: ctx.omp,
         signal: ctx.signal,
       })
 
@@ -290,6 +292,7 @@ export class Predict<S extends AnySignature> {
         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' | 'pi'
+export type BackendType = 'opencode' | 'claude-code' | 'codex' | 'pi' | 'omp'
 
 /** Reasoning effort for Codex SDK threads. */
 export type CodexReasoningEffort =
@@ -133,6 +133,38 @@ export interface PiOptions {
   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'). */
@@ -168,6 +200,8 @@ export interface ExecutionContext {
   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
 }
@@ -390,6 +424,8 @@ export interface PipelineConfig {
   codex?: CodexOptions
   /** Pi coding agent specific options. */
   pi?: PiOptions
+  /** Oh My Pi specific options. */
+  omp?: OmpOptions
 }
 
 /** Options for running a pipeline step. */
@@ -428,6 +464,8 @@ export interface RunAgentOptions {
   codex?: CodexOptions
   /** Pi coding agent specific options. */
   pi?: PiOptions
+  /** Oh My Pi specific options. */
+  omp?: OmpOptions
   /** AbortSignal for cancelling the request. */
   signal?: AbortSignal
 }