ocpipe 0.3.1 → 0.3.2

package/DESIGN.md

@@ -45,6 +45,20 @@ const AnalyzeCode = signature({
 - `field.nullable(field)` - Nullable wrapper
 - `field.custom(zodType, desc?)` - Custom Zod type
 
+**Type inference:**
+
+Use `InferInputs<S>` and `InferOutputs<S>` to extract TypeScript types from a signature:
+
+```typescript
+import { InferInputs, InferOutputs } from 'ocpipe'
+
+type AnalyzeInputs = InferInputs<typeof AnalyzeCode>
+// { code: string; language: 'typescript' | 'python' | 'rust' }
+
+type AnalyzeOutputs = InferOutputs<typeof AnalyzeCode>
+// { issues: { severity: 'error' | 'warning' | 'info'; message: string; line: number }[]; suggestions: string[]; score: number }
+```
+
 ### Predict
 
 `Predict` bridges a Signature and OpenCode. It handles prompt generation, response parsing, and validation.

package/GETTING_STARTED.md

@@ -355,6 +355,31 @@ field.enum(['a', 'b'] as const) // 'a' | 'b'
 field.optional(field.string()) // string | undefined
 ```
 
+### Type Inference
+
+Use `InferInputs` and `InferOutputs` to extract TypeScript types from a signature:
+
+```typescript
+import { signature, field, InferInputs, InferOutputs } from 'ocpipe'
+
+const Greet = signature({
+  doc: 'Generate a greeting.',
+  inputs: { name: field.string('Name to greet') },
+  outputs: { greeting: field.string('The greeting message') },
+})
+
+// Extract types from the signature
+type GreetInputs = InferInputs<typeof Greet> // { name: string }
+type GreetOutputs = InferOutputs<typeof Greet> // { greeting: string }
+
+// Use in functions
+function processGreeting(input: GreetInputs): void {
+  console.log(`Processing greeting for: ${input.name}`)
+}
+```
+
+This is useful for typing function parameters, return types, or when building generic utilities around signatures.
+
 ### Complex Modules
 
 For modules with multiple predictors or transformed outputs, use the base `Module` class:

package/README.md

@@ -40,6 +40,11 @@ const pipeline = new Pipeline(
 
 const result = await pipeline.run(module(Greet), { name: 'World' })
 console.log(result.data.greeting)
+
+// Extract types from signatures
+import { InferInputs, InferOutputs } from 'ocpipe'
+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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocpipe",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "SDK for LLM pipelines with OpenCode and Zod",
   "type": "module",
   "main": "src/index.ts",

package/src/.tmp/ocpipe-integration-test/mood-analysis_20251231_092022.json

@@ -0,0 +1,55 @@
+{
+  "sessionId": "20251231_092022",
+  "startedAt": "2025-12-31T09:20:22.199Z",
+  "phase": "init",
+  "steps": [
+    {
+      "stepName": "MoodAnalyzer",
+      "timestamp": "2025-12-31T09:20:25.808Z",
+      "result": {
+        "data": {
+          "mood": "happy",
+          "keywords": [
+            "happy",
+            "so",
+            "today"
+          ]
+        },
+        "stepName": "MoodAnalyzer",
+        "duration": 3608,
+        "sessionId": "ses_48c4aa762ffeP1pxFsOURK4cw2",
+        "model": {
+          "providerID": "github-copilot",
+          "modelID": "grok-code-fast-1"
+        },
+        "attempt": 1
+      }
+    },
+    {
+      "stepName": "ResponseSuggester",
+      "timestamp": "2025-12-31T09:20:30.186Z",
+      "result": {
+        "data": {
+          "suggestion": "That's wonderful! What's making you so happy today?"
+        },
+        "stepName": "ResponseSuggester",
+        "duration": 4377,
+        "sessionId": "ses_48c4aa762ffeP1pxFsOURK4cw2",
+        "model": {
+          "providerID": "github-copilot",
+          "modelID": "grok-code-fast-1"
+        },
+        "attempt": 1
+      }
+    }
+  ],
+  "subPipelines": [],
+  "inputText": "I am so happy today!",
+  "opencodeSessionId": "ses_48c4aa762ffeP1pxFsOURK4cw2",
+  "mood": "happy",
+  "keywords": [
+    "happy",
+    "so",
+    "today"
+  ]
+}

package/src/parsing.ts

@@ -79,6 +79,7 @@ export function tryParseJson<T>(
       ok: false,
       errors: [
         {
+          code: 'no_json_found',
           path: '',
           message: 'No JSON found in response',
           expectedType: 'object',
@@ -96,6 +97,7 @@ export function tryParseJson<T>(
       ok: false,
       errors: [
         {
+          code: 'json_parse_failed',
           path: '',
           message: `JSON parse failed: ${parseErr.message}`,
           expectedType: 'object',
@@ -157,6 +159,7 @@ function zodErrorsToFieldErrors(
     }
 
     errors.push({
+      code: 'schema_validation_failed',
       path,
       message: issue.message,
       expectedType,
@@ -1060,3 +1063,41 @@ export function parseJsonFromResponse<T = Record<string, unknown>>(
     response,
   )
 }
+
+/** buildJsonRepairPrompt creates a prompt asking the model to fix malformed JSON. */
+export function buildJsonRepairPrompt(
+  malformedJson: string,
+  errorMessage: string,
+  schema: Record<string, FieldConfig>,
+): string {
+  const lines: string[] = []
+
+  lines.push(
+    'Your previous JSON output has a syntax error and cannot be parsed.',
+  )
+  lines.push('')
+  lines.push(`Error: ${errorMessage}`)
+  lines.push('')
+  lines.push('The malformed JSON (may be truncated):')
+  lines.push('```')
+  lines.push(malformedJson.slice(0, 2000))
+  if (malformedJson.length > 2000) {
+    lines.push('... (truncated)')
+  }
+  lines.push('```')
+  lines.push('')
+  lines.push('Please output the COMPLETE, VALID JSON that matches this schema:')
+  lines.push('```json')
+
+  // Build a simple schema description
+  const schemaDesc: Record<string, string> = {}
+  for (const [name, config] of Object.entries(schema)) {
+    schemaDesc[name] = config.desc ?? zodTypeToString(config.type)
+  }
+  lines.push(JSON.stringify(schemaDesc, null, 2))
+  lines.push('```')
+  lines.push('')
+  lines.push('Respond with ONLY the corrected JSON object, no explanation.')
+
+  return lines.join('\n')
+}

package/src/predict.ts

@@ -20,6 +20,8 @@ import type {
 import { runAgent } from './agent.js'
 import {
   tryParseResponse,
+  extractJsonString,
+  buildJsonRepairPrompt,
   // jq-style patches
   buildPatchPrompt,
   buildBatchPatchPrompt,
@@ -78,7 +80,7 @@ export class Predict<S extends AnySignature> {
     // Update context with new session ID for continuity
     ctx.sessionId = agentResult.sessionId
 
-    const parseResult = tryParseResponse<InferOutputs<S>>(
+    let parseResult = tryParseResponse<InferOutputs<S>>(
       agentResult.text,
       this.sig.outputs,
     )
@@ -94,7 +96,42 @@ export class Predict<S extends AnySignature> {
       }
     }
 
-    // Parsing failed - attempt correction if enabled
+    // Check if this is a JSON parse error (malformed JSON, not schema validation)
+    const isJsonParseError =
+      parseResult.errors?.some(
+        (e) => e.code === 'json_parse_failed' || e.code === 'no_json_found',
+      ) ?? false
+
+    // Attempt JSON repair if enabled and we have a parse error
+    if (this.config.correction !== false && isJsonParseError) {
+      const rawJson = extractJsonString(agentResult.text)
+      const repairedResult = await this.repairJson(
+        rawJson ?? agentResult.text,
+        parseResult.errors?.[0]?.message ?? 'JSON parse failed',
+        ctx,
+        agentResult.sessionId,
+      )
+
+      if (repairedResult) {
+        // Re-parse the repaired response
+        parseResult = tryParseResponse<InferOutputs<S>>(
+          repairedResult,
+          this.sig.outputs,
+        )
+
+        if (parseResult.ok && parseResult.data) {
+          return {
+            data: parseResult.data,
+            raw: agentResult.text,
+            sessionId: agentResult.sessionId,
+            duration: Date.now() - startTime,
+            model: this.config.model ?? ctx.defaultModel,
+          }
+        }
+      }
+    }
+
+    // Parsing failed - attempt field correction if enabled and we have parsed JSON
     if (
       this.config.correction !== false &&
       parseResult.errors &&
@@ -135,6 +172,62 @@ export class Predict<S extends AnySignature> {
     )
   }
 
+  /** repairJson asks the model to fix malformed JSON. */
+  private async repairJson(
+    malformedJson: string,
+    errorMessage: string,
+    ctx: ExecutionContext,
+    sessionId: string,
+  ): Promise<string | null> {
+    const correctionConfig =
+      typeof this.config.correction === 'object' ? this.config.correction : {}
+    const maxRounds = correctionConfig.maxRounds ?? 3
+    const correctionModel = correctionConfig.model
+
+    for (let round = 1; round <= maxRounds; round++) {
+      console.error(
+        `\n>>> JSON repair round ${round}/${maxRounds}: fixing malformed JSON...`,
+      )
+
+      const repairPrompt = buildJsonRepairPrompt(
+        malformedJson,
+        errorMessage,
+        this.sig.outputs,
+      )
+
+      // Use same session so the model has context of what it was trying to output
+      const repairResult = await runAgent({
+        prompt: repairPrompt,
+        model: correctionModel ?? ctx.defaultModel,
+        sessionId: correctionModel ? undefined : sessionId,
+        agent: ctx.defaultAgent,
+        timeoutSec: 60,
+      })
+
+      // Try to parse the repaired JSON
+      const repairedJson = extractJsonString(repairResult.text)
+      if (repairedJson) {
+        try {
+          JSON.parse(repairedJson)
+          console.error(`  JSON repair successful after ${round} round(s)!`)
+          return repairedJson
+        } catch (e) {
+          const parseErr = e as SyntaxError
+          console.error(`  Repair attempt ${round} failed: ${parseErr.message}`)
+          malformedJson = repairedJson
+          errorMessage = parseErr.message
+        }
+      } else {
+        console.error(
+          `  Repair attempt ${round} failed: no JSON found in response`,
+        )
+      }
+    }
+
+    console.error(`  JSON repair failed after ${maxRounds} rounds`)
+    return null
+  }
+
   /** correctFields attempts to fix field errors using same-session patches with retries. */
   private async correctFields(
     json: Record<string, unknown>,

package/src/types.ts

@@ -173,7 +173,12 @@ export type CorrectionMethod = 'json-patch' | 'jq'
 export interface CorrectionConfig {
   /** Correction method to use (default: 'json-patch'). */
   method?: CorrectionMethod
-  /** Use a different model for corrections (default: same model, same session). */
+  /**
+   * Use a different model for corrections.
+   * When specified, the correction runs in a new session (no context from the original model).
+   * When not specified, corrections reuse the original session so the model has context
+   * of what it was trying to output.
+   */
   model?: ModelConfig
   /** Maximum number of fields to attempt correcting per round (default: 5). */
   maxFields?: number
@@ -181,8 +186,16 @@ export interface CorrectionConfig {
   maxRounds?: number
 }
 
+/** Error codes for field errors, enabling robust error type detection. */
+export type FieldErrorCode =
+  | 'json_parse_failed'
+  | 'no_json_found'
+  | 'schema_validation_failed'
+
 /** A field-level error from schema validation. */
 export interface FieldError {
+  /** Error code for programmatic detection. */
+  code: FieldErrorCode
   /** The field path that failed (e.g., "issues.0.issue_type"). */
   path: string
   /** Human-readable error message. */