ocpipe 0.6.9 → 0.6.11

package/src/agent.ts

@@ -1,29 +1,25 @@
 /**
  * ocpipe agent integration.
  *
- * Dispatches to OpenCode CLI, Claude Code SDK, Codex SDK, or Pi based on backend
- * configuration.
+ * Dispatches prompts to configured coding-agent backends.
  */
 
 import { spawn } from 'child_process'
-import { mkdir, writeFile, unlink } from 'fs/promises'
+import { randomUUID } from 'crypto'
+import { mkdir, unlink, writeFile } from 'fs/promises'
 import { join } from 'path'
 import { PROJECT_ROOT, TMP_DIR } from './paths.js'
 import type { RunAgentOptions, RunAgentResult } from './types.js'
+import { runOmpAgent } from './omp.js'
+import { runPiAgent } from './pi.js'
 
-/** Get command and args to invoke opencode from PATH */
-function getOpencodeCommand(args: string[]): { cmd: string; args: string[] } {
-  return { cmd: 'opencode', args }
-}
-
-/** runAgent dispatches to the appropriate backend based on model configuration. */
+/** runAgent dispatches to the selected backend. */
 export async function runAgent(
   options: RunAgentOptions,
 ): Promise<RunAgentResult> {
-  const backend = options.model.backend ?? 'opencode'
+  const backend = options.model.backend ?? 'omp'
 
   if (backend === 'claude-code') {
-    // Dynamic import to avoid requiring @anthropic-ai/claude-agent-sdk when using opencode
     const { runClaudeCodeAgent } = await import('./claude-code.js')
     return runClaudeCodeAgent(options)
   }
@@ -33,57 +29,60 @@ export async function runAgent(
     return runCodexAgent(options)
   }
 
+  if (backend === 'opencode') {
+    return runOpencodeAgent(options)
+  }
+
   if (backend === 'pi') {
-    const { runPiAgent } = await import('./pi.js')
     return runPiAgent(options)
   }
 
-  return runOpencodeAgent(options)
+  if (backend === 'omp') {
+    return runOmpAgent(options)
+  }
+
+  const unreachable: never = backend
+  throw new Error(`Unsupported backend: ${unreachable}`)
 }
 
-/** runOpencodeAgent executes an OpenCode agent with a prompt, streaming output in real-time. */
 async function runOpencodeAgent(
   options: RunAgentOptions,
 ): Promise<RunAgentResult> {
   const {
     prompt,
-    agent,
     model,
     sessionId,
     timeoutSec = 3600,
     workdir,
+    opencode,
     signal,
   } = options
 
   if (!model.providerID) {
     throw new Error('providerID is required for OpenCode backend')
   }
-  const modelStr = `${model.providerID}/${model.modelID}`
-  const sessionInfo = sessionId ? `[session:${sessionId}]` : '[new session]'
-  const promptPreview = prompt.slice(0, 50).replace(/\n/g, ' ')
 
-  console.error(
-    `\n>>> OpenCode [${agent}] [${modelStr}] ${sessionInfo}: ${promptPreview}...`,
-  )
-
-  // Check if already aborted
   if (signal?.aborted) {
     throw new Error('Request aborted')
   }
 
-  // Write prompt to .opencode/prompts/ within the working directory
   const cwd = workdir ?? PROJECT_ROOT
-  const promptsDir = join(cwd, '.opencode', 'prompts')
-  await mkdir(promptsDir, { recursive: true })
-  const promptFile = join(promptsDir, `prompt_${Date.now()}.txt`)
+  const modelStr = `${model.providerID}/${model.modelID}`
+  const sessionInfo = sessionId ? `[session:${sessionId}]` : '[new session]'
+  const promptPreview = prompt.slice(0, 50).replace(/\n/g, ' ')
+  console.error(
+    `\n>>> OpenCode [${modelStr}] ${sessionInfo}: ${promptPreview}...`,
+  )
+
+  const promptDir = opencode?.promptDir ?? TMP_DIR
+  await mkdir(promptDir, { recursive: true })
+  const promptFile = join(promptDir, `ocpipe_prompt_${randomUUID()}.txt`)
   await writeFile(promptFile, prompt)
 
   const args = [
     'run',
     '--format',
     'default',
-    '--agent',
-    agent,
     '--model',
     modelStr,
     '--prompt-file',
@@ -93,11 +92,9 @@ async function runOpencodeAgent(
   if (sessionId) {
     args.push('--session', sessionId)
   }
-
   if (model.variant) {
     args.push('--model-variant', model.variant)
   }
-
   if (model.variantThinkingBudget !== undefined) {
     args.push(
       '--model-variant-thinking-budget',
@@ -105,194 +102,164 @@ async function runOpencodeAgent(
     )
   }
 
-  return new Promise((resolve, reject) => {
-    const opencodeCmd = getOpencodeCommand(args)
-    console.error(
-      `[DEBUG] Running: ${opencodeCmd.cmd} ${opencodeCmd.args.join(' ')}`,
-    )
-    const proc = spawn(opencodeCmd.cmd, opencodeCmd.args, {
-      cwd,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    })
-
-    let newSessionId = sessionId || ''
-    const stdoutChunks: string[] = []
-    const stderrChunks: string[] = []
-    let aborted = false
-
-    // Handle abort signal - kill subprocess when aborted
-    const abortHandler = async () => {
-      if (aborted) return
-      aborted = true
-      console.error(`\n[abort] Killing OpenCode subprocess...`)
-      proc.kill('SIGTERM')
-      // Give it a moment to clean up, then force kill
-      setTimeout(() => {
-        if (!proc.killed) proc.kill('SIGKILL')
-      }, 1000)
-      await unlink(promptFile).catch(() => {})
-      reject(new Error('Request aborted'))
-    }
-    signal?.addEventListener('abort', abortHandler, { once: true })
-
-    // Stream stderr in real-time (OpenCode progress output)
-    proc.stderr.on('data', (data: Buffer) => {
-      const text = data.toString()
-      stderrChunks.push(text)
-
-      // Parse session ID from output
-      for (const line of text.split('\n')) {
-        if (line.startsWith('[session:')) {
-          newSessionId = line.trim().slice(9, -1)
-          continue
-        }
-        // Filter noise
-        if (line.includes('baseline-browser-mapping')) continue
-        if (line.startsWith('$ bun run')) continue
-        if (line.trim()) {
-          process.stderr.write(line + '\n')
-        }
-      }
-    })
-
-    // Collect stdout
-    proc.stdout.on('data', (data: Buffer) => {
-      const text = data.toString()
-      stdoutChunks.push(text)
-      process.stderr.write(text)
-    })
-
-    // Timeout handling (0 = no timeout)
-    const timeout =
-      timeoutSec > 0 ?
-        setTimeout(async () => {
-          proc.kill()
-          await unlink(promptFile).catch(() => {})
-          reject(new Error(`Timeout after ${timeoutSec}s`))
-        }, timeoutSec * 1000)
-      : null
-
-    proc.on('close', async (code) => {
-      if (timeout) clearTimeout(timeout)
-      signal?.removeEventListener('abort', abortHandler)
-
-      // If aborted, we already rejected
-      if (aborted) return
-
-      // Clean up prompt file
-      await unlink(promptFile).catch(() => {})
-
-      const stderr = stderrChunks.join('').trim()
-
-      if (code !== 0) {
-        const lastLines = stderr.split('\n').slice(-5).join('\n')
-        const detail = lastLines ? `\n${lastLines}` : ''
-        reject(new Error(`OpenCode exited with code ${code}${detail}`))
-        return
-      }
+  const command = opencode?.command ?? 'opencode'
+  console.error(`[DEBUG] Running: ${command} ${args.join(' ')}`)
+  const proc = spawn(command, args, {
+    cwd,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { ...process.env, ...opencode?.env },
+  })
 
-      // Check for OpenCode errors that exit with code 0 but produce no output
-      const knownErrors = [
-        {
-          pattern: /ProviderModelNotFoundError/,
-          message: 'Provider/model not found',
-        },
-        { pattern: /ModelNotFoundError/, message: 'Model not found' },
-        { pattern: /ProviderNotFoundError/, message: 'Provider not found' },
-        { pattern: /API key.*not.*found/i, message: 'API key not configured' },
-        {
-          pattern: /authentication.*failed/i,
-          message: 'Authentication failed',
-        },
-      ]
-
-      for (const { pattern, message } of knownErrors) {
-        if (pattern.test(stderr)) {
-          // Extract the relevant error lines
-          const errorLines = stderr
-            .split('\n')
-            .filter(
-              (line) =>
-                pattern.test(line) ||
-                line.includes('Error') ||
-                line.includes('error:'),
-            )
-            .slice(0, 5)
-            .join('\n')
-          reject(new Error(`OpenCode ${message}:\n${errorLines}`))
-          return
-        }
-      }
+  const { promise, resolve, reject } = Promise.withResolvers<RunAgentResult>()
+  let newSessionId = sessionId || ''
+  const stdoutChunks: string[] = []
+  const stderrChunks: string[] = []
+  let aborted = false
+
+  const abortHandler = () => {
+    if (aborted) return
+    aborted = true
+    console.error(`\n[abort] Killing OpenCode subprocess...`)
+    proc.kill('SIGTERM')
+    setTimeout(() => {
+      if (!proc.killed) proc.kill('SIGKILL')
+    }, 1000)
+    void unlink(promptFile).catch(() => {})
+    reject(new Error('Request aborted'))
+  }
+  signal?.addEventListener('abort', abortHandler, { once: true })
 
-      // Export session to get structured response
-      let response = stdoutChunks.join('').trim()
+  proc.stderr.on('data', (data: Buffer) => {
+    const text = data.toString()
+    stderrChunks.push(text)
 
-      if (newSessionId) {
-        const exported = await exportSession(newSessionId, workdir)
-        if (exported) {
-          response = exported
-        }
+    for (const line of text.split('\n')) {
+      if (line.startsWith('[session:')) {
+        newSessionId = line.trim().slice(9, -1)
+        continue
+      }
+      if (line.includes('baseline-browser-mapping')) continue
+      if (line.startsWith('$ bun run')) continue
+      if (line.trim()) {
+        process.stderr.write(line + '\n')
       }
+    }
+  })
+
+  proc.stdout.on('data', (data: Buffer) => {
+    const text = data.toString()
+    stdoutChunks.push(text)
+    process.stderr.write(text)
+  })
+
+  const timeout =
+    timeoutSec > 0 ?
+      setTimeout(() => {
+        proc.kill()
+        void unlink(promptFile).catch(() => {})
+        reject(new Error(`Timeout after ${timeoutSec}s`))
+      }, timeoutSec * 1000)
+    : undefined
+
+  proc.on('close', async (code) => {
+    clearTimeout(timeout)
+    signal?.removeEventListener('abort', abortHandler)
+    if (aborted) return
+
+    void unlink(promptFile).catch(() => {})
+    const stderr = stderrChunks.join('').trim()
+
+    if (code !== 0) {
+      const lastLines = stderr.split('\n').slice(-5).join('\n')
+      const detail = lastLines ? `\n${lastLines}` : ''
+      reject(new Error(`OpenCode exited with code ${code}${detail}`))
+      return
+    }
 
-      // Check for empty response with errors in stderr (likely a silent failure)
-      if (response.length === 0 && stderr.includes('Error')) {
-        const lastLines = stderr.split('\n').slice(-10).join('\n')
-        reject(
-          new Error(
-            `OpenCode returned empty response with errors:\n${lastLines}`,
-          ),
-        )
+    for (const { pattern, message } of knownOpenCodeErrors) {
+      if (pattern.test(stderr)) {
+        const errorLines = stderr
+          .split('\n')
+          .filter(
+            (line) =>
+              pattern.test(line) ||
+              line.includes('Error') ||
+              line.includes('error:'),
+          )
+          .slice(0, 5)
+          .join('\n')
+        reject(new Error(`OpenCode ${message}:\n${errorLines}`))
         return
       }
+    }
+
+    let response = stdoutChunks.join('').trim()
+    if (newSessionId) {
+      response =
+        (await exportSession(newSessionId, cwd, command, opencode?.env)) ??
+        response
+    }
 
-      const sessionStr = newSessionId || 'none'
-      console.error(
-        `<<< OpenCode done (${response.length} chars) [session:${sessionStr}]`,
+    if (response.length === 0 && stderr.includes('Error')) {
+      const lastLines = stderr.split('\n').slice(-10).join('\n')
+      reject(
+        new Error(
+          `OpenCode returned empty response with errors:\n${lastLines}`,
+        ),
       )
+      return
+    }
+
+    const sessionStr = newSessionId || 'none'
+    console.error(
+      `<<< OpenCode done (${response.length} chars) [session:${sessionStr}]`,
+    )
+    resolve({ text: response, sessionId: newSessionId })
+  })
 
-      resolve({
-        text: response,
-        sessionId: newSessionId,
-      })
-    })
-
-    proc.on('error', async (err) => {
-      if (timeout) clearTimeout(timeout)
-      await unlink(promptFile).catch(() => {})
-      reject(err)
-    })
+  proc.on('error', (err) => {
+    clearTimeout(timeout)
+    signal?.removeEventListener('abort', abortHandler)
+    void unlink(promptFile).catch(() => {})
+    reject(err)
   })
+
+  return promise
 }
 
-/** exportSession exports a session and extracts assistant text responses. */
 async function exportSession(
   sessionId: string,
-  workdir?: string,
+  workdir: string,
+  command: string,
+  env: Record<string, string> | undefined,
 ): Promise<string | null> {
-  const tmpPath = `${TMP_DIR}/opencode_export_${Date.now()}.json`
+  const exportFile = join(TMP_DIR, `opencode_export_${randomUUID()}.json`)
 
   try {
     await mkdir(TMP_DIR, { recursive: true })
-    const opencodeCmd = getOpencodeCommand([
-      'session',
-      'export',
-      sessionId,
-      '--format',
-      'json',
-      '--turn',
-      '-1',
-      '-o',
-      tmpPath,
-    ])
-    const proc = Bun.spawn([opencodeCmd.cmd, ...opencodeCmd.args], {
-      cwd: workdir ?? PROJECT_ROOT,
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
+    const proc = Bun.spawn(
+      [
+        command,
+        'session',
+        'export',
+        sessionId,
+        '--format',
+        'json',
+        '--turn',
+        '-1',
+        '-o',
+        exportFile,
+      ],
+      {
+        cwd: workdir,
+        stdout: 'pipe',
+        stderr: 'pipe',
+        env: { ...process.env, ...env },
+      },
+    )
 
     await proc.exited
-
-    const file = Bun.file(tmpPath)
+    const file = Bun.file(exportFile)
     if (!(await file.exists())) return null
 
     const data = (await file.json()) as {
@@ -301,29 +268,37 @@ async function exportSession(
         parts?: Array<{ type?: string; text?: string }>
       }>
     }
-    await Bun.write(tmpPath, '') // Clean up
+    void unlink(exportFile).catch(() => {})
 
-    // Extract all assistant text parts from the exported turn.
-    // The --turn -1 flag ensures we only get the last turn's messages.
-    const messages = data.messages || []
     const textParts: string[] = []
-
-    for (const msg of messages) {
-      if (msg.info?.role === 'assistant') {
-        for (const part of msg.parts || []) {
-          if (part.type === 'text' && part.text) {
-            textParts.push(part.text)
-          }
+    for (const msg of data.messages ?? []) {
+      if (msg.info?.role !== 'assistant') continue
+      for (const part of msg.parts ?? []) {
+        if (part.type === 'text' && part.text) {
+          textParts.push(part.text)
         }
       }
     }
 
     return textParts.length > 0 ? textParts.join('\n') : null
   } catch {
+    void unlink(exportFile).catch(() => {})
     return null
   }
 }
 
+const knownOpenCodeErrors: ReadonlyArray<{ pattern: RegExp; message: string }> =
+  [
+    {
+      pattern: /ProviderModelNotFoundError/,
+      message: 'Provider/model not found',
+    },
+    { pattern: /ModelNotFoundError/, message: 'Model not found' },
+    { pattern: /ProviderNotFoundError/, message: 'Provider not found' },
+    { pattern: /API key.*not.*found/i, message: 'API key not configured' },
+    { pattern: /authentication.*failed/i, message: 'Authentication failed' },
+  ]
+
 /** logStep logs a step header for workflow progress. */
 export function logStep(step: number, title: string, detail = ''): void {
   const detailStr = detail ? ` (${detail})` : ''

package/src/claude-code.ts

@@ -11,7 +11,7 @@
  */
 
 import { execSync } from 'child_process'
-import { existsSync, readFileSync } from 'fs'
+import { existsSync } from 'fs'
 import { join } from 'path'
 import { homedir } from 'os'
 import {
@@ -66,9 +66,14 @@ function resolveClaudeCodePath(explicit?: string): string | undefined {
   if (explicit) return explicit
 
   try {
-    const found = execSync('which claude', { encoding: 'utf8', timeout: 3000 }).trim()
+    const found = execSync('which claude', {
+      encoding: 'utf8',
+      timeout: 3000,
+    }).trim()
     if (found) return found
-  } catch { /* which not found or timed out — fall through to defaults */ }
+  } catch {
+    /* which not found or timed out — fall through to defaults */
+  }
 
   const defaults = [
     join(homedir(), '.local', 'bin', 'claude'),
@@ -90,21 +95,6 @@ function normalizeModelId(modelId: string): string {
   return modelId
 }
 
-/** loadAgentDefinition loads an OpenCode agent definition file and extracts the
- * markdown body (stripping the YAML frontmatter) for use as a system prompt. */
-function loadAgentDefinition(agent: string, workdir?: string): string | undefined {
-  if (!agent || !workdir) return undefined
-
-  const agentPath = join(workdir, '.opencode', 'agents', `${agent}.md`)
-  if (!existsSync(agentPath)) return undefined
-
-  const content = readFileSync(agentPath, 'utf8')
-
-  // Strip YAML frontmatter (--- delimited block at the start).
-  const stripped = content.replace(/^---\n[\s\S]*?\n---\n*/, '')
-  return stripped.trim() || undefined
-}
-
 /** Extract text from assistant messages. */
 function getAssistantText(msg: SDKMessage): string | null {
   if (msg.type !== 'assistant') return null
@@ -147,7 +137,6 @@ export async function runClaudeCodeAgent(
 ): Promise<RunAgentResult> {
   const {
     prompt,
-    agent,
     model,
     sessionId,
     timeoutSec = 3600,
@@ -169,8 +158,8 @@ export async function runClaudeCodeAgent(
   // Build query options with configurable permission mode (default: acceptEdits)
   const permissionMode = claudeCode?.permissionMode ?? 'acceptEdits'
 
-  // Resolve system prompt: explicit option > agent definition file > none
-  const systemPrompt = claudeCode?.systemPrompt ?? loadAgentDefinition(agent, workdir)
+  // Resolve system prompt from explicit configuration only.
+  const systemPrompt = claudeCode?.systemPrompt
 
   // Bridge external abort signal to an AbortController for the SDK
   const abortController = new AbortController()
@@ -217,16 +206,22 @@ export async function runClaudeCodeAgent(
       }),
     // Resolve executable path: explicit option > PATH lookup > default locations
     ...(() => {
-      const resolved = resolveClaudeCodePath(claudeCode?.pathToClaudeCodeExecutable)
+      const resolved = resolveClaudeCodePath(
+        claudeCode?.pathToClaudeCodeExecutable,
+      )
       return resolved ? { pathToClaudeCodeExecutable: resolved } : {}
     })(),
   }
 
   if (claudeCode?.agents) {
-    console.error(`[ocpipe] Subagents defined: ${Object.keys(claudeCode.agents).join(', ')}`)
+    console.error(
+      `[ocpipe] Subagents defined: ${Object.keys(claudeCode.agents).join(', ')}`,
+    )
   }
   if (claudeCode?.allowedTools) {
-    console.error(`[ocpipe] Allowed tools: ${claudeCode.allowedTools.join(', ')}`)
+    console.error(
+      `[ocpipe] Allowed tools: ${claudeCode.allowedTools.join(', ')}`,
+    )
   }
   console.error(
     `\n>>> Claude Code [${modelStr}] [${permissionMode}] ${sessionInfo}: ${promptPreview}...`,

package/src/index.ts

@@ -1,5 +1,5 @@
 /**
- * ocpipe: LLM pipelines with OpenCode and Zod.
+ * ocpipe: LLM pipelines with coding-agent backends and Zod.
  *
  * Inspired by DSPy.
  *
@@ -22,8 +22,7 @@
  * // Run in a pipeline
  * const pipeline = new Pipeline({
  *   name: 'my-workflow',
- *   defaultModel: { providerID: 'opencode', modelID: 'minimax-m2.1-free' },
- *   defaultAgent: 'general',
+ *   defaultModel: { backend: 'omp', modelID: 'gpt-5.5' },
  *   checkpointDir: './ckpt',
  *   logDir: './logs',
  * }, createBaseState)
@@ -93,6 +92,7 @@ export type {
   PermissionMode,
   ClaudeCodeOptions,
   PiOptions,
+  OmpOptions,
   CodexApprovalPolicy,
   CodexConfigValue,
   CodexOptions,