ocpipe 0.6.6 → 0.6.8

package/README.md

@@ -76,11 +76,11 @@ defaultModel: { backend: 'claude-code', modelID: 'sonnet' },
 claudeCode: { permissionMode: 'acceptEdits' },
 ```
 
-**Codex** - Uses `@openai/codex`. Install as a peer dependency.
+**Codex** - Uses `@openai/codex-sdk`. Install as a peer dependency.
 
 ```typescript
 defaultModel: { backend: 'codex', modelID: 'gpt-5.4' },
-codex: { sandbox: 'read-only', ephemeral: true },
+codex: { sandbox: 'read-only', reasoningEffort: 'high' },
 ```
 
 ### Requirements
@@ -96,10 +96,10 @@ codex: { sandbox: 'read-only', ephemeral: true },
 bun add @anthropic-ai/claude-agent-sdk
 ```
 
-**For Codex backend:** Install the Codex CLI package as a peer dependency:
+**For Codex backend:** Install the Codex SDK package as a peer dependency:
 
 ```bash
-bun add @openai/codex
+bun add @openai/codex-sdk
 ```
 
 ### Documentation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocpipe",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "description": "SDK for LLM pipelines with OpenCode, Codex, and Zod",
   "type": "module",
   "main": "src/index.ts",
@@ -32,20 +32,21 @@
   "peerDependencies": {
     "zod": "4.4.3",
     "@anthropic-ai/claude-agent-sdk": "0.2.126",
-    "@openai/codex": "0.128.0"
+    "@openai/codex-sdk": "0.130.0"
   },
   "peerDependenciesMeta": {
     "@anthropic-ai/claude-agent-sdk": {
       "optional": true
     },
-    "@openai/codex": {
+    "@openai/codex-sdk": {
       "optional": true
     }
   },
   "devDependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.132",
-    "@openai/codex": "^0.128.0",
     "@eslint/js": "^10.0.1",
+    "@openai/codex-sdk": "0.130.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260506.1",
     "bun-types": "^1.3.13",
     "eslint": "^10.3.0",
     "globals": "^17.6.0",
@@ -53,7 +54,6 @@
     "prettier": "^3.8.3",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.59.2",
-    "@typescript/native-preview": "^7.0.0-dev.20260506.1",
     "vitest": "^4.1.5"
   },
   "scripts": {

package/src/agent.ts

@@ -1,7 +1,7 @@
 /**
  * ocpipe agent integration.
  *
- * Dispatches to OpenCode CLI, Claude Code SDK, or Codex CLI based on backend
+ * Dispatches to OpenCode CLI, Claude Code SDK, or Codex SDK based on backend
  * configuration.
  */
 

package/src/codex.ts

@@ -1,14 +1,22 @@
 /**
- * ocpipe Codex CLI integration.
+ * ocpipe Codex SDK integration.
  *
- * Runs Codex non-interactively through `codex exec`.
+ * Runs Codex through @openai/codex-sdk threads.
  */
 
-import { spawn } from 'child_process'
-import { mkdir, readFile, unlink } from 'fs/promises'
-import { join } from 'path'
-import { PROJECT_ROOT, TMP_DIR } from './paths.js'
-import type { RunAgentOptions, RunAgentResult } from './types.js'
+import {
+  Codex,
+  type CodexOptions as CodexSdkClientOptions,
+  type RunResult,
+  type ThreadOptions,
+} from '@openai/codex-sdk'
+import { PROJECT_ROOT } from './paths.js'
+import type {
+  CodexOptions,
+  CodexRunSummary,
+  RunAgentOptions,
+  RunAgentResult,
+} from './types.js'
 
 class CodexLogFilter {
   private buf = ''
@@ -79,157 +87,200 @@ export async function runCodexAgent(
     signal,
   } = options
 
-  if (sessionId) {
-    throw new Error('Codex backend does not support session resume yet')
-  }
   if (signal?.aborted) {
     throw new Error('Request aborted')
   }
 
   const cwd = workdir ?? PROJECT_ROOT
-  await mkdir(TMP_DIR, { recursive: true })
-  const stamp = `${Date.now()}_${Math.random().toString(36).slice(2)}`
-  const outputFile = join(TMP_DIR, `codex_output_${stamp}.txt`)
-
-  const cmd = codex?.pathToCodexExecutable ?? 'codex'
-  const args = [
-    'exec',
-    '--color',
-    'never',
-    '--model',
-    model.modelID,
-    '--sandbox',
-    codex?.sandbox ?? 'read-only',
-    '--cd',
-    cwd,
-    '--output-last-message',
-    outputFile,
-  ]
-
-  if (codex?.ephemeral ?? true) {
-    args.push('--ephemeral')
-  }
-  if (codex?.ignoreUserConfig) {
-    args.push('--ignore-user-config')
-  }
-  if (codex?.ignoreRules) {
-    args.push('--ignore-rules')
-  }
-  if (codex?.reasoningEffort) {
-    args.push('-c', `model_reasoning_effort="${codex.reasoningEffort}"`)
-  }
-  for (const dir of codex?.addDirs ?? []) {
-    args.push('--add-dir', dir)
-  }
-  for (const [key, value] of Object.entries(codex?.config ?? {})) {
-    args.push('-c', `${key}=${value}`)
-  }
-  args.push('-')
+  const client = new Codex(buildCodexClientOptions(codex))
+  const threadOptions = buildCodexThreadOptions(model.modelID, cwd, codex)
+  const thread =
+    sessionId && !codex?.ephemeral ?
+      client.resumeThread(sessionId, threadOptions)
+    : client.startThread(threadOptions)
 
   const promptPreview = prompt.slice(0, 50).replace(/\n/g, ' ')
+  const sessionInfo =
+    sessionId && !codex?.ephemeral ? `[thread:${sessionId}]` : '[new thread]'
   console.error(
-    `\n>>> Codex [${model.modelID}] [new session]: ${promptPreview}...`,
+    `\n>>> Codex SDK [${model.modelID}] ${sessionInfo}: ${promptPreview}...`,
   )
 
-  return new Promise((resolve, reject) => {
-    const proc = spawn(cmd, args, {
-      cwd,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    })
-
-    const stderrChunks: string[] = []
-    const stdoutFilter = new CodexLogFilter()
-    const stderrFilter = new CodexLogFilter()
-    let aborted = false
+  const abort = new AbortController()
+  let timedOut = false
+  const abortHandler = () => abort.abort()
+  signal?.addEventListener('abort', abortHandler, { once: true })
+  const timeout =
+    timeoutSec > 0 ?
+      setTimeout(() => {
+        timedOut = true
+        abort.abort()
+      }, timeoutSec * 1000)
+    : null
 
-    const cleanup = async () => {
-      await unlink(outputFile).catch(() => {})
+  try {
+    const result = await thread.run(prompt, { signal: abort.signal })
+    const response = result.finalResponse.trim()
+    if (!response) {
+      throw new Error('Codex returned an empty response')
     }
 
-    const abortHandler = () => {
-      if (aborted) return
-      aborted = true
-      console.error('\n[abort] Killing Codex subprocess...')
-      proc.kill('SIGTERM')
-      setTimeout(() => {
-        if (!proc.killed) proc.kill('SIGKILL')
-      }, 1000)
-      void cleanup()
-      reject(new Error('Request aborted'))
+    const nextSessionId = codex?.ephemeral ? '' : (thread.id ?? '')
+    const sessionStr = nextSessionId || 'none'
+    const runSummary = buildCodexRunSummary(result)
+    console.error(
+      `<<< Codex SDK done [thread:${sessionStr}]\n${formatCodexRunSummary(runSummary)}`,
+    )
+
+    return {
+      text: response,
+      sessionId: nextSessionId,
+      runSummary,
+    }
+  } catch (err) {
+    if (timedOut) {
+      throw new Error(`Timeout after ${timeoutSec}s`, { cause: err })
     }
-    signal?.addEventListener('abort', abortHandler, { once: true })
+    if (signal?.aborted) {
+      throw new Error('Request aborted', { cause: err })
+    }
+    throw err
+  } finally {
+    if (timeout) clearTimeout(timeout)
+    signal?.removeEventListener('abort', abortHandler)
+  }
+}
 
-    proc.stdout.on('data', (data: Buffer) => {
-      const text = stdoutFilter.write(data.toString())
-      if (text) {
-        process.stderr.write(text)
-      }
-    })
-    proc.stderr.on('data', (data: Buffer) => {
-      const text = stderrFilter.write(data.toString())
-      stderrChunks.push(text)
-      if (text) {
-        process.stderr.write(text)
-      }
-    })
-
-    const timeout =
-      timeoutSec > 0 ?
-        setTimeout(() => {
-          proc.kill()
-          void cleanup()
-          reject(new Error(`Timeout after ${timeoutSec}s`))
-        }, timeoutSec * 1000)
-      : null
-
-    proc.stdin.end(prompt)
-
-    proc.on('close', async (code) => {
-      if (timeout) clearTimeout(timeout)
-      signal?.removeEventListener('abort', abortHandler)
-      if (aborted) return
-
-      const stdoutTail = stdoutFilter.flush()
-      if (stdoutTail) {
-        process.stderr.write(stdoutTail)
-      }
-      const stderrTail = stderrFilter.flush()
-      if (stderrTail) {
-        stderrChunks.push(stderrTail)
-        process.stderr.write(stderrTail)
-      }
-      const stderr = stderrChunks.join('').trim()
-      if (code !== 0) {
-        await cleanup()
-        const detail =
-          stderr ? `\n${stderr.split('\n').slice(-10).join('\n')}` : ''
-        reject(new Error(`Codex exited with code ${code}${detail}`))
-        return
-      }
+/** buildCodexRunSummary projects a Codex turn into a parent-readable summary. */
+export function buildCodexRunSummary(result: RunResult): CodexRunSummary {
+  const commands: CodexRunSummary['commands'] = []
+  const fileChanges: CodexRunSummary['fileChanges'] = []
+  let errorMessage = ''
+  let finalMessage = result.finalResponse.trim()
 
-      try {
-        const response = (await readFile(outputFile, 'utf8')).trim()
-        await cleanup()
-        if (!response) {
-          reject(new Error('Codex returned an empty response'))
-          return
-        }
-        console.error(`<<< Codex done (${response.length} chars)`)
-        resolve({
-          text: response,
-          sessionId: '',
+  for (const item of result.items) {
+    switch (item.type) {
+      case 'agent_message':
+        if (item.text) finalMessage = item.text
+        break
+      case 'command_execution':
+        commands.push({
+          command: item.command,
+          status: item.status,
+          exitCode: item.exit_code ?? null,
         })
-      } catch (err) {
-        await cleanup()
-        reject(err)
-      }
-    })
-
-    proc.on('error', async (err) => {
-      if (timeout) clearTimeout(timeout)
-      signal?.removeEventListener('abort', abortHandler)
-      await cleanup()
-      reject(err)
-    })
-  })
+        break
+      case 'file_change':
+        for (const change of item.changes) {
+          fileChanges.push({
+            path: change.path,
+            kind: change.kind,
+            status: item.status,
+          })
+        }
+        break
+      case 'error':
+        errorMessage = item.message
+        break
+    }
+  }
+
+  const usage = result.usage
+  return {
+    status: errorMessage ? 'failed' : 'completed',
+    finalMessage: finalMessage.trim(),
+    errorMessage,
+    commands,
+    fileChanges,
+    tokens:
+      usage ?
+        {
+          input: usage.input_tokens,
+          cached: usage.cached_input_tokens,
+          output: usage.output_tokens,
+          reasoning: usage.reasoning_output_tokens,
+        }
+      : null,
+  }
+}
+
+/** formatCodexRunSummary renders a Codex run summary as a clean text block. */
+export function formatCodexRunSummary(summary: CodexRunSummary): string {
+  const lines: string[] = [`status: ${summary.status}`]
+  if (summary.errorMessage) {
+    lines.push(`error: ${summary.errorMessage}`)
+  }
+  if (summary.commands.length > 0) {
+    const failed = summary.commands.filter(isFailedCommand).length
+    lines.push(
+      `commands: ${summary.commands.length} completed, ${failed} failed`,
+    )
+  }
+  if (summary.fileChanges.length > 0) {
+    let add = 0
+    let update = 0
+    let del = 0
+    for (const change of summary.fileChanges) {
+      if (change.kind === 'add') add++
+      else if (change.kind === 'delete') del++
+      else update++
+    }
+    lines.push(`files: add=${add} update=${update} delete=${del}`)
+  }
+  if (summary.tokens) {
+    const t = summary.tokens
+    lines.push(
+      `tokens: input=${t.input} cached=${t.cached} output=${t.output} reasoning=${t.reasoning}`,
+    )
+  }
+  if (summary.finalMessage) {
+    lines.push(`final_message:\n${summary.finalMessage}`)
+  }
+  return lines.join('\n')
+}
+
+function isFailedCommand(command: CodexRunSummary['commands'][number]): boolean {
+  return (
+    command.status === 'failed' ||
+    (command.exitCode !== null && command.exitCode !== 0)
+  )
+}
+
+function buildCodexClientOptions(
+  codex: CodexOptions | undefined,
+): CodexSdkClientOptions {
+  return {
+    ...(codex?.pathToCodexExecutable ?
+      { codexPathOverride: codex.pathToCodexExecutable }
+    : {}),
+    ...(codex?.baseUrl ? { baseUrl: codex.baseUrl } : {}),
+    ...(codex?.apiKey ? { apiKey: codex.apiKey } : {}),
+    ...(codex?.env ? { env: codex.env } : {}),
+    ...(codex?.config ? { config: codex.config } : {}),
+  }
+}
+
+function buildCodexThreadOptions(
+  modelID: string,
+  cwd: string,
+  codex: CodexOptions | undefined,
+): ThreadOptions {
+  return {
+    model: modelID,
+    workingDirectory: cwd,
+    skipGitRepoCheck: true,
+    sandboxMode: codex?.sandbox ?? 'read-only',
+    ...(codex?.reasoningEffort ?
+      { modelReasoningEffort: codex.reasoningEffort }
+    : {}),
+    ...(codex?.addDirs ? { additionalDirectories: codex.addDirs } : {}),
+    ...(codex?.approvalPolicy ? { approvalPolicy: codex.approvalPolicy } : {}),
+    ...(codex?.networkAccessEnabled !== undefined ?
+      { networkAccessEnabled: codex.networkAccessEnabled }
+    : {}),
+    ...(codex?.webSearchMode ? { webSearchMode: codex.webSearchMode } : {}),
+    ...(codex?.webSearchEnabled !== undefined ?
+      { webSearchEnabled: codex.webSearchEnabled }
+    : {}),
+  }
 }

package/src/index.ts

@@ -50,6 +50,7 @@ export { createSessionId, createBaseState, extendBaseState } from './state.js'
 
 // Agent integration
 export { runAgent, logStep } from './agent.js'
+export { buildCodexRunSummary, formatCodexRunSummary } from './codex.js'
 
 // Response parsing
 export {
@@ -91,7 +92,12 @@ export type {
   BackendType,
   PermissionMode,
   ClaudeCodeOptions,
+  CodexApprovalPolicy,
+  CodexConfigValue,
   CodexOptions,
+  CodexReasoningEffort,
+  CodexSandboxMode,
+  CodexWebSearchMode,
   ModelConfig,
   ExecutionContext,
   StepResult,
@@ -111,6 +117,10 @@ export type {
   // Agent types
   RunAgentOptions,
   RunAgentResult,
+  CodexRunSummary,
+  CodexRunCommand,
+  CodexRunFileChange,
+  CodexRunTokens,
   // Correction types
   CorrectionMethod,
   CorrectionConfig,

package/src/types.ts

@@ -11,6 +11,38 @@ import type { z } from 'zod/v4'
 /** Backend type for running agents. */
 export type BackendType = 'opencode' | 'claude-code' | 'codex'
 
+/** Reasoning effort for Codex SDK threads. */
+export type CodexReasoningEffort =
+  | 'minimal'
+  | 'low'
+  | 'medium'
+  | 'high'
+  | 'xhigh'
+
+/** Codex sandbox mode. */
+export type CodexSandboxMode =
+  | 'read-only'
+  | 'workspace-write'
+  | 'danger-full-access'
+
+/** Codex approval policy. */
+export type CodexApprovalPolicy =
+  | 'never'
+  | 'on-request'
+  | 'on-failure'
+  | 'untrusted'
+
+/** Codex web search mode. */
+export type CodexWebSearchMode = 'disabled' | 'cached' | 'live'
+
+/** Codex SDK config override value. */
+export type CodexConfigValue =
+  | string
+  | number
+  | boolean
+  | CodexConfigValue[]
+  | { [key: string]: CodexConfigValue }
+
 /** Permission mode for Claude Code sessions. */
 export type PermissionMode =
   | 'default'
@@ -57,24 +89,34 @@ export interface ClaudeCodeOptions {
   allowedTools?: string[]
 }
 
-/** Codex CLI specific session options. */
+/** Codex SDK specific session options. */
 export interface CodexOptions {
-  /** Path to Codex executable (default: `codex` from PATH). */
+  /** Path override for the Codex executable used by the SDK. */
   pathToCodexExecutable?: string
-  /** Sandbox mode for `codex exec` (default: `read-only`). */
-  sandbox?: 'read-only' | 'workspace-write' | 'danger-full-access'
-  /** Extra config overrides passed as repeated `-c key=value` flags. */
-  config?: Record<string, string>
-  /** Reasoning effort passed to Codex (for example: `low`, `medium`, `high`, `xhigh`). */
-  reasoningEffort?: string
-  /** Run without persisting Codex session files (default: true). */
+  /** Base URL passed to the Codex SDK. */
+  baseUrl?: string
+  /** API key passed to the Codex SDK. */
+  apiKey?: string
+  /** Environment variables passed to the Codex subprocess. */
+  env?: Record<string, string>
+  /** Sandbox mode for Codex (default: `read-only`). */
+  sandbox?: CodexSandboxMode
+  /** Extra config overrides passed through the Codex SDK. */
+  config?: { [key: string]: CodexConfigValue }
+  /** Reasoning effort passed to Codex. */
+  reasoningEffort?: CodexReasoningEffort
+  /** Start a new SDK thread instead of resuming the provided session ID. */
   ephemeral?: boolean
-  /** Ignore user config for deterministic automation (default: false). */
-  ignoreUserConfig?: boolean
-  /** Ignore user and project execpolicy rules (default: false). */
-  ignoreRules?: boolean
   /** Additional directories Codex may access alongside the working directory. */
   addDirs?: string[]
+  /** Approval policy passed to Codex. */
+  approvalPolicy?: CodexApprovalPolicy
+  /** Enable network access in workspace-write sandboxes. */
+  networkAccessEnabled?: boolean
+  /** Web search mode passed to Codex. */
+  webSearchMode?: CodexWebSearchMode
+  /** Legacy boolean web search control passed to Codex. */
+  webSearchEnabled?: boolean
 }
 
 /** Model configuration for LLM backends. */
@@ -108,9 +150,9 @@ export interface ExecutionContext {
   workdir?: string
   /** Claude Code specific options. */
   claudeCode?: ClaudeCodeOptions
-  /** Codex CLI specific options. */
+  /** Codex SDK specific options. */
   codex?: CodexOptions
-  /** AbortSignal for cancelling requests. When aborted, kills subprocesses. */
+  /** AbortSignal for cancelling in-flight backend requests. */
   signal?: AbortSignal
 }
 
@@ -328,7 +370,7 @@ export interface PipelineConfig {
   workdir?: string
   /** Claude Code specific options. */
   claudeCode?: ClaudeCodeOptions
-  /** Codex CLI specific options. */
+  /** Codex SDK specific options. */
   codex?: CodexOptions
 }
 
@@ -364,9 +406,9 @@ export interface RunAgentOptions {
   workdir?: string
   /** Claude Code specific options. */
   claudeCode?: ClaudeCodeOptions
-  /** Codex CLI specific options. */
+  /** Codex SDK specific options. */
   codex?: CodexOptions
-  /** AbortSignal for cancelling the request. When aborted, kills the subprocess. */
+  /** AbortSignal for cancelling the request. */
   signal?: AbortSignal
 }
 
@@ -376,4 +418,38 @@ export interface RunAgentResult {
   text: string
   /** Session ID (for continuing the conversation). */
   sessionId: string
+  /** Clean run summary, set for the Codex backend. */
+  runSummary?: CodexRunSummary
+}
+
+/** CodexRunCommand records one command the Codex agent executed. */
+export interface CodexRunCommand {
+  command: string
+  status: string
+  exitCode: number | null
+}
+
+/** CodexRunFileChange records one file the Codex agent changed. */
+export interface CodexRunFileChange {
+  path: string
+  kind: 'add' | 'update' | 'delete'
+  status: string
+}
+
+/** CodexRunTokens records token usage for a Codex turn. */
+export interface CodexRunTokens {
+  input: number
+  cached: number
+  output: number
+  reasoning: number
+}
+
+/** CodexRunSummary is the parent-readable projection of a Codex turn. */
+export interface CodexRunSummary {
+  status: 'completed' | 'failed' | 'unknown'
+  finalMessage: string
+  errorMessage: string
+  commands: CodexRunCommand[]
+  fileChanges: CodexRunFileChange[]
+  tokens: CodexRunTokens | null
 }