ocpipe 0.3.9 → 0.4.1

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> 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>, 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-model** Works with 75+ providers through OpenCode
+- **Multi-backend** Choose between OpenCode (75+ providers) or Claude Code SDK
 - **Auto-correction** Fixes schema mismatches automatically
 
 ### Quick Start
@@ -47,15 +47,43 @@ type GreetIn = InferInputs<typeof Greet> // { name: string }
 type GreetOut = InferOutputs<typeof Greet> // { greeting: string }
 ```
 
-OpenCode CLI is bundled — run `bun run opencode` or use your system `opencode` if installed.
+### Backends
+
+ocpipe supports two backends for running LLM agents:
+
+**OpenCode** (default) - Requires `opencode` CLI in your PATH. Supports 75+ providers.
+
+```typescript
+const pipeline = new Pipeline({
+  name: 'my-pipeline',
+  defaultModel: { providerID: 'anthropic', modelID: 'claude-sonnet-4-20250514' },
+  defaultAgent: 'default',
+}, createBaseState)
+```
+
+**Claude Code** - Uses `@anthropic-ai/claude-agent-sdk`. Install as a peer dependency.
+
+```typescript
+const pipeline = new Pipeline({
+  name: 'my-pipeline',
+  defaultModel: { backend: 'claude-code', providerID: 'anthropic', modelID: 'claude-sonnet-4-20250514' },
+  defaultAgent: 'default',
+}, createBaseState)
+```
 
 ### Requirements
 
-Currently requires [this OpenCode fork](https://github.com/paralin/opencode). Once the following PRs are merged, the official release will work:
+**For OpenCode backend:** Currently requires [this OpenCode fork](https://github.com/paralin/opencode). Once the following PRs are merged, the official release will work:
 
 - [#5426](https://github.com/anomalyco/opencode/pull/5426) - Adds `--prompt-file` flag
 - [#5339](https://github.com/anomalyco/opencode/pull/5339) - Session export fixes
 
+**For Claude Code backend:** Install the SDK as a peer dependency:
+
+```bash
+bun add @anthropic-ai/claude-agent-sdk
+```
+
 ### Documentation
 
 - [Getting Started](./GETTING_STARTED.md) - Tutorial with examples

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocpipe",
-  "version": "0.3.9",
+  "version": "0.4.1",
   "description": "SDK for LLM pipelines with OpenCode and Zod",
   "type": "module",
   "main": "src/index.ts",
@@ -28,13 +28,18 @@
   "engines": {
     "bun": ">=1.0.0"
   },
-  "dependencies": {
-    "opencode-ai": "1.1.25"
-  },
+  "dependencies": {},
   "peerDependencies": {
-    "zod": "4.3.5"
+    "zod": "4.3.6",
+    "@anthropic-ai/claude-agent-sdk": "0.2.19"
+  },
+  "peerDependenciesMeta": {
+    "@anthropic-ai/claude-agent-sdk": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.14",
     "@eslint/js": "^9.39.2",
     "bun-types": "^1.3.5",
     "eslint": "^9.39.2",

package/src/agent.ts

@@ -1,53 +1,37 @@
 /**
- * ocpipe OpenCode agent integration.
+ * ocpipe agent integration.
  *
- * Wraps the OpenCode CLI for running LLM agents with session management.
+ * Dispatches to OpenCode CLI or Claude Code SDK based on backend configuration.
  */
 
 import { spawn } from 'child_process'
-import { existsSync } from 'fs'
 import { mkdir, writeFile, unlink } from 'fs/promises'
 import { join } from 'path'
 import { PROJECT_ROOT, TMP_DIR } from './paths.js'
 import type { RunAgentOptions, RunAgentResult } from './types.js'
 
-/** Find opencode binary from PATH, preferring non-node_modules locations */
-function findOpencode(): string | null {
-  const pathDirs = (process.env.PATH || '').split(':')
+/** Get command and args to invoke opencode from PATH */
+function getOpencodeCommand(args: string[]): { cmd: string; args: string[] } {
+  return { cmd: 'opencode', args }
+}
 
-  // First pass: look for opencode in non-node_modules directories
-  for (const dir of pathDirs) {
-    if (dir.includes('node_modules')) continue
-    const candidate = join(dir, 'opencode')
-    if (existsSync(candidate)) {
-      return candidate
-    }
-  }
+/** runAgent dispatches to the appropriate backend based on model configuration. */
+export async function runAgent(
+  options: RunAgentOptions,
+): Promise<RunAgentResult> {
+  const backend = options.model.backend ?? 'opencode'
 
-  // Second pass: check node_modules/.bin as fallback
-  for (const dir of pathDirs) {
-    if (!dir.includes('node_modules')) continue
-    const candidate = join(dir, 'opencode')
-    if (existsSync(candidate)) {
-      return candidate
-    }
+  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)
   }
 
-  return null
-}
-
-/** Get command and args to invoke opencode */
-function getOpencodeCommand(args: string[]): { cmd: string; args: string[] } {
-  const opencode = findOpencode()
-  if (opencode) {
-    return { cmd: opencode, args }
-  }
-  // Fallback to bunx with ocpipe package (which has opencode-ai as dependency)
-  return { cmd: 'bunx', args: ['-p', 'ocpipe', 'opencode', ...args] }
+  return runOpencodeAgent(options)
 }
 
-/** runAgent executes an OpenCode agent with a prompt, streaming output in real-time. */
-export async function runAgent(
+/** 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 = 300, workdir } = options
@@ -69,6 +53,8 @@ export async function runAgent(
 
   const args = [
     'run',
+    '--dir',
+    cwd,
     '--format',
     'default',
     '--agent',
@@ -85,6 +71,7 @@ export async function runAgent(
 
   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'],

package/src/claude-code.ts

@@ -0,0 +1,102 @@
+/**
+ * ocpipe Claude Code agent integration.
+ *
+ * Uses the Claude Agent SDK v2 for running LLM agents with session management.
+ */
+
+import {
+  unstable_v2_createSession,
+  unstable_v2_resumeSession,
+  type SDKMessage,
+} from '@anthropic-ai/claude-agent-sdk'
+import type { RunAgentOptions, RunAgentResult } from './types.js'
+
+/** Extract text from assistant messages. */
+function getAssistantText(msg: SDKMessage): string | null {
+  if (msg.type !== 'assistant') return null
+  const textParts: string[] = []
+  for (const block of msg.message.content) {
+    if (block.type === 'text') {
+      textParts.push(block.text)
+    }
+  }
+  return textParts.join('')
+}
+
+/** runClaudeCodeAgent executes a Claude Code agent with a prompt. */
+export async function runClaudeCodeAgent(
+  options: RunAgentOptions,
+): Promise<RunAgentResult> {
+  const { prompt, model, sessionId, timeoutSec = 300 } = options
+
+  // Claude Agent SDK only uses modelID, not providerID
+  const modelStr = model.modelID
+  const sessionInfo = sessionId ? `[session:${sessionId}]` : '[new session]'
+  const promptPreview = prompt.slice(0, 50).replace(/\n/g, ' ')
+
+  console.error(
+    `\n>>> Claude Code [${modelStr}] ${sessionInfo}: ${promptPreview}...`,
+  )
+
+  // Create or resume session
+  const session =
+    sessionId ?
+      unstable_v2_resumeSession(sessionId, { model: modelStr })
+    : unstable_v2_createSession({ model: modelStr })
+
+  try {
+    // Send the prompt
+    await session.send(prompt)
+
+    // Collect the response
+    const textParts: string[] = []
+    let newSessionId = sessionId || ''
+
+    // Set up timeout
+    const timeoutPromise =
+      timeoutSec > 0 ?
+        new Promise<never>((_, reject) => {
+          setTimeout(() => {
+            session.close()
+            reject(new Error(`Timeout after ${timeoutSec}s`))
+          }, timeoutSec * 1000)
+        })
+      : null
+
+    // Stream the response
+    const streamPromise = (async () => {
+      for await (const msg of session.stream()) {
+        // Capture session ID from any message
+        if (msg.session_id) {
+          newSessionId = msg.session_id
+        }
+
+        const text = getAssistantText(msg)
+        if (text) {
+          textParts.push(text)
+          process.stderr.write(text)
+        }
+      }
+    })()
+
+    // Race between stream and timeout
+    if (timeoutPromise) {
+      await Promise.race([streamPromise, timeoutPromise])
+    } else {
+      await streamPromise
+    }
+
+    const response = textParts.join('')
+    const sessionStr = newSessionId || 'none'
+    console.error(
+      `\n<<< Claude Code done (${response.length} chars) [session:${sessionStr}]`,
+    )
+
+    return {
+      text: response,
+      sessionId: newSessionId,
+    }
+  } finally {
+    session.close()
+  }
+}

package/src/index.ts

@@ -87,6 +87,7 @@ export type { MockResponse } from './testing.js'
 // Types
 export type {
   // Core types
+  BackendType,
   ModelConfig,
   ExecutionContext,
   StepResult,

package/src/parsing.ts

@@ -307,33 +307,69 @@ export function zodTypeToString(zodType: z.ZodType): string {
   return 'unknown'
 }
 
+/**
+ * extractBalancedObject extracts a balanced JSON object starting at startIdx.
+ * Returns the object substring or null if unbalanced.
+ */
+function extractBalancedObject(text: string, startIdx: number): string | null {
+  if (startIdx === -1 || startIdx >= text.length || text[startIdx] !== '{') {
+    return null
+  }
+
+  let braceCount = 0
+  let endIdx = startIdx
+  for (let i = startIdx; i < text.length; i++) {
+    if (text[i] === '{') braceCount++
+    else if (text[i] === '}') {
+      braceCount--
+      if (braceCount === 0) {
+        endIdx = i + 1
+        break
+      }
+    }
+  }
+
+  if (endIdx > startIdx && braceCount === 0) {
+    return text.slice(startIdx, endIdx)
+  }
+  return null
+}
+
 /** extractJsonString finds and extracts JSON from a response string. */
 export function extractJsonString(response: string): string | null {
   // Try to find JSON in code blocks first
   const codeBlockMatch = response.match(/```(?:json)?\s*(\{[\s\S]*?)```/)
   if (codeBlockMatch?.[1]) {
-    return codeBlockMatch[1].trim()
+    const candidate = codeBlockMatch[1].trim()
+    // Validate it's actually parseable JSON
+    try {
+      JSON.parse(candidate)
+      return candidate
+    } catch {
+      // Code block content is malformed, try other methods
+    }
   }
 
-  // Try to find raw JSON by counting braces
-  const startIdx = response.indexOf('{')
-  if (startIdx !== -1) {
-    let braceCount = 0
-    let endIdx = startIdx
-    for (let i = startIdx; i < response.length; i++) {
-      if (response[i] === '{') braceCount++
-      else if (response[i] === '}') {
-        braceCount--
-        if (braceCount === 0) {
-          endIdx = i + 1
-          break
-        }
+  // Try to find raw JSON by counting braces, starting from each { position
+  // This handles cases where the model started outputting JSON, then restarted
+  // (e.g., "{"response":{"embeds":[{"title":"Haze{"response":{"embeds":[...]}}}")
+  // We try each { position until we find one that produces valid JSON
+  let searchFrom = 0
+  while (searchFrom < response.length) {
+    const startIdx = response.indexOf('{', searchFrom)
+    if (startIdx === -1) break
+
+    const candidate = extractBalancedObject(response, startIdx)
+    if (candidate) {
+      try {
+        JSON.parse(candidate)
+        return candidate
+      } catch {
+        // This { position produced invalid JSON, try the next one
       }
     }
 
-    if (endIdx > startIdx) {
-      return response.slice(startIdx, endIdx)
-    }
+    searchFrom = startIdx + 1
   }
 
   return null

package/src/types.ts

@@ -8,8 +8,13 @@ import type { z } from 'zod/v4'
 // Model Configuration
 // ============================================================================
 
-/** Model configuration for OpenCode. */
+/** Backend type for running agents. */
+export type BackendType = 'opencode' | 'claude-code'
+
+/** Model configuration for LLM backends. */
 export interface ModelConfig {
+  /** Backend to use (default: 'opencode'). */
+  backend?: BackendType
   providerID: string
   modelID: string
 }