ocpipe 0.2.1 → 0.3.0

package/README.md

@@ -1,22 +1,17 @@
-<div align="center">
-  <h3>OpenCode Pipeline</h3>
-  <p>SDK for LLM pipelines with <a href="https://opencode.ai">OpenCode</a> and <a href="https://zod.dev">Zod</a>.</p>
-</div>
+<p align="center"><strong>ocpipe</strong></p>
+<p align="center">SDK for LLM pipelines with <a href="https://github.com/sst/opencode">OpenCode</a> and <a href="https://zod.dev">Zod</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>
+  <a href="https://github.com/s4wave/ocpipe/actions"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/s4wave/ocpipe/tests.yml?style=flat-square&branch=master" /></a>
+</p>
 
-<div align="center">
+---
 
-```
-Signature  →  Predict  →  Module  →  Pipeline
-   │            │           │           │
- what        execute     compose    orchestrate
-```
-
-</div>
+### Quick Start
 
 ```typescript
 import { signature, field, module, Pipeline, createBaseState } from 'ocpipe'
 
-// Define a signature
 const Greet = signature({
   doc: 'Generate a friendly greeting for the given name.',
   inputs: {
@@ -28,33 +23,38 @@ const Greet = signature({
   },
 })
 
-// Run in a pipeline
-const pipeline = new Pipeline({
-  name: 'hello-world',
-  defaultModel: { providerID: 'anthropic', modelID: 'claude-haiku-4-5' },
-  defaultAgent: 'code',
-  checkpointDir: './ckpt',
-  logDir: './logs',
-}, createBaseState)
+const pipeline = new Pipeline(
+  {
+    name: 'hello-world',
+    defaultModel: { providerID: 'anthropic', modelID: 'claude-haiku-4-5' },
+    defaultAgent: 'code',
+    checkpointDir: './ckpt',
+    logDir: './logs',
+  },
+  createBaseState,
+)
 
 const result = await pipeline.run(module(Greet), { name: 'World' })
-console.log(result.data.greeting)  // "Hello, World! It's wonderful to meet you!"
+console.log(result.data.greeting) // "Hello, World! It's wonderful to meet you!"
 ```
 
-## Install
+### Installation
 
 ```bash
-bun add ocpipe zod
+bun init
+bun add ocpipe
 ```
 
-Requires [Bun](https://bun.sh) and [OpenCode](https://opencode.ai) CLI.
+OpenCode CLI is bundled — run `bun run opencode` or use your system `opencode` if installed (preferred).
+
+See [example/](./example) for a complete example.
 
-## Documentation
+### Documentation
 
 - [Getting Started](./GETTING_STARTED.md) - Tutorial with examples
 - [Design](./DESIGN.md) - Architecture and concepts
 - [Contributing](./CONTRIBUTING.md) - Development setup
 
-## License
+---
 
-[MIT](./LICENSE)
+**Join the OpenCode community** [Discord](https://opencode.ai/discord) | follow on [X.com](https://x.com/opencode)

package/example/ckpt/hello-world_20251227_044217.json

@@ -0,0 +1,27 @@
+{
+  "sessionId": "20251227_044217",
+  "startedAt": "2025-12-27T04:42:17.756Z",
+  "phase": "init",
+  "steps": [
+    {
+      "stepName": "Greeter",
+      "timestamp": "2025-12-27T04:42:22.145Z",
+      "result": {
+        "data": {
+          "greeting": "Hello, World! Welcome!",
+          "emoji": "👋"
+        },
+        "stepName": "Greeter",
+        "duration": 4389,
+        "sessionId": "ses_4a1e2aaceffedog5Q2374azn79",
+        "model": {
+          "providerID": "anthropic",
+          "modelID": "claude-haiku-4-5"
+        },
+        "attempt": 1
+      }
+    }
+  ],
+  "subPipelines": [],
+  "opencodeSessionId": "ses_4a1e2aaceffedog5Q2374azn79"
+}

package/example/correction.ts

@@ -15,7 +15,13 @@
  */
 
 import { z } from 'zod/v4'
-import { Pipeline, createBaseState, signature, field, SignatureModule } from '../src/index.js'
+import {
+  Pipeline,
+  createBaseState,
+  signature,
+  field,
+  SignatureModule,
+} from '../src/index.js'
 import type { CorrectionMethod, ExecutionContext } from '../src/types.js'
 
 // A signature with field names that LLMs often get wrong
@@ -28,9 +34,15 @@ IMPORTANT: Use the EXACT field names specified in the schema.`,
   },
   outputs: {
     // LLMs often return "type" instead of "issue_type"
-    issue_type: field.enum(['bug', 'feature', 'refactor', 'docs'] as const, 'Category of the issue'),
+    issue_type: field.enum(
+      ['bug', 'feature', 'refactor', 'docs'] as const,
+      'Category of the issue',
+    ),
     // LLMs often return "priority" instead of "severity"
-    severity: field.enum(['low', 'medium', 'high', 'critical'] as const, 'How severe is the issue'),
+    severity: field.enum(
+      ['low', 'medium', 'high', 'critical'] as const,
+      'How severe is the issue',
+    ),
     // LLMs often return "description" or "reason" instead of "explanation"
     explanation: field.string('Detailed explanation of the issue'),
     // LLMs often return just "tags" or "labels"
@@ -53,7 +65,8 @@ class IssueAnalyzer extends SignatureModule<typeof AnalyzeIssue> {
 
 async function main() {
   // Check for --jq flag
-  const method: CorrectionMethod = process.argv.includes('--jq') ? 'jq' : 'json-patch'
+  const method: CorrectionMethod =
+    process.argv.includes('--jq') ? 'jq' : 'json-patch'
 
   const pipeline = new Pipeline(
     {
@@ -72,7 +85,8 @@ async function main() {
   console.log('Watch the correction rounds fix schema mismatches.\n')
 
   const result = await pipeline.run(new IssueAnalyzer(method), {
-    description: 'The login button does not respond when clicked on mobile devices',
+    description:
+      'The login button does not respond when clicked on mobile devices',
   })
 
   console.log('\n=== Final Result ===')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocpipe",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "SDK for LLM pipelines with OpenCode and Zod",
   "type": "module",
   "main": "src/index.ts",
@@ -28,15 +28,20 @@
   "engines": {
     "bun": ">=1.0.0"
   },
+  "dependencies": {
+    "opencode-ai": "latest"
+  },
   "peerDependencies": {
     "zod": "^4.0.0"
   },
   "devDependencies": {
     "bun-types": "^1.3.5",
+    "prettier": "^3.7.4",
     "typescript": "^5.0.0",
     "vitest": "^4.0.0"
   },
   "scripts": {
+    "format": "bun run prettier --write .",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",

package/src/agent.ts

@@ -4,11 +4,30 @@
  * Wraps the OpenCode CLI for running LLM agents with session management.
  */
 
-import { spawn } from 'child_process'
+import { spawn, execSync } from 'child_process'
 import { mkdir } from 'fs/promises'
 import { PROJECT_ROOT, TMP_DIR } from './paths.js'
 import type { RunAgentOptions, RunAgentResult } from './types.js'
 
+/** Check if opencode is available in system PATH */
+function hasSystemOpencode(): boolean {
+  try {
+    execSync('which opencode', { stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** Get command and args to invoke opencode */
+function getOpencodeCommand(args: string[]): { cmd: string; args: string[] } {
+  if (hasSystemOpencode()) {
+    return { cmd: 'opencode', args }
+  }
+  // Fallback to bunx with ocpipe package (which has opencode-ai as dependency)
+  return { cmd: 'bunx', args: ['-p', 'ocpipe', 'opencode', ...args] }
+}
+
 /** runAgent executes an OpenCode agent with a prompt, streaming output in real-time. */
 export async function runAgent(
   options: RunAgentOptions,
@@ -23,14 +42,23 @@ export async function runAgent(
     `\n>>> OpenCode [${agent}] [${modelStr}] ${sessionInfo}: ${promptPreview}...`,
   )
 
-  const args = ['run', '--format', 'default', '--agent', agent, '--model', modelStr]
+  const args = [
+    'run',
+    '--format',
+    'default',
+    '--agent',
+    agent,
+    '--model',
+    modelStr,
+  ]
 
   if (sessionId) {
     args.push('--session', sessionId)
   }
 
   return new Promise((resolve, reject) => {
-    const proc = spawn('opencode', args, {
+    const opencodeCmd = getOpencodeCommand(args)
+    const proc = spawn(opencodeCmd.cmd, opencodeCmd.args, {
       cwd: PROJECT_ROOT,
       stdio: ['pipe', 'pipe', 'pipe'],
     })
@@ -116,23 +144,20 @@ async function exportSession(sessionId: string): Promise<string | null> {
 
   try {
     await mkdir(TMP_DIR, { recursive: true })
-    const proc = Bun.spawn(
-      [
-        'opencode',
-        'session',
-        'export',
-        sessionId,
-        '--format',
-        'json',
-        '-o',
-        tmpPath,
-      ],
-      {
-        cwd: PROJECT_ROOT,
-        stdout: 'pipe',
-        stderr: 'pipe',
-      },
-    )
+    const opencodeCmd = getOpencodeCommand([
+      'session',
+      'export',
+      sessionId,
+      '--format',
+      'json',
+      '-o',
+      tmpPath,
+    ])
+    const proc = Bun.spawn([opencodeCmd.cmd, ...opencodeCmd.args], {
+      cwd: PROJECT_ROOT,
+      stdout: 'pipe',
+      stderr: 'pipe',
+    })
 
     await proc.exited
 

package/src/module.ts

@@ -51,12 +51,17 @@ export abstract class SignatureModule<
 }
 
 /** SimpleModule is a SignatureModule that just executes the predictor. */
-class SimpleModule<S extends SignatureDef<any, any>> extends SignatureModule<S> {
+class SimpleModule<
+  S extends SignatureDef<any, any>,
+> extends SignatureModule<S> {
   constructor(sig: S, config?: PredictConfig) {
     super(sig, config)
   }
 
-  async forward(input: InferInputs<S>, ctx: ExecutionContext): Promise<InferOutputs<S>> {
+  async forward(
+    input: InferInputs<S>,
+    ctx: ExecutionContext,
+  ): Promise<InferOutputs<S>> {
     return (await this.predictor.execute(input, ctx)).data
   }
 }

package/src/parsing.ts

@@ -77,7 +77,13 @@ export function tryParseJson<T>(
   if (!jsonStr) {
     return {
       ok: false,
-      errors: [{ path: '', message: 'No JSON found in response', expectedType: 'object' }],
+      errors: [
+        {
+          path: '',
+          message: 'No JSON found in response',
+          expectedType: 'object',
+        },
+      ],
     }
   }
 
@@ -88,7 +94,13 @@ export function tryParseJson<T>(
     const parseErr = e as SyntaxError
     return {
       ok: false,
-      errors: [{ path: '', message: `JSON parse failed: ${parseErr.message}`, expectedType: 'object' }],
+      errors: [
+        {
+          path: '',
+          message: `JSON parse failed: ${parseErr.message}`,
+          expectedType: 'object',
+        },
+      ],
     }
   }
 
@@ -131,9 +143,10 @@ function zodErrorsToFieldErrors(
     let foundValue: unknown
 
     // Check if field is missing (received undefined)
-    const isMissing = issue.code === 'invalid_type' && 
+    const isMissing =
+      issue.code === 'invalid_type' &&
       (issue as { received?: string }).received === 'undefined'
-    
+
     if (isMissing) {
       // Field is missing - look for similar field names in parsed data
       const similar = findSimilarField(fieldName, parsed, schemaKeys)
@@ -187,14 +200,21 @@ function findSimilarField(
   for (const key of extraKeys) {
     const normalizedKey = key.toLowerCase().replace(/_/g, '')
     if (normalizedKey === normalized) return key
-    if (normalizedKey.includes(normalized) || normalized.includes(normalizedKey)) return key
+    if (
+      normalizedKey.includes(normalized) ||
+      normalized.includes(normalizedKey)
+    )
+      return key
   }
 
   return undefined
 }
 
 /** getExpectedType extracts a human-readable type description from a Zod issue. */
-function getExpectedType(issue: z.ZodIssue, schema: Record<string, FieldConfig>): string {
+function getExpectedType(
+  issue: z.ZodIssue,
+  schema: Record<string, FieldConfig>,
+): string {
   const fieldName = issue.path[0] as string
   const fieldConfig = schema[fieldName]
 
@@ -225,7 +245,9 @@ export function zodTypeToString(zodType: z.ZodType): string {
       return `enum[${opts.map((v) => `"${v}"`).join(', ')}]`
     }
     // Fallback to _def
-    const def = (zodType as unknown as { _def?: { values?: readonly string[] } })._def
+    const def = (
+      zodType as unknown as { _def?: { values?: readonly string[] } }
+    )._def
     const values = def?.values ?? []
     if (values.length > 0) {
       return `enum[${values.map((v) => `"${v}"`).join(', ')}]`
@@ -242,7 +264,9 @@ export function zodTypeToString(zodType: z.ZodType): string {
   }
   if (zodType instanceof z.ZodObject) {
     // ZodObject has .shape property
-    const shapeObj = (zodType as unknown as { shape?: Record<string, z.ZodType> }).shape
+    const shapeObj = (
+      zodType as unknown as { shape?: Record<string, z.ZodType> }
+    ).shape
     if (shapeObj) {
       const fields = Object.keys(shapeObj).slice(0, 3).join(', ')
       return `object{${fields}${Object.keys(shapeObj).length > 3 ? ', ...' : ''}}`
@@ -251,14 +275,18 @@ export function zodTypeToString(zodType: z.ZodType): string {
   }
   if (zodType instanceof z.ZodOptional) {
     // ZodOptional has .unwrap() method
-    const unwrapped = (zodType as unknown as { unwrap?: () => z.ZodType }).unwrap?.()
+    const unwrapped = (
+      zodType as unknown as { unwrap?: () => z.ZodType }
+    ).unwrap?.()
     if (unwrapped) {
       return `optional<${zodTypeToString(unwrapped)}>`
     }
     return 'optional'
   }
   if (zodType instanceof z.ZodNullable) {
-    const unwrapped = (zodType as unknown as { unwrap?: () => z.ZodType }).unwrap?.()
+    const unwrapped = (
+      zodType as unknown as { unwrap?: () => z.ZodType }
+    ).unwrap?.()
     if (unwrapped) {
       return `nullable<${zodTypeToString(unwrapped)}>`
     }
@@ -266,7 +294,8 @@ export function zodTypeToString(zodType: z.ZodType): string {
   }
   if (zodType instanceof z.ZodDefault) {
     // ZodDefault wraps inner type
-    const inner = (zodType as unknown as { _def?: { innerType?: z.ZodType } })._def?.innerType
+    const inner = (zodType as unknown as { _def?: { innerType?: z.ZodType } })
+      ._def?.innerType
     if (inner) {
       return `default<${zodTypeToString(inner)}>`
     }
@@ -322,7 +351,9 @@ export function buildPatchPrompt(
   lines.push(`Expected type: ${error.expectedType}`)
 
   if (error.foundField) {
-    lines.push(`Found similar field: "${error.foundField}" with value: ${JSON.stringify(error.foundValue)}`)
+    lines.push(
+      `Found similar field: "${error.foundField}" with value: ${JSON.stringify(error.foundValue)}`,
+    )
   }
 
   lines.push('')
@@ -354,9 +385,13 @@ export function buildBatchPatchPrompt(
   lines.push('ERRORS:')
   for (let i = 0; i < errors.length; i++) {
     const error = errors[i]!
-    lines.push(`${i + 1}. Field "${error.path}": ${error.message} (expected: ${error.expectedType})`)
+    lines.push(
+      `${i + 1}. Field "${error.path}": ${error.message} (expected: ${error.expectedType})`,
+    )
     if (error.foundField) {
-      lines.push(`   Found similar: "${error.foundField}" = ${JSON.stringify(error.foundValue)}`)
+      lines.push(
+        `   Found similar: "${error.foundField}" = ${JSON.stringify(error.foundValue)}`,
+      )
     }
   }
 
@@ -366,7 +401,9 @@ export function buildBatchPatchPrompt(
   lines.push(JSON.stringify(abbreviateJson(currentJson), null, 2))
   lines.push('```')
   lines.push('')
-  lines.push('Respond with jq-style patches to fix ALL errors. Use | to chain multiple patches.')
+  lines.push(
+    'Respond with jq-style patches to fix ALL errors. Use | to chain multiple patches.',
+  )
   lines.push('Examples:')
   lines.push('- .field1 = "value" | .field2 = 123')
   lines.push('- .items[0].name = .items[0].title | del(.items[0].title)')
@@ -378,7 +415,10 @@ export function buildBatchPatchPrompt(
 }
 
 /** abbreviateJson truncates large values for display in prompts. */
-function abbreviateJson(obj: Record<string, unknown>, maxLength = 100): Record<string, unknown> {
+function abbreviateJson(
+  obj: Record<string, unknown>,
+  maxLength = 100,
+): Record<string, unknown> {
   const result: Record<string, unknown> = {}
 
   for (const [key, value] of Object.entries(obj)) {
@@ -401,7 +441,9 @@ function abbreviateJson(obj: Record<string, unknown>, maxLength = 100): Record<s
 }
 
 /** convertNullToUndefined recursively converts null values to undefined (for optional fields). */
-function convertNullToUndefined(obj: Record<string, unknown>): Record<string, unknown> {
+function convertNullToUndefined(
+  obj: Record<string, unknown>,
+): Record<string, unknown> {
   const result: Record<string, unknown> = {}
 
   for (const [key, value] of Object.entries(obj)) {
@@ -441,7 +483,10 @@ export function extractPatch(response: string): string {
   // If no clear patch found, try the whole response (minus markdown)
   const cleaned = response.replace(/```[^`]*```/g, '').trim()
   const firstLine = cleaned.split('\n')[0]?.trim()
-  if (firstLine && (firstLine.startsWith('.') || firstLine.startsWith('del('))) {
+  if (
+    firstLine &&
+    (firstLine.startsWith('.') || firstLine.startsWith('del('))
+  ) {
     return firstLine
   }
 
@@ -475,7 +520,7 @@ export function applyJqPatch(
     /\bdebug\b/,
     /\berror\b/,
     /\bhalt\b/,
-    /\$/,  // Any variable reference (safest to disallow all)
+    /\$/, // Any variable reference (safest to disallow all)
   ]
 
   for (const pattern of unsafePatterns) {
@@ -535,7 +580,9 @@ export function buildJsonPatchPrompt(
   lines.push(`Expected type: ${error.expectedType}`)
 
   if (error.foundField) {
-    lines.push(`Found similar field: "${error.foundField}" with value: ${JSON.stringify(error.foundValue)}`)
+    lines.push(
+      `Found similar field: "${error.foundField}" with value: ${JSON.stringify(error.foundValue)}`,
+    )
   }
 
   lines.push('')
@@ -544,11 +591,17 @@ export function buildJsonPatchPrompt(
   lines.push(JSON.stringify(abbreviateJson(currentJson), null, 2))
   lines.push('```')
   lines.push('')
-  lines.push('Respond with ONLY a JSON Patch array (RFC 6902) to fix this field. Examples:')
+  lines.push(
+    'Respond with ONLY a JSON Patch array (RFC 6902) to fix this field. Examples:',
+  )
   lines.push('- [{"op": "add", "path": "/field_name", "value": "new_value"}]')
   lines.push('- [{"op": "replace", "path": "/field_name", "value": 123}]')
-  lines.push('- [{"op": "move", "from": "/wrong_field", "path": "/correct_field"}]')
-  lines.push('- [{"op": "remove", "path": "/wrong_field"}, {"op": "add", "path": "/correct_field", "value": "..."}]')
+  lines.push(
+    '- [{"op": "move", "from": "/wrong_field", "path": "/correct_field"}]',
+  )
+  lines.push(
+    '- [{"op": "remove", "path": "/wrong_field"}, {"op": "add", "path": "/correct_field", "value": "..."}]',
+  )
   lines.push('')
   lines.push('Your JSON Patch:')
 
@@ -567,9 +620,13 @@ export function buildBatchJsonPatchPrompt(
   lines.push('ERRORS:')
   for (let i = 0; i < errors.length; i++) {
     const error = errors[i]!
-    lines.push(`${i + 1}. Field "${error.path}": ${error.message} (expected: ${error.expectedType})`)
+    lines.push(
+      `${i + 1}. Field "${error.path}": ${error.message} (expected: ${error.expectedType})`,
+    )
     if (error.foundField) {
-      lines.push(`   Found similar: "${error.foundField}" = ${JSON.stringify(error.foundValue)}`)
+      lines.push(
+        `   Found similar: "${error.foundField}" = ${JSON.stringify(error.foundValue)}`,
+      )
     }
   }
 
@@ -579,7 +636,9 @@ export function buildBatchJsonPatchPrompt(
   lines.push(JSON.stringify(abbreviateJson(currentJson), null, 2))
   lines.push('```')
   lines.push('')
-  lines.push('Respond with a JSON Patch array (RFC 6902) to fix ALL errors. Examples:')
+  lines.push(
+    'Respond with a JSON Patch array (RFC 6902) to fix ALL errors. Examples:',
+  )
   lines.push('- [{"op": "move", "from": "/type", "path": "/issue_type"}]')
   lines.push('- [{"op": "replace", "path": "/items/0/name", "value": "fixed"}]')
   lines.push('- [{"op": "add", "path": "/missing_field", "value": "default"}]')
@@ -592,7 +651,9 @@ export function buildBatchJsonPatchPrompt(
 /** extractJsonPatch extracts a JSON Patch array from an LLM response. */
 export function extractJsonPatch(response: string): JsonPatchOperation[] {
   // Try to find JSON array in code blocks first
-  const codeBlockMatch = response.match(/```(?:json)?\s*(\[[\s\S]*?\])[\s\S]*?```/)
+  const codeBlockMatch = response.match(
+    /```(?:json)?\s*(\[[\s\S]*?\])[\s\S]*?```/,
+  )
   if (codeBlockMatch?.[1]) {
     try {
       return JSON.parse(codeBlockMatch[1]) as JsonPatchOperation[]
@@ -619,14 +680,18 @@ export function extractJsonPatch(response: string): JsonPatchOperation[] {
 
     if (endIdx > startIdx) {
       try {
-        return JSON.parse(response.slice(startIdx, endIdx)) as JsonPatchOperation[]
+        return JSON.parse(
+          response.slice(startIdx, endIdx),
+        ) as JsonPatchOperation[]
       } catch {
         // Fall through to empty array
       }
     }
   }
 
-  console.error(`  Could not extract JSON Patch from response: ${response.slice(0, 100)}...`)
+  console.error(
+    `  Could not extract JSON Patch from response: ${response.slice(0, 100)}...`,
+  )
   return []
 }
 
@@ -649,7 +714,7 @@ export function applyJsonPatch(
   for (const op of operations) {
     const path = toJsonPointer(op.path)
     const pathParts = path.split('/').filter(Boolean)
-    
+
     try {
       switch (op.op) {
         case 'add':
@@ -682,20 +747,28 @@ export function applyJsonPatch(
           const srcPath = toJsonPointer(op.from)
           const srcParts = srcPath.split('/').filter(Boolean)
           const srcValue = getValueAtPath(result, srcParts)
-          setValueAtPath(result, pathParts, JSON.parse(JSON.stringify(srcValue)))
+          setValueAtPath(
+            result,
+            pathParts,
+            JSON.parse(JSON.stringify(srcValue)),
+          )
           break
         }
         case 'test': {
           // Test operation - verify value matches, throw if not
           const actualValue = getValueAtPath(result, pathParts)
           if (JSON.stringify(actualValue) !== JSON.stringify(op.value)) {
-            console.error(`  JSON Patch test failed: ${path} expected ${JSON.stringify(op.value)}, got ${JSON.stringify(actualValue)}`)
+            console.error(
+              `  JSON Patch test failed: ${path} expected ${JSON.stringify(op.value)}, got ${JSON.stringify(actualValue)}`,
+            )
           }
           break
         }
       }
     } catch (e) {
-      console.error(`  JSON Patch operation failed: ${JSON.stringify(op)} - ${e}`)
+      console.error(
+        `  JSON Patch operation failed: ${JSON.stringify(op)} - ${e}`,
+      )
     }
   }
 
@@ -703,7 +776,10 @@ export function applyJsonPatch(
 }
 
 /** getValueAtPath retrieves a value at a JSON Pointer path. */
-function getValueAtPath(obj: Record<string, unknown>, parts: string[]): unknown {
+function getValueAtPath(
+  obj: Record<string, unknown>,
+  parts: string[],
+): unknown {
   let current: unknown = obj
   for (const part of parts) {
     if (current === null || current === undefined) return undefined
@@ -720,9 +796,13 @@ function getValueAtPath(obj: Record<string, unknown>, parts: string[]): unknown
 }
 
 /** setValueAtPath sets a value at a JSON Pointer path. */
-function setValueAtPath(obj: Record<string, unknown>, parts: string[], value: unknown): void {
+function setValueAtPath(
+  obj: Record<string, unknown>,
+  parts: string[],
+  value: unknown,
+): void {
   if (parts.length === 0) return
-  
+
   let current: unknown = obj
   for (let i = 0; i < parts.length - 1; i++) {
     const part = parts[i]!
@@ -749,12 +829,15 @@ function setValueAtPath(obj: Record<string, unknown>, parts: string[], value: un
     const idx = parseInt(lastPart, 10)
     current[idx] = value
   } else if (typeof current === 'object' && current !== null) {
-    (current as Record<string, unknown>)[lastPart] = value
+    ;(current as Record<string, unknown>)[lastPart] = value
   }
 }
 
 /** removeValueAtPath removes a value at a JSON Pointer path. */
-function removeValueAtPath(obj: Record<string, unknown>, parts: string[]): void {
+function removeValueAtPath(
+  obj: Record<string, unknown>,
+  parts: string[],
+): void {
   if (parts.length === 0) return
 
   let current: unknown = obj
@@ -805,8 +888,15 @@ export function parseJson<T>(
   const zodResult = zodSchema.safeParse(result.json)
 
   if (!zodResult.success) {
-    const issues = zodResult.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ')
-    throw new ValidationError(`Output validation failed: ${issues}`, response, zodResult.error, errors)
+    const issues = zodResult.error.issues
+      .map((i) => `${i.path.join('.')}: ${i.message}`)
+      .join('; ')
+    throw new ValidationError(
+      `Output validation failed: ${issues}`,
+      response,
+      zodResult.error,
+      errors,
+    )
   }
 
   // Shouldn't reach here

package/src/pipeline.ts

@@ -58,7 +58,8 @@ export class Pipeline<S extends BaseState> {
 
     const startTime = Date.now()
     let lastError: Error | undefined
-    const retryConfig = options?.retry ?? this.config.retry ?? { maxAttempts: 1 }
+    const retryConfig = options?.retry ??
+      this.config.retry ?? { maxAttempts: 1 }
 
     for (let attempt = 1; attempt <= retryConfig.maxAttempts; attempt++) {
       try {
@@ -176,7 +177,7 @@ export class Pipeline<S extends BaseState> {
     sessionId: string,
   ): Promise<Pipeline<S> | null> {
     const path = `${config.checkpointDir}/${config.name}_${sessionId}.json`
-    
+
     try {
       const content = await readFile(path, 'utf-8')
       const state = JSON.parse(content) as S

package/src/predict.ts

@@ -90,7 +90,11 @@ export class Predict<S extends SignatureDef<any, any>> {
     }
 
     // Parsing failed - attempt correction if enabled
-    if (this.config.correction !== false && parseResult.errors && parseResult.json) {
+    if (
+      this.config.correction !== false &&
+      parseResult.errors &&
+      parseResult.json
+    ) {
       const corrected = await this.correctFields(
         parseResult.json,
         parseResult.errors,
@@ -111,9 +115,19 @@ export class Predict<S extends SignatureDef<any, any>> {
 
     // Correction failed or disabled - throw SchemaValidationError (non-retryable)
     const errors = parseResult.errors ?? []
-    const errorMessages = errors.map((e) => `${e.path}: ${e.message}`).join('; ') || 'Unknown error'
-    const correctionAttempts = this.config.correction !== false ? (typeof this.config.correction === 'object' ? this.config.correction.maxRounds ?? 3 : 3) : 0
-    throw new SchemaValidationError(`Schema validation failed: ${errorMessages}`, errors, correctionAttempts)
+    const errorMessages =
+      errors.map((e) => `${e.path}: ${e.message}`).join('; ') || 'Unknown error'
+    const correctionAttempts =
+      this.config.correction !== false ?
+        typeof this.config.correction === 'object' ?
+          (this.config.correction.maxRounds ?? 3)
+        : 3
+      : 0
+    throw new SchemaValidationError(
+      `Schema validation failed: ${errorMessages}`,
+      errors,
+      correctionAttempts,
+    )
   }
 
   /** correctFields attempts to fix field errors using same-session patches with retries. */
@@ -123,32 +137,39 @@ export class Predict<S extends SignatureDef<any, any>> {
     ctx: ExecutionContext,
     sessionId: string,
   ): Promise<InferOutputs<S> | null> {
-    const correctionConfig = typeof this.config.correction === 'object' ? this.config.correction : {}
+    const correctionConfig =
+      typeof this.config.correction === 'object' ? this.config.correction : {}
     const method: CorrectionMethod = correctionConfig.method ?? 'json-patch'
     const maxFields = correctionConfig.maxFields ?? 5
     const maxRounds = correctionConfig.maxRounds ?? 3
     const correctionModel = correctionConfig.model
 
-    let currentJson = JSON.parse(JSON.stringify(json)) as Record<string, unknown>
+    let currentJson = JSON.parse(JSON.stringify(json)) as Record<
+      string,
+      unknown
+    >
     let currentErrors = initialErrors
 
     for (let round = 1; round <= maxRounds; round++) {
       const errorsToFix = currentErrors.slice(0, maxFields)
-      
+
       if (errorsToFix.length === 0) {
         break
       }
 
-      console.error(`\n>>> Correction round ${round}/${maxRounds} [${method}]: fixing ${errorsToFix.length} field(s)...`)
+      console.error(
+        `\n>>> Correction round ${round}/${maxRounds} [${method}]: fixing ${errorsToFix.length} field(s)...`,
+      )
 
       // Build prompt based on correction method
-      const patchPrompt = method === 'jq'
-        ? (errorsToFix.length === 1
-            ? buildPatchPrompt(errorsToFix[0]!, currentJson, this.sig.outputs)
-            : buildBatchPatchPrompt(errorsToFix, currentJson))
-        : (errorsToFix.length === 1
-            ? buildJsonPatchPrompt(errorsToFix[0]!, currentJson, this.sig.outputs)
-            : buildBatchJsonPatchPrompt(errorsToFix, currentJson))
+      const patchPrompt =
+        method === 'jq' ?
+          errorsToFix.length === 1 ?
+            buildPatchPrompt(errorsToFix[0]!, currentJson, this.sig.outputs)
+          : buildBatchPatchPrompt(errorsToFix, currentJson)
+        : errorsToFix.length === 1 ?
+          buildJsonPatchPrompt(errorsToFix[0]!, currentJson, this.sig.outputs)
+        : buildBatchJsonPatchPrompt(errorsToFix, currentJson)
 
       // Use same session (model has context) unless correction model specified
       const patchResult = await runAgent({
@@ -183,14 +204,16 @@ export class Predict<S extends SignatureDef<any, any>> {
 
       // Update errors for next round
       currentErrors = revalidated.errors ?? []
-      
+
       if (currentErrors.length === 0) {
         // No errors but also no data? Shouldn't happen, but handle gracefully
         console.error(`  Unexpected state: no errors but validation failed`)
         break
       }
 
-      console.error(`  Round ${round} complete, ${currentErrors.length} error(s) remaining`)
+      console.error(
+        `  Round ${round} complete, ${currentErrors.length} error(s) remaining`,
+      )
     }
 
     console.error(`  Schema correction failed after ${maxRounds} rounds`)
@@ -231,7 +254,9 @@ export class Predict<S extends SignatureDef<any, any>> {
     // Output format with JSON Schema
     lines.push('OUTPUT FORMAT:')
     lines.push('Return a JSON object matching this schema EXACTLY.')
-    lines.push('IMPORTANT: For optional fields, OMIT the field entirely - do NOT use null.')
+    lines.push(
+      'IMPORTANT: For optional fields, OMIT the field entirely - do NOT use null.',
+    )
     lines.push('')
     lines.push('```json')
     lines.push(JSON.stringify(this.buildOutputJsonSchema(), null, 2))
@@ -244,7 +269,10 @@ export class Predict<S extends SignatureDef<any, any>> {
   private buildOutputJsonSchema(): Record<string, unknown> {
     // Build a Zod object from the output fields
     const shape: Record<string, z.ZodType> = {}
-    for (const [name, config] of Object.entries(this.sig.outputs) as [string, FieldConfig][]) {
+    for (const [name, config] of Object.entries(this.sig.outputs) as [
+      string,
+      FieldConfig,
+    ][]) {
       shape[name] = config.type
     }
     const outputSchema = z.object(shape)
@@ -254,9 +282,14 @@ export class Predict<S extends SignatureDef<any, any>> {
 
     // Add field descriptions from our config (toJSONSchema uses .describe() metadata)
     // Since our FieldConfig has a separate desc field, merge it in
-    const props = jsonSchema.properties as Record<string, Record<string, unknown>> | undefined
+    const props = jsonSchema.properties as
+      | Record<string, Record<string, unknown>>
+      | undefined
     if (props) {
-      for (const [name, config] of Object.entries(this.sig.outputs) as [string, FieldConfig][]) {
+      for (const [name, config] of Object.entries(this.sig.outputs) as [
+        string,
+        FieldConfig,
+      ][]) {
         if (config.desc && props[name]) {
           // Only add if not already set by .describe()
           if (!props[name].description) {

package/src/testing.ts

@@ -34,7 +34,10 @@ export class MockAgentBackend {
   }
 
   /** addJsonResponse adds a mock JSON response. */
-  addJsonResponse(data: Record<string, unknown>, options?: Partial<MockResponse>): this {
+  addJsonResponse(
+    data: Record<string, unknown>,
+    options?: Partial<MockResponse>,
+  ): this {
     return this.addResponse({
       response: JSON.stringify(data, null, 2),
       ...options,
@@ -76,7 +79,7 @@ export class MockAgentBackend {
     for (let i = 0; i < this.responses.length; i++) {
       const r = this.responses[i]
       if (!r) continue
-      
+
       if (!r.match) {
         response = r
         responseIndex = i
@@ -116,7 +119,8 @@ export class MockAgentBackend {
 
     return {
       text: response.response ?? '',
-      sessionId: response.sessionId ?? options.sessionId ?? this.defaultSessionId,
+      sessionId:
+        response.sessionId ?? options.sessionId ?? this.defaultSessionId,
     }
   }
 
@@ -127,12 +131,14 @@ export class MockAgentBackend {
 }
 
 /** createMockContext creates a test execution context. */
-export function createMockContext(overrides?: Partial<{
-  sessionId: string
-  defaultModel: { providerID: string; modelID: string }
-  defaultAgent: string
-  timeoutSec: number
-}>) {
+export function createMockContext(
+  overrides?: Partial<{
+    sessionId: string
+    defaultModel: { providerID: string; modelID: string }
+    defaultAgent: string
+    timeoutSec: number
+  }>,
+) {
   return {
     sessionId: overrides?.sessionId,
     defaultModel: overrides?.defaultModel ?? {
@@ -145,12 +151,14 @@ export function createMockContext(overrides?: Partial<{
 }
 
 /** generateMockOutputs creates mock output data based on a schema. */
-export function generateMockOutputs(schema: Record<string, FieldConfig>): Record<string, unknown> {
+export function generateMockOutputs(
+  schema: Record<string, FieldConfig>,
+): Record<string, unknown> {
   const result: Record<string, unknown> = {}
   for (const [name, config] of Object.entries(schema)) {
     // Use constructor name for type detection (works across zod versions)
     const typeName = config.type.constructor.name
-    
+
     switch (typeName) {
       case 'ZodString':
         result[name] = `mock_${name}`

package/src/types.ts

@@ -132,15 +132,15 @@ export interface SignatureDef<
 
 /** Infer the input type from a signature definition. */
 export type InferInputs<S extends SignatureDef<any, any>> =
-  S extends SignatureDef<infer I, any>
-    ? { [K in keyof I]: z.infer<I[K]['type']> }
-    : never
+  S extends SignatureDef<infer I, any> ?
+    { [K in keyof I]: z.infer<I[K]['type']> }
+  : never
 
 /** Infer the output type from a signature definition. */
 export type InferOutputs<S extends SignatureDef<any, any>> =
-  S extends SignatureDef<any, infer O>
-    ? { [K in keyof O]: z.infer<O[K]['type']> }
-    : never
+  S extends SignatureDef<any, infer O> ?
+    { [K in keyof O]: z.infer<O[K]['type']> }
+  : never
 
 // ============================================================================
 // Retry Configuration