ocpipe 0.3.0 → 0.3.2

package/src/parsing.ts

@@ -1,5 +1,5 @@
 /**
- * DSTS SDK response parsing.
+ * ocpipe response parsing.
  *
  * Extracts and validates LLM responses using JSON or field marker formats.
  */
@@ -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,
@@ -507,13 +510,13 @@ export function applyJqPatch(
     /\binput\b/,
     /\binputs\b/,
     /\bsystem\b/,
-    /\@base64d/,
-    /\@uri/,
-    /\@csv/,
-    /\@tsv/,
-    /\@json/,
-    /\@text/,
-    /\@sh/,
+    /@base64d/,
+    /@uri/,
+    /@csv/,
+    /@tsv/,
+    /@json/,
+    /@text/,
+    /@sh/,
     /`[^`]*`/, // Backtick string interpolation
     /\bimport\b/,
     /\binclude\b/,
@@ -532,7 +535,7 @@ export function applyJqPatch(
 
   // Only allow patches that look like field operations
   // Valid: .foo = "bar", .items[0].name = .items[0].title, del(.foo) | .bar = 1
-  const safePattern = /^[\s\w\[\]."'=|,:\-{}]*$/
+  const safePattern = /^[\s\w[\]."'=|,:\-{}]*$/
   if (!safePattern.test(patch)) {
     console.error(`  Invalid characters in patch, skipping: ${patch}`)
     return obj
@@ -648,44 +651,63 @@ export function buildBatchJsonPatchPrompt(
   return lines.join('\n')
 }
 
-/** 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]*?```/,
-  )
-  if (codeBlockMatch?.[1]) {
-    try {
-      return JSON.parse(codeBlockMatch[1]) as JsonPatchOperation[]
-    } catch {
-      // Continue to try other methods
+/**
+ * extractBalancedArray extracts a balanced JSON array from a string starting at startIdx.
+ * Returns the array substring or null if not found/unbalanced.
+ */
+function extractBalancedArray(text: string, startIdx: number): string | null {
+  if (startIdx === -1 || startIdx >= text.length) return null
+
+  let bracketCount = 0
+  let endIdx = startIdx
+  for (let i = startIdx; i < text.length; i++) {
+    if (text[i] === '[') bracketCount++
+    else if (text[i] === ']') {
+      bracketCount--
+      if (bracketCount === 0) {
+        endIdx = i + 1
+        break
+      }
     }
   }
 
-  // Try to find raw JSON array by counting brackets
-  const startIdx = response.indexOf('[')
-  if (startIdx !== -1) {
-    let bracketCount = 0
-    let endIdx = startIdx
-    for (let i = startIdx; i < response.length; i++) {
-      if (response[i] === '[') bracketCount++
-      else if (response[i] === ']') {
-        bracketCount--
-        if (bracketCount === 0) {
-          endIdx = i + 1
-          break
+  if (endIdx > startIdx && bracketCount === 0) {
+    return text.slice(startIdx, endIdx)
+  }
+  return null
+}
+
+/** 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
+  // Use indexOf to find code block boundaries to avoid ReDoS vulnerabilities
+  const codeBlockStart = response.indexOf('```')
+  if (codeBlockStart !== -1) {
+    const codeBlockEnd = response.indexOf('```', codeBlockStart + 3)
+    if (codeBlockEnd !== -1) {
+      const codeBlockContent = response.slice(codeBlockStart + 3, codeBlockEnd)
+      // Skip optional "json" language identifier and whitespace
+      const arrayStart = codeBlockContent.indexOf('[')
+      if (arrayStart !== -1) {
+        const arrayJson = extractBalancedArray(codeBlockContent, arrayStart)
+        if (arrayJson) {
+          try {
+            return JSON.parse(arrayJson) as JsonPatchOperation[]
+          } catch {
+            // Continue to try other methods
+          }
         }
       }
     }
+  }
 
-    if (endIdx > startIdx) {
-      try {
-        return JSON.parse(
-          response.slice(startIdx, endIdx),
-        ) as JsonPatchOperation[]
-      } catch {
-        // Fall through to empty array
-      }
+  // Try to find raw JSON array by counting brackets
+  const arrayJson = extractBalancedArray(response, response.indexOf('['))
+  if (arrayJson) {
+    try {
+      return JSON.parse(arrayJson) as JsonPatchOperation[]
+    } catch {
+      // Fall through to empty array
     }
   }
 
@@ -775,6 +797,37 @@ export function applyJsonPatch(
   return result
 }
 
+/** Keys that could be used for prototype pollution attacks. */
+const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype'])
+
+function isUnsafeKey(key: string): boolean {
+  return UNSAFE_KEYS.has(key)
+}
+
+/**
+ * Unescape a single JSON Pointer path segment according to RFC 6901.
+ * This ensures that checks for dangerous keys are applied to the
+ * effective property name, not the escaped form.
+ */
+function unescapeJsonPointerSegment(segment: string): string {
+  return segment.replace(/~1/g, '/').replace(/~0/g, '~')
+}
+
+/**
+ * isSafePathSegment determines whether a JSON Pointer path segment is safe to use
+ * as a property key on an object. It rejects keys that are known to enable
+ * prototype pollution or that contain characters commonly used in special
+ * property notations.
+ */
+function isSafePathSegment(segment: string): boolean {
+  // Normalize the segment as it will appear as a property key.
+  const normalized = unescapeJsonPointerSegment(String(segment))
+  if (isUnsafeKey(normalized)) return false
+  // Disallow bracket notation-style segments to avoid unexpected coercions.
+  if (normalized.includes('[') || normalized.includes(']')) return false
+  return true
+}
+
 /** getValueAtPath retrieves a value at a JSON Pointer path. */
 function getValueAtPath(
   obj: Record<string, unknown>,
@@ -782,6 +835,15 @@ function getValueAtPath(
 ): unknown {
   let current: unknown = obj
   for (const part of parts) {
+    // Block prototype-pollution: reject __proto__, constructor, prototype
+    if (
+      part === '__proto__' ||
+      part === 'constructor' ||
+      part === 'prototype'
+    ) {
+      return undefined
+    }
+    if (!isSafePathSegment(part)) return undefined
     if (current === null || current === undefined) return undefined
     if (Array.isArray(current)) {
       const idx = parseInt(part, 10)
@@ -806,25 +868,49 @@ function setValueAtPath(
   let current: unknown = obj
   for (let i = 0; i < parts.length - 1; i++) {
     const part = parts[i]!
+    // Block prototype-pollution: reject __proto__, constructor, prototype
+    if (
+      part === '__proto__' ||
+      part === 'constructor' ||
+      part === 'prototype'
+    ) {
+      return
+    }
+    if (!isSafePathSegment(part)) {
+      // Avoid writing to dangerous or malformed prototype-related properties
+      return
+    }
     if (Array.isArray(current)) {
       const idx = parseInt(part, 10)
       if (current[idx] === undefined) {
         // Create intermediate object or array
         const nextPart = parts[i + 1]!
-        current[idx] = /^\d+$/.test(nextPart) ? [] : {}
+        current[idx] = /^\d+$/.test(nextPart) ? [] : Object.create(null)
       }
       current = current[idx]
     } else if (typeof current === 'object' && current !== null) {
       const rec = current as Record<string, unknown>
       if (rec[part] === undefined) {
         const nextPart = parts[i + 1]!
-        rec[part] = /^\d+$/.test(nextPart) ? [] : {}
+        rec[part] = /^\d+$/.test(nextPart) ? [] : Object.create(null)
       }
       current = rec[part]
     }
   }
 
   const lastPart = parts[parts.length - 1]!
+  // Block prototype-pollution: reject __proto__, constructor, prototype
+  if (
+    lastPart === '__proto__' ||
+    lastPart === 'constructor' ||
+    lastPart === 'prototype'
+  ) {
+    return
+  }
+  if (!isSafePathSegment(lastPart)) {
+    // Avoid writing to dangerous or malformed prototype-related properties
+    return
+  }
   if (Array.isArray(current)) {
     const idx = parseInt(lastPart, 10)
     current[idx] = value
@@ -843,6 +929,18 @@ function removeValueAtPath(
   let current: unknown = obj
   for (let i = 0; i < parts.length - 1; i++) {
     const part = parts[i]!
+    // Block prototype-pollution: reject __proto__, constructor, prototype
+    if (
+      part === '__proto__' ||
+      part === 'constructor' ||
+      part === 'prototype'
+    ) {
+      return
+    }
+    if (!isSafePathSegment(part)) {
+      // Avoid accessing dangerous prototype-related properties
+      return
+    }
     if (Array.isArray(current)) {
       current = current[parseInt(part, 10)]
     } else if (typeof current === 'object' && current !== null) {
@@ -853,6 +951,18 @@ function removeValueAtPath(
   }
 
   const lastPart = parts[parts.length - 1]!
+  // Block prototype-pollution: reject __proto__, constructor, prototype
+  if (
+    lastPart === '__proto__' ||
+    lastPart === 'constructor' ||
+    lastPart === 'prototype'
+  ) {
+    return
+  }
+  if (!isSafePathSegment(lastPart)) {
+    // Avoid deleting dangerous or malformed properties
+    return
+  }
   if (Array.isArray(current)) {
     const idx = parseInt(lastPart, 10)
     current.splice(idx, 1)
@@ -953,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/pipeline.ts

@@ -1,5 +1,5 @@
 /**
- * DSTS SDK Pipeline orchestrator.
+ * ocpipe Pipeline orchestrator.
  *
  * Manages execution context, state, checkpointing, logging, retry logic, and sub-pipelines.
  */

package/src/predict.ts

@@ -1,5 +1,5 @@
 /**
- * DSTS SDK Predict class.
+ * ocpipe Predict class.
  *
  * Executes a signature by generating a prompt, calling OpenCode, and parsing the response.
  */
@@ -20,6 +20,8 @@ import type {
 import { runAgent } from './agent.js'
 import {
   tryParseResponse,
+  extractJsonString,
+  buildJsonRepairPrompt,
   // jq-style patches
   buildPatchPrompt,
   buildBatchPatchPrompt,
@@ -47,8 +49,13 @@ export interface PredictConfig {
   correction?: CorrectionConfig | false
 }
 
+type AnySignature = SignatureDef<
+  Record<string, FieldConfig>,
+  Record<string, FieldConfig>
+>
+
 /** Predict executes a signature by calling an LLM and parsing the response. */
-export class Predict<S extends SignatureDef<any, any>> {
+export class Predict<S extends AnySignature> {
   constructor(
     public readonly sig: S,
     public readonly config: PredictConfig = {},
@@ -73,7 +80,7 @@ export class Predict<S extends SignatureDef<any, any>> {
     // 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,
     )
@@ -89,7 +96,42 @@ export class Predict<S extends SignatureDef<any, any>> {
       }
     }
 
-    // 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 &&
@@ -130,6 +172,62 @@ export class Predict<S extends SignatureDef<any, any>> {
     )
   }
 
+  /** 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>,
@@ -239,7 +337,7 @@ export class Predict<S extends SignatureDef<any, any>> {
 
     // Input fields as JSON
     const inputsWithDescriptions: Record<string, unknown> = {}
-    for (const [name, config] of Object.entries(this.sig.inputs) as [
+    for (const [name] of Object.entries(this.sig.inputs) as [
       string,
       FieldConfig,
     ][]) {

package/src/signature.ts

@@ -1,5 +1,5 @@
 /**
- * DSTS SDK signature definition.
+ * ocpipe signature definition.
  *
  * Signatures declare input/output contracts for LLM interactions using Zod for validation.
  */

package/src/state.ts

@@ -1,5 +1,5 @@
 /**
- * DSTS SDK state management.
+ * ocpipe state management.
  *
  * Provides base state types and helpers for checkpointable workflow state.
  */

package/src/testing.ts

@@ -1,7 +1,7 @@
 /**
- * DSTS SDK testing utilities.
+ * ocpipe testing utilities.
  *
- * Provides mock backends and test helpers for unit testing DSTS components.
+ * Provides mock backends and test helpers for unit testing ocpipe components.
  */
 
 import type { RunAgentOptions, RunAgentResult, FieldConfig } from './types.js'
@@ -175,11 +175,12 @@ export function generateMockOutputs(
       case 'ZodObject':
         result[name] = {}
         break
-      case 'ZodEnum':
+      case 'ZodEnum': {
         // Get first enum value via options property
         const enumType = config.type as { options?: readonly string[] }
         result[name] = enumType.options?.[0] ?? 'unknown'
         break
+      }
       default:
         result[name] = null
     }

package/src/types.ts

@@ -1,7 +1,5 @@
 /**
- * DSTS SDK shared types.
- *
- * Core type definitions for the Declarative Self-Improving TypeScript SDK.
+ * ocpipe shared types.
  */
 
 import type { z } from 'zod/v4'
@@ -131,14 +129,24 @@ 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> ?
+export type InferInputs<
+  S extends SignatureDef<
+    Record<string, FieldConfig>,
+    Record<string, FieldConfig>
+  >,
+> =
+  S extends SignatureDef<infer I, Record<string, FieldConfig>> ?
     { [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> ?
+export type InferOutputs<
+  S extends SignatureDef<
+    Record<string, FieldConfig>,
+    Record<string, FieldConfig>
+  >,
+> =
+  S extends SignatureDef<Record<string, FieldConfig>, infer O> ?
     { [K in keyof O]: z.infer<O[K]['type']> }
   : never
 
@@ -165,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
@@ -173,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. */