@anthropic-ai/claude-code/
├── cli.js (9.36MB - minified executable)
├── sdk.mjs (511KB - main SDK module, 14,157 lines)
├── sdk.d.ts (417 lines - TypeScript definitions)
├── sdk-tools.d.ts (272 lines - Tool input schemas)
├── package.json (32 lines)
├── README.md
├── yoga.wasm (WASM layout engine)
└── vendor/
    ├── claude-code-jetbrains-plugin/
    └── ripgrep/

// Main query function - streaming message generator
export function query({
  prompt: string | AsyncIterable<SDKUserMessage>,
  options?: Options
}): Query;

// MCP tool creation
export function tool<Schema>(
  name: string,
  description: string,
  inputSchema: Schema,
  handler: (args, extra) => Promise<CallToolResult>
): SdkMcpToolDefinition<Schema>;

// In-process MCP server creation
export function createSdkMcpServer(options: {
  name: string;
  version?: string;
  tools?: Array<SdkMcpToolDefinition<any>>;
}): McpSdkServerConfigWithInstance;

// Custom error type
export class AbortError extends Error {}

export const HOOK_EVENTS = [
  "PreToolUse",       // Before any tool execution
  "PostToolUse",      // After tool completes
  "Notification",     // System notifications
  "UserPromptSubmit", // User input submitted
  "SessionStart",     // Session initialization
  "SessionEnd",       // Session termination
  "Stop",             // User interrupt
  "SubagentStop",     // Subagent termination
  "PreCompact"        // Before context compaction
] as const;

interface HookCallback {
  matcher?: string;  // Optional pattern matching
  hooks: HookCallback[];
}

type HookJSONOutput =
  | { async: true; asyncTimeout?: number }
  | {
      continue?: boolean;
      suppressOutput?: boolean;
      stopReason?: string;
      decision?: 'approve' | 'block';
      systemMessage?: string;
      reason?: string;
      hookSpecificOutput?: {
        hookEventName: 'PreToolUse';
        permissionDecision?: 'allow' | 'deny' | 'ask';
        permissionDecisionReason?: string;
      } | {
        hookEventName: 'UserPromptSubmit' | 'SessionStart' | 'PostToolUse';
        additionalContext?: string;
      }
    };

type PermissionBehavior = 'allow' | 'deny' | 'ask';

type PermissionMode =
  | 'default'           // Interactive prompts
  | 'acceptEdits'       // Auto-accept file edits
  | 'bypassPermissions' // Skip all prompts
  | 'plan';             // Planning mode

interface CanUseTool {
  (toolName: string,
   input: Record<string, unknown>,
   options: {
     signal: AbortSignal;
     suggestions?: PermissionUpdate[];
   }): Promise<PermissionResult>;
}

type PermissionUpdate =
  | { type: 'addRules'; rules: PermissionRuleValue[]; behavior: PermissionBehavior; destination: PermissionUpdateDestination }
  | { type: 'replaceRules'; rules: PermissionRuleValue[]; behavior: PermissionBehavior; destination: PermissionUpdateDestination }
  | { type: 'removeRules'; rules: PermissionRuleValue[]; behavior: PermissionBehavior; destination: PermissionUpdateDestination }
  | { type: 'setMode'; mode: PermissionMode; destination: PermissionUpdateDestination }
  | { type: 'addDirectories'; directories: string[]; destination: PermissionUpdateDestination }
  | { type: 'removeDirectories'; directories: string[]; destination: PermissionUpdateDestination };

type PermissionUpdateDestination =
  | 'userSettings'      // ~/.claude/settings.json
  | 'projectSettings'   // .claude/settings.json
  | 'localSettings'     // .claude-local.json
  | 'session';          // Current session only

type McpServerConfig =
  | {
      type?: 'stdio';  // Command-based (current Claude-Flow method)
      command: string;
      args?: string[];
      env?: Record<string, string>;
    }
  | {
      type: 'sse';     // Server-Sent Events (NEW!)
      url: string;
      headers?: Record<string, string>;
    }
  | {
      type: 'http';    // HTTP transport (NEW!)
      url: string;
      headers?: Record<string, string>;
    }
  | {
      type: 'sdk';     // In-process (NEW! - ZERO IPC OVERHEAD)
      name: string;
      instance: McpServer;
    };

const swarmServer = createSdkMcpServer({
  name: 'claude-flow-swarm',
  version: '2.5.0-alpha.130',
  tools: [
    tool('swarm_init', 'Initialize multi-agent swarm', {...}, handler),
    tool('agent_spawn', 'Spawn specialized agent', {...}, handler),
    tool('task_orchestrate', 'Orchestrate task across swarm', {...}, handler),
    // ... 40+ more tools
  ]
});

interface Options {
  // Resume existing session
  resume?: string;              // Session ID to resume
  resumeSessionAt?: string;     // Resume from specific message ID
  forkSession?: boolean;        // Fork session instead of resuming

  // Session control
  includePartialMessages?: boolean;

  // Context management
  maxThinkingTokens?: number;
  maxTurns?: number;
}

interface Query extends AsyncGenerator<SDKMessage, void> {
  // Real-time control methods
  interrupt(): Promise<void>;
  setPermissionMode(mode: PermissionMode): Promise<void>;
  setModel(model?: string): Promise<void>;
  supportedCommands(): Promise<SlashCommand[]>;
  supportedModels(): Promise<ModelInfo[]>;
  mcpServerStatus(): Promise<McpServerStatus[]>;
}

type SDKMessage =
  | SDKAssistantMessage    // Claude's response
  | SDKUserMessage         // User input
  | SDKUserMessageReplay   // Replayed user message
  | SDKResultMessage       // Task completion result
  | SDKSystemMessage       // System initialization
  | SDKPartialAssistantMessage  // Streaming chunk
  | SDKCompactBoundaryMessage;  // Context compression marker

// Result types
type SDKResultMessage =
  | {
      type: 'result';
      subtype: 'success';
      duration_ms: number;
      duration_api_ms: number;
      num_turns: number;
      result: string;
      total_cost_usd: number;
      usage: NonNullableUsage;
      modelUsage: { [modelName: string]: ModelUsage };
      permission_denials: SDKPermissionDenial[];
    }
  | {
      type: 'result';
      subtype: 'error_max_turns' | 'error_during_execution';
      // ... error details
    };

// Compact boundary for checkpoints
type SDKCompactBoundaryMessage = {
  type: 'system';
  subtype: 'compact_boundary';
  compact_metadata: {
    trigger: 'manual' | 'auto';
    pre_tokens: number;
  };
};

type ToolInputSchemas =
  | AgentInput          // Subagent spawning
  | BashInput           // Shell commands
  | BashOutputInput     // Background shell monitoring
  | ExitPlanModeInput   // Plan mode control
  | FileEditInput       // File modifications
  | FileReadInput       // File reading
  | FileWriteInput      // File creation
  | GlobInput           // File pattern matching
  | GrepInput           // Content search
  | KillShellInput      // Background shell termination
  | ListMcpResourcesInput  // MCP resource listing
  | McpInput            // Generic MCP tool
  | NotebookEditInput   // Jupyter notebook editing
  | ReadMcpResourceInput   // MCP resource reading
  | TodoWriteInput      // Task list management
  | WebFetchInput       // Web content fetching
  | WebSearchInput;     // Web search

// Agent spawning schema
interface AgentInput {
  description: string;      // 3-5 word task description
  prompt: string;           // Full task instructions
  subagent_type: string;    // Agent specialization
}

// Bash execution schema
interface BashInput {
  command: string;
  timeout?: number;         // Max 600000ms (10 minutes)
  description?: string;
  run_in_background?: boolean;
}

// Found in cli.js (minified)
interface NetworkPermission {
  hostPattern: { host: string; port: number };
  allow: boolean;
  rememberForSession: boolean;
}

// Found in cli.js
window.__REACT_DEVTOOLS_COMPONENT_FILTERS__
// SDK includes full React DevTools backend

// Found in cli.js
interface InstallCommand {
  force?: boolean;
  target?: string;  // version or "stable"
  cleanupNpm?: boolean;
}

// Found in cli.js
function B1(eventName: string, properties: Record<string, any>): void;
// Example: B1("tengu_claude_install_command", { forced: 1 })

// Found in cli.js
interface ProfilingData {
  dataForRoots: Array<{
    commitData: CommitData[];
    displayName: string;
    initialTreeBaseDurations: [number, number][];
    rootID: number;
  }>;
  rendererID: number;
  timelineData: TimelineData | null;
}

// Found from sharp package analysis
const prebuiltPlatforms = [
  "darwin-arm64", "darwin-x64",
  "linux-arm", "linux-arm64", "linux-s390x", "linux-x64",
  "linuxmusl-arm64", "linuxmusl-x64",
  "win32-ia32", "win32-x64",
  "wasm32"  // WebAssembly target!
];

// Found in sharp installation code
function WsQ(): boolean {
  // Detects if running on Apple Silicon via Rosetta
  return (spawnSync("sysctl sysctl.proc_translated").stdout || "").trim() ===
         "sysctl.proc_translated: 1";
}

interface SlashCommand {
  name: string;
  description: string;
  argumentHint: string;
}

// Query interface exposes:
supportedCommands(): Promise<SlashCommand[]>;

interface ModelInfo {
  value: string;          // Model ID
  displayName: string;    // Human-readable name
  description: string;    // Model description
}

supportedModels(): Promise<ModelInfo[]>;

interface McpServerStatus {
  name: string;
  status: 'connected' | 'failed' | 'needs-auth' | 'pending';
  serverInfo?: {
    name: string;
    version: string;
  };
}

mcpServerStatus(): Promise<McpServerStatus[]>;

// Instead of custom memory, use SDK sessions
class SwarmMemoryManager {
  async saveCheckpoint(swarmId: string, state: SwarmState) {
    // Store as SDKMessage history
    const messages: SDKMessage[] = this.convertToSDKMessages(state);
    await this.storeSession(swarmId, messages);
  }

  async restoreCheckpoint(swarmId: string, messageId?: string) {
    // Use resumeSessionAt for point-in-time recovery
    return query({
      prompt: this.getResumePrompt(),
      options: {
        resume: swarmId,
        resumeSessionAt: messageId
      }
    });
  }
}

// Parallel agent spawning via session forking
class SwarmExecutor {
  async spawnParallelAgents(task: Task, agentCount: number) {
    const baseSession = await this.initializeSession(task);

    // Fork N sessions for parallel execution
    const agents = await Promise.all(
      Array.from({ length: agentCount }, () =>
        query({
          prompt: this.getAgentPrompt(task),
          options: {
            resume: baseSession.id,
            forkSession: true  // Key: fork instead of resume
          }
        })
      )
    );

    return agents;
  }
}

// Replace custom hooks with SDK hooks
const hooks: Partial<Record<HookEvent, HookCallbackMatcher[]>> = {
  PreToolUse: [{
    hooks: [async (input, toolUseID, { signal }) => {
      // Swarm-level tool governance
      const allowed = await this.checkSwarmPermissions(
        input.tool_name,
        input.tool_input
      );

      return {
        decision: allowed ? 'approve' : 'block',
        hookSpecificOutput: {
          hookEventName: 'PreToolUse',
          permissionDecision: allowed ? 'allow' : 'deny',
          permissionDecisionReason: 'Swarm policy check'
        }
      };
    }]
  }],

  PostToolUse: [{
    hooks: [async (input, toolUseID, { signal }) => {
      // Store tool execution results in swarm memory
      await this.swarmMemory.recordToolExecution({
        tool: input.tool_name,
        input: input.tool_input,
        output: input.tool_response,
        timestamp: Date.now()
      });

      return { continue: true };
    }]
  }],

  SessionEnd: [{
    hooks: [async (input, toolUseID, { signal }) => {
      // Aggregate swarm metrics on session end
      await this.aggregateSwarmMetrics(input.session_id);
      return { continue: true };
    }]
  }]
};

// Zero-overhead swarm coordination
import { createSdkMcpServer, tool } from '@anthropic-ai/claude-code/sdk';

const claudeFlowSwarmServer = createSdkMcpServer({
  name: 'claude-flow-swarm',
  version: '2.5.0-alpha.130',
  tools: [
    tool('swarm_init', 'Initialize multi-agent swarm', {
      topology: { type: 'string', enum: ['mesh', 'hierarchical', 'ring', 'star'] },
      maxAgents: { type: 'number', minimum: 1, maximum: 100 }
    }, async (args) => {
      const swarm = await SwarmCoordinator.initialize(args);
      return {
        content: [{ type: 'text', text: JSON.stringify(swarm.status) }]
      };
    }),

    tool('agent_spawn', 'Spawn specialized agent in swarm', {
      type: { type: 'string', enum: ['researcher', 'coder', 'analyst', 'optimizer'] },
      capabilities: { type: 'array', items: { type: 'string' } }
    }, async (args) => {
      const agent = await SwarmCoordinator.spawnAgent(args);
      return {
        content: [{ type: 'text', text: JSON.stringify(agent) }]
      };
    }),

    // ... 40+ more tools with ZERO IPC overhead
  ]
});

// Use in Claude-Flow
const response = query({
  prompt: 'Deploy a 5-agent swarm to analyze this codebase',
  options: {
    mcpServers: {
      'claude-flow-swarm': {
        type: 'sdk',
        name: 'claude-flow-swarm',
        instance: claudeFlowSwarmServer.instance
      }
    }
  }
});