interface CodexProps<TSchema extends z.ZodType = z.ZodType> {
  /**
   * Prompt/task for the agent.
   */
  children: ReactNode

  /**
   * Model selection.
   * @default 'gpt-4-turbo'
   */
  model?: 'gpt-4' | 'gpt-4-turbo' | 'gpt-3.5-turbo'

  /**
   * Temperature for randomness (0-2).
   * @default 1
   */
  temperature?: number

  /**
   * System prompt for agent behavior.
   */
  systemPrompt?: string

  /**
   * Working directory for code operations.
   */
  cwd?: string

  /**
   * Environment variables.
   */
  env?: Record<string, string>

  /**
   * Timeout in milliseconds.
   * @default 300000 (5 minutes)
   */
  timeout?: number

  /**
   * Zod schema for structured output.
   */
  schema?: TSchema

  /**
   * Callback on successful completion.
   */
  onFinished?: (result: AgentResult<TSchema>) => void

  /**
   * Callback on error.
   */
  onError?: (error: Error) => void
}

interface AgentResult<TSchema extends z.ZodType = z.ZodType> {
  output: string
  parsedOutput?: z.infer<TSchema>
  toolCalls?: ToolCall[]
  durationMs: number
}

export function Codex<TSchema extends z.ZodType = z.ZodType>(
  props: CodexProps<TSchema>
): JSX.Element

import { Codex, Phase, Step } from 'smithers-orchestrator'

export function ImplementFeature() {
  return (
    <Phase name="Implementation">
      <Step name="implement">
        <Codex model="gpt-4-turbo">
          Implement user authentication with JWT tokens.
          Include login, logout, and token refresh endpoints.
        </Codex>
      </Step>
    </Phase>
  )
}

import { z } from 'zod'

const reviewSchema = z.object({
  decision: z.enum(['approve', 'request_changes']),
  issues: z.array(z.object({
    severity: z.enum(['critical', 'major', 'minor']),
    file: z.string(),
    message: z.string()
  })),
  summary: z.string()
})

<Codex
  model="gpt-4"
  schema={reviewSchema}
  onFinished={(result) => {
    const review = result.parsedOutput
    console.log(`Decision: ${review.decision}`)
    console.log(`Issues: ${review.issues.length}`)
  }}
>
  Review this pull request and provide structured feedback
</Codex>

<Codex
  model="gpt-4-turbo"
  systemPrompt="You are a senior software engineer specializing in React and TypeScript. Focus on performance, type safety, and maintainability."
>
  Refactor this component to use modern React patterns
</Codex>

import { FallbackAgent, Codex, Claude } from 'smithers-orchestrator'

<FallbackAgent>
  <Codex model="gpt-4-turbo">{prompt}</Codex>
  <Claude model="sonnet">{prompt}</Claude>
</FallbackAgent>

export function Codex<TSchema extends z.ZodType = z.ZodType>(
  props: CodexProps<TSchema>
): ReactNode {
  const { db } = useSmithers()
  const worktree = useWorktree()
  const taskIdRef = useRef<string | null>(null)

  useMount(() => {
    ;(async () => {
      taskIdRef.current = db.tasks.start('codex_agent', extractPrompt(props.children))

      try {
        const result = await executeCodexCLI({
          prompt: extractPrompt(props.children),
          model: props.model ?? 'gpt-4-turbo',
          temperature: props.temperature,
          systemPrompt: props.systemPrompt,
          cwd: props.cwd ?? worktree?.cwd,
          env: props.env,
          timeout: props.timeout ?? 300000,
          schema: props.schema
        })

        props.onFinished?.(result)
      } catch (error) {
        props.onError?.(error)
        throw error
      } finally {
        db.tasks.complete(taskIdRef.current)
      }
    })()
  })

  return <codex-agent model={props.model} status="running" />
}

export OPENAI_API_KEY="sk-..."

const reviewSchema = z.object({
  decision: z.enum(['approve', 'request_changes']),
  blocking: z.boolean(),
  issues: z.array(z.object({
    severity: z.enum(['critical', 'major', 'minor']),
    message: z.string(),
    file: z.string().optional()
  })),
  summary: z.string()
})

<Codex
  model="gpt-4"
  schema={reviewSchema}
  systemPrompt="You are a senior code reviewer. Focus on correctness, security, and maintainability."
  onFinished={async (result) => {
    const review = result.parsedOutput
    await db.state.set('lastReview', review)

    if (review.decision === 'request_changes') {
      await postReviewComment(review.issues)
    }
  }}
>
  Review this PR:

  {prDiff}

  Check for:
  - Security vulnerabilities
  - Performance issues
  - Type safety
  - Test coverage
</Codex>

<Codex
  model="gpt-4-turbo"
  temperature={0.3}  // Lower temp for focused refactoring
  systemPrompt="Expert in React hooks and modern patterns. Preserve functionality while improving code quality."
>
  Refactor this component to:
  1. Use modern React hooks (no class components)
  2. Extract custom hooks for reusable logic
  3. Add proper TypeScript types
  4. Improve performance with memoization

  {componentCode}
</Codex>

const bugAnalysisSchema = z.object({
  rootCause: z.string(),
  affectedFiles: z.array(z.string()),
  suggestedFix: z.string(),
  testCases: z.array(z.string())
})

<Codex
  model="gpt-4"
  schema={bugAnalysisSchema}
  systemPrompt="Expert debugger. Provide root cause analysis and concrete fixes."
>
  Analyze this bug:

  Error: {errorMessage}
  Stack trace: {stackTrace}
  Recent changes: {gitDiff}

  Provide root cause, affected files, and suggested fix.
</Codex>

// Before (manual API calls)
const completion = await openai.chat.completions.create({
  model: 'gpt-4',
  messages: [
    { role: 'system', content: systemPrompt },
    { role: 'user', content: prompt }
  ],
  temperature: 0.7
})
const result = completion.choices[0].message.content

// After (declarative)
<Codex
  model="gpt-4"
  temperature={0.7}
  systemPrompt={systemPrompt}
>
  {prompt}
</Codex>