Headless Coder SDK unifies multiple headless AI-coder SDKs - Codex-sdk, Claude-Agent-sdk, and Gemini-CLI - under one consistent interface

[OhadAssulin]

Headless Coder SDK unifies multiple headless AI-coder SDKs - Codex-sdk, Claude-Agent-sdk, and Gemini-CLI under one consistent interface.
It standardizes threads, streaming, structured outputs, permissions, and sandboxing, allowing you to build AI coding tools or autonomous agents that switch backends with a single line of code.

https://github.com/OhadAssulin/headless-coder-sdk

---

🚀 Why use it?

• Avoid vendor lock-in between AI-coder SDKs
• Unified threads and streaming API
• Structured output and sandbox enforcement
• Works in Node, Electron, or CI pipelines
• Extensible - add your own adapters easily

---

🔄 In this workflow two reviewers (Claude, Codex) analyze the same commit in parallel and emit structured findings. Gemini then waits until both reviews finish and applies fixes issue-by-issue using the shared structured payload.

import {
  registerAdapter,
  createCoder,
} from '@headless-coder-sdk/core/factory';
import {
  CODER_NAME as CODEX,
  createAdapter as createCodex,
} from '@headless-coder-sdk/codex-adapter';
import {
  CODER_NAME as CLAUDE,
  createAdapter as createClaude,
} from '@headless-coder-sdk/claude-adapter';
import {
  CODER_NAME as GEMINI,
  createAdapter as createGemini,
} from '@headless-coder-sdk/gemini-adapter';

registerAdapter(CODEX, createCodex);
registerAdapter(CLAUDE, createClaude);
registerAdapter(GEMINI, createGemini);

// 1) Claude + Codex perform code review concurrently and emit structured findings.
const reviewSchema = {
  type: 'object',
  properties: {
    issues: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          file: { type: 'string' },
          description: { type: 'string' },
          severity: { type: 'string', enum: ['high', 'medium', 'low'] },
        },
        required: ['file', 'description', 'severity'],
      },
    },
  },
  required: ['issues'],
} as const;

async function runMultiProviderReview(commitHash: string) {
  const [claude, codex] = [createCoder(CLAUDE), createCoder(CODEX)];
  const [claudeThread, codexThread] = await Promise.all([
    claude.startThread(),
    codex.startThread(),
  ]);

  const reviewPrompt = (name: string) =>
    `Review commit ${commitHash} and provide structured findings as ${name}. Focus on regressions, tests, and security.`;

  const [claudeReview, codexReview] = await Promise.all([
    claudeThread.run(reviewPrompt('Claude'), { outputSchema: reviewSchema }),
    codexThread.run(reviewPrompt('Codex'), { outputSchema: reviewSchema }),
  ]);

  const combinedIssues = [
    ...(claudeReview.json?.issues ?? []),
    ...(codexReview.json?.issues ?? []),
  ];

  // 2) Gemini waits for both reviewers, then fixes each issue sequentially.
  const gemini = createCoder(GEMINI, { workingDirectory: process.cwd() });
  const geminiThread = await gemini.startThread();

  for (const issue of combinedIssues) {
    await geminiThread.run([
      {
        role: 'system',
        content: 'You fix code review issues one at a time. Apply patches directly when possible.',
      },
      {
        role: 'user',
        content: `Commit: ${commitHash}\nFile: ${issue.file}\nSeverity: ${issue.severity}\nIssue: ${issue.description}\nPlease fix this issue and describe the change.`,
      },
    ]);
  }

  await Promise.all([claude.close?.(claudeThread), codex.close?.(codexThread), gemini.close?.(geminiThread)]);
}