@cleocode/adapters 2026.4.46 → 2026.4.48

package/dist/providers/claude-code/adapter.d.ts

@@ -6,12 +6,11 @@
  *
  * @task T5240
  */
-import type { AdapterCapabilities, AdapterHealthStatus, CLEOProviderAdapter } from '@cleocode/contracts';
+import type { AdapterCapabilities, AdapterHealthStatus, AdapterSpawnProvider, CLEOProviderAdapter } from '@cleocode/contracts';
 import { ClaudeCodeContextMonitorProvider } from './context-monitor.js';
 import { ClaudeCodeHookProvider } from './hooks.js';
 import { ClaudeCodeInstallProvider } from './install.js';
 import { ClaudeCodePathProvider } from './paths.js';
-import { ClaudeCodeSpawnProvider } from './spawn.js';
 import { ClaudeCodeTaskSyncProvider } from './task-sync.js';
 import { ClaudeCodeTransportProvider } from './transport.js';
 /**
@@ -40,8 +39,14 @@ export declare class ClaudeCodeAdapter implements CLEOProviderAdapter {
     capabilities: AdapterCapabilities;
     /** Hook provider for CAAMP event mapping and registration. */
     hooks: ClaudeCodeHookProvider;
-    /** Spawn provider for launching subagent processes via `claude` CLI. */
-    spawn: ClaudeCodeSpawnProvider;
+    /**
+     * Spawn provider for launching subagent processes.
+     *
+     * Defaults to `ClaudeCodeSpawnProvider` (CLI mode). When
+     * `provider.claude.mode === 'sdk'` is set in CLEO config, the adapter
+     * swaps this for `ClaudeSDKSpawnProvider` at initialization time.
+     */
+    spawn: AdapterSpawnProvider;
     /** Install provider for managing instruction files and plugin registration. */
     install: ClaudeCodeInstallProvider;
     /** Path provider for resolving Claude Code directory locations. */
@@ -60,8 +65,9 @@ export declare class ClaudeCodeAdapter implements CLEOProviderAdapter {
     /**
      * Initialize the adapter for a given project directory.
      *
-     * Validates the environment by checking for the Claude CLI
-     * and Claude Code configuration directory.
+     * Reads the CLEO config to determine the spawn mode and swaps the spawn
+     * provider to `ClaudeSDKSpawnProvider` when `provider.claude.mode === 'sdk'`.
+     * Defaults to `ClaudeCodeSpawnProvider` (CLI) for backwards compatibility.
      *
      * @param projectDir - Root directory of the project
      */

package/dist/providers/claude-code/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAI7D;;;;;;;;;;;;;;GAcG;AACH,qBAAa,iBAAkB,YAAW,mBAAmB;IAC3D,kCAAkC;IAClC,QAAQ,CAAC,EAAE,iBAAiB;IAC5B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,iBAAiB;IAC9B,8BAA8B;IAC9B,QAAQ,CAAC,OAAO,WAAW;IAE3B,+CAA+C;IAC/C,YAAY,EAAE,mBAAmB,CA6B/B;IAEF,8DAA8D;IAC9D,KAAK,EAAE,sBAAsB,CAAC;IAC9B,wEAAwE;IACxE,KAAK,EAAE,uBAAuB,CAAC;IAC/B,+EAA+E;IAC/E,OAAO,EAAE,yBAAyB,CAAC;IACnC,mEAAmE;IACnE,KAAK,EAAE,sBAAsB,CAAC;IAC9B,+EAA+E;IAC/E,cAAc,EAAE,gCAAgC,CAAC;IACjD,wDAAwD;IACxD,SAAS,EAAE,2BAA2B,CAAC;IACvC,2EAA2E;IAC3E,QAAQ,EAAE,0BAA0B,CAAC;IAErC,oEAAoE;IACpE,OAAO,CAAC,UAAU,CAAuB;IACzC,kDAAkD;IAClD,OAAO,CAAC,WAAW,CAAS;;IAY5B;;;;;;;OAOG;IACG,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASnD;;;;OAIG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ9B;;;;;;;;;OASG;IACG,WAAW,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAyCjD;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,aAAa,IAAI,MAAM,GAAG,IAAI;CAG/B"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEpD,OAAO,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAI7D;;;;;;;;;;;;;;GAcG;AACH,qBAAa,iBAAkB,YAAW,mBAAmB;IAC3D,kCAAkC;IAClC,QAAQ,CAAC,EAAE,iBAAiB;IAC5B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,iBAAiB;IAC9B,8BAA8B;IAC9B,QAAQ,CAAC,OAAO,WAAW;IAE3B,+CAA+C;IAC/C,YAAY,EAAE,mBAAmB,CA6B/B;IAEF,8DAA8D;IAC9D,KAAK,EAAE,sBAAsB,CAAC;IAC9B;;;;;;OAMG;IACH,KAAK,EAAE,oBAAoB,CAAC;IAC5B,+EAA+E;IAC/E,OAAO,EAAE,yBAAyB,CAAC;IACnC,mEAAmE;IACnE,KAAK,EAAE,sBAAsB,CAAC;IAC9B,+EAA+E;IAC/E,cAAc,EAAE,gCAAgC,CAAC;IACjD,wDAAwD;IACxD,SAAS,EAAE,2BAA2B,CAAC;IACvC,2EAA2E;IAC3E,QAAQ,EAAE,0BAA0B,CAAC;IAErC,oEAAoE;IACpE,OAAO,CAAC,UAAU,CAAuB;IACzC,kDAAkD;IAClD,OAAO,CAAC,WAAW,CAAS;;IAY5B;;;;;;;;OAQG;IACG,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqCnD;;;;OAIG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ9B;;;;;;;;;OASG;IACG,WAAW,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAyCjD;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,aAAa,IAAI,MAAM,GAAG,IAAI;CAG/B"}

package/dist/providers/claude-sdk/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @packageDocumentation
+ *
+ * Claude Agent SDK spawn provider for CLEO.
+ * Uses `@anthropic-ai/claude-agent-sdk` instead of the CLI for programmatic
+ * subagent execution with structured output and session tracking.
+ *
+ * Enabled via `provider.claude.mode = 'sdk'` in CLEO config.
+ *
+ * @task T581
+ */
+export type { McpServerMap, McpStdioConfig } from './mcp-registry.js';
+export { getServers } from './mcp-registry.js';
+export type { SessionEntry } from './session-store.js';
+export { SessionStore } from './session-store.js';
+export { ClaudeSDKSpawnProvider } from './spawn.js';
+export { DEFAULT_TOOLS, resolveTools } from './tool-bridge.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/claude-sdk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-sdk/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/providers/claude-sdk/mcp-registry.d.ts

@@ -0,0 +1,40 @@
+/**
+ * MCP Registry for Claude SDK Spawn Provider
+ *
+ * Resolves available CLEO MCP servers and returns their configurations in the
+ * format expected by the SDK's `mcpServers` option. Each server is represented
+ * as an `McpStdioServerConfig` (command + optional args/env).
+ *
+ * Resolution is best-effort: if a server binary cannot be found in PATH or
+ * `node_modules/.bin/`, it is silently omitted from the returned map. This
+ * ensures agents always spawn even when some MCP servers are unavailable.
+ *
+ * @task T581
+ */
+/** Minimal stdio MCP server configuration understood by the SDK. */
+export interface McpStdioConfig {
+    type?: 'stdio';
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+/** Map of server name to its stdio configuration. */
+export type McpServerMap = Record<string, McpStdioConfig>;
+/**
+ * Resolve available CLEO MCP servers for the given working directory.
+ *
+ * Checks each known CLEO MCP server candidate against `node_modules/.bin/`
+ * in the provided directory. Only servers whose binary can be located are
+ * included in the returned map.
+ *
+ * @param workingDirectory - Project root directory for binary resolution
+ * @returns Map of available server name to stdio config (may be empty)
+ *
+ * @example
+ * ```typescript
+ * const servers = getServers('/path/to/project');
+ * // { brain: { type: 'stdio', command: '/path/to/project/node_modules/.bin/cleo-mcp-brain' } }
+ * ```
+ */
+export declare function getServers(workingDirectory: string): McpServerMap;
+//# sourceMappingURL=mcp-registry.d.ts.map

package/dist/providers/claude-sdk/mcp-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-registry.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-sdk/mcp-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,oEAAoE;AACpE,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED,qDAAqD;AACrD,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAsC1D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,gBAAgB,EAAE,MAAM,GAAG,YAAY,CAejE"}

package/dist/providers/claude-sdk/session-store.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Session Store for Claude SDK Spawn Provider
+ *
+ * Maintains an in-memory map of active SDK sessions keyed by instanceId.
+ * Each entry records the session ID returned by the SDK, the task ID, and
+ * the start time. Session IDs can be used with `options: { resume: sessionId }`
+ * in subsequent `query()` calls for multi-turn continuations.
+ *
+ * Persistence to conduit.db is intentionally deferred: the in-memory store
+ * is sufficient for single-process lifetimes and avoids coupling the spawn
+ * provider to the conduit subsystem at construction time.
+ *
+ * @task T581
+ */
+/** A single tracked SDK session entry. */
+export interface SessionEntry {
+    /** Unique instance ID assigned at spawn time. */
+    instanceId: string;
+    /** Claude SDK session ID returned in the first SDK message (if captured). */
+    sessionId: string | undefined;
+    /** CLEO task ID this session is executing. */
+    taskId: string;
+    /** ISO timestamp when the session was created. */
+    startTime: string;
+}
+/**
+ * In-memory store for active Claude SDK sessions.
+ *
+ * Provides CRUD operations over a `Map<instanceId, SessionEntry>`.
+ * Thread-safe within a single Node.js process (single-threaded event loop).
+ */
+export declare class SessionStore {
+    private readonly store;
+    /**
+     * Register a new session entry.
+     *
+     * @param entry - The session entry to add
+     */
+    add(entry: SessionEntry): void;
+    /**
+     * Update the SDK session ID for an existing entry once it is received
+     * from the first SDK message.
+     *
+     * No-op if the instanceId is not found.
+     *
+     * @param instanceId - ID of the spawn instance
+     * @param sessionId - SDK-assigned session identifier
+     */
+    setSessionId(instanceId: string, sessionId: string): void;
+    /**
+     * Retrieve an entry by instance ID.
+     *
+     * @param instanceId - ID of the spawn instance
+     * @returns The session entry, or undefined if not found
+     */
+    get(instanceId: string): SessionEntry | undefined;
+    /**
+     * Remove an entry by instance ID.
+     *
+     * @param instanceId - ID of the spawn instance to remove
+     */
+    remove(instanceId: string): void;
+    /**
+     * List all active session entries.
+     *
+     * @returns Array of all tracked session entries
+     */
+    listActive(): SessionEntry[];
+    /**
+     * Return the number of tracked sessions.
+     */
+    size(): number;
+    /**
+     * Clear all tracked sessions. Intended for testing only.
+     */
+    clear(): void;
+}
+//# sourceMappingURL=session-store.d.ts.map

package/dist/providers/claude-sdk/session-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-sdk/session-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,0CAA0C;AAC1C,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmC;IAEzD;;;;OAIG;IACH,GAAG,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAI9B;;;;;;;;OAQG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAOzD;;;;;OAKG;IACH,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIjD;;;;OAIG;IACH,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIhC;;;;OAIG;IACH,UAAU,IAAI,YAAY,EAAE;IAI5B;;OAEG;IACH,IAAI,IAAI,MAAM;IAId;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd"}

package/dist/providers/claude-sdk/spawn.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Claude SDK Spawn Provider
+ *
+ * Implements `AdapterSpawnProvider` using the `@anthropic-ai/claude-agent-sdk`
+ * programmatic API instead of shelling out to the `claude` CLI.
+ *
+ * Differences from `ClaudeCodeSpawnProvider`:
+ * - Uses SDK `query()` instead of a detached child process
+ * - Awaits full completion before returning (synchronous output capture)
+ * - Session IDs from the SDK enable future multi-turn resumption
+ * - No temp files, no OS PIDs — tracking is purely in-memory session IDs
+ * - `canSpawn()` checks for `ANTHROPIC_API_KEY` rather than CLI availability
+ *
+ * CANT enrichment is identical to the CLI provider: `buildCantEnrichedPrompt()`
+ * is called before `query()` and the result is passed as the SDK prompt string.
+ *
+ * @task T581
+ */
+import type { AdapterSpawnProvider, SpawnContext, SpawnResult } from '@cleocode/contracts';
+/**
+ * Spawn provider that uses the Anthropic Claude Agent SDK for programmatic
+ * subagent execution.
+ *
+ * Each call to `spawn()` runs a full SDK `query()` to completion and
+ * captures the output. Sessions are tracked in `SessionStore` so callers
+ * can inspect active sessions via `listRunning()` and cancel them via
+ * `terminate()`.
+ *
+ * @remarks
+ * The `permissionMode: 'bypassPermissions'` + `allowDangerouslySkipPermissions: true`
+ * combination mirrors the `--dangerously-skip-permissions` flag used by
+ * the CLI provider. Both are required by the SDK when bypassing all tool
+ * permission prompts.
+ */
+export declare class ClaudeSDKSpawnProvider implements AdapterSpawnProvider {
+    /** In-memory session registry. */
+    private readonly sessions;
+    /**
+     * Check whether the SDK can be used in the current environment.
+     *
+     * Returns `true` if `ANTHROPIC_API_KEY` is set. No binary check is needed
+     * because the SDK manages the Claude Code subprocess internally.
+     *
+     * @returns `true` when an API key is present
+     */
+    canSpawn(): Promise<boolean>;
+    /**
+     * Spawn a subagent using the Claude Agent SDK.
+     *
+     * Enriches the prompt via CANT context, runs the SDK `query()` to
+     * completion, captures all assistant text output, and returns a
+     * `SpawnResult` with the final output and exit code.
+     *
+     * @param context - Spawn context with taskId, prompt, options
+     * @returns Resolved spawn result (status: 'completed' or 'failed')
+     */
+    spawn(context: SpawnContext): Promise<SpawnResult>;
+    /**
+     * List sessions currently tracked as active (spawned but not yet completed).
+     *
+     * Because SDK sessions run to completion inside `spawn()`, this list is
+     * typically empty unless concurrent spawns are in flight.
+     *
+     * @returns Array of in-flight spawn results
+     */
+    listRunning(): Promise<SpawnResult[]>;
+    /**
+     * Remove a session from tracking.
+     *
+     * The underlying SDK query runs inside `spawn()` and cannot be cancelled
+     * externally once the async iterator is in flight. Removing the entry from
+     * the store prevents it from appearing in `listRunning()` but does not
+     * interrupt the in-progress HTTP request.
+     *
+     * @param instanceId - ID of the spawn instance to terminate
+     */
+    terminate(instanceId: string): Promise<void>;
+}
+//# sourceMappingURL=spawn.d.ts.map

package/dist/providers/claude-sdk/spawn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-sdk/spawn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAS3F;;;;;;;;;;;;;;GAcG;AACH,qBAAa,sBAAuB,YAAW,oBAAoB;IACjE,kCAAkC;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;IAE/C;;;;;;;OAOG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAIlC;;;;;;;;;OASG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IA6IxD;;;;;;;OAOG;IACG,WAAW,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAU3C;;;;;;;;;OASG;IACG,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGnD"}

package/dist/providers/claude-sdk/tool-bridge.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Tool Bridge for Claude SDK Spawn Provider
+ *
+ * Maps CLEO's tool allowlist (string names) to the SDK's `allowedTools`
+ * option format. The SDK accepts plain tool name strings such as
+ * `"Read"`, `"Bash"`, `"Edit"` for built-in Claude Code tools and
+ * `"mcp__<server>__<tool>"` for MCP-backed tools.
+ *
+ * @task T581
+ */
+/**
+ * Default CLEO tool set passed to the SDK when no explicit allowlist
+ * is provided in `SpawnContext.options.toolAllowlist`.
+ *
+ * Mirrors the standard agent tool surface used by the Claude Code CLI
+ * `--dangerously-skip-permissions` mode.
+ */
+export declare const DEFAULT_TOOLS: readonly string[];
+/**
+ * Resolves a CLEO tool allowlist to the SDK `allowedTools` array.
+ *
+ * When `allowlist` is undefined or empty, the default CLEO tool set is
+ * returned. When an explicit list is provided, it is returned as-is so
+ * callers can pass MCP tool strings (`mcp__server__tool`) alongside
+ * built-in names without transformation.
+ *
+ * @param allowlist - Optional array of tool names from `SpawnContext.options`
+ * @returns Array of SDK-compatible tool name strings
+ *
+ * @example
+ * ```typescript
+ * resolveTools(); // ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep']
+ * resolveTools(['Read', 'Bash']); // ['Read', 'Bash']
+ * resolveTools(['mcp__brain__search']); // ['mcp__brain__search']
+ * ```
+ */
+export declare function resolveTools(allowlist?: string[]): string[];
+//# sourceMappingURL=tool-bridge.d.ts.map

package/dist/providers/claude-sdk/tool-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-bridge.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-sdk/tool-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,MAAM,EAOjC,CAAC;AAEX;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAK3D"}

package/dist/providers/openai-sdk/adapter.d.ts

@@ -0,0 +1,77 @@
+/**
+ * OpenAI Agents SDK Adapter.
+ *
+ * Main `CLEOProviderAdapter` implementation for the OpenAI Agents SDK.
+ * Provides spawn and install capabilities. Hooks are not supported (the
+ * SDK does not expose a CLI hook system equivalent to Claude Code's).
+ *
+ * @task T582
+ */
+import type { AdapterCapabilities, AdapterHealthStatus, CLEOProviderAdapter } from '@cleocode/contracts';
+import { OpenAiSdkInstallProvider } from './install.js';
+import { OpenAiSdkSpawnProvider } from './spawn.js';
+/**
+ * CLEO provider adapter for the OpenAI Agents SDK.
+ *
+ * Bridges CLEO's adapter system with the `@openai/agents` SDK:
+ * - Spawn: Launches agents via the SDK runner with handoff topology
+ * - Install: Manages AGENTS.md @-references and .openai/ config directory
+ * - Tracing: Default-on conduit span persistence via `CleoConduitTraceProcessor`
+ *
+ * @remarks
+ * This adapter is the only CLEO provider with first-class handoff support.
+ * Team Lead → Worker topology is declared in `SpawnContext.options.handoffs`
+ * and wired directly to SDK `Agent.handoffs`. The SDK handles routing
+ * internally without any CLEO glue code.
+ *
+ * This is also the only provider supporting 100+ LLMs via the Vercel AI SDK
+ * bridge (capability flag: `supportsMultiModel`).
+ */
+export declare class OpenAiSdkAdapter implements CLEOProviderAdapter {
+    /** Unique provider identifier. */
+    readonly id = "openai-sdk";
+    /** Human-readable provider name. */
+    readonly name = "OpenAI Agents SDK";
+    /** Adapter version string. */
+    readonly version = "1.0.0";
+    /** Declared capabilities for this provider. */
+    capabilities: AdapterCapabilities;
+    /** Spawn provider for SDK-backed agent runs with handoff topology. */
+    spawn: OpenAiSdkSpawnProvider;
+    /** Install provider for AGENTS.md and .openai/ config directory management. */
+    install: OpenAiSdkInstallProvider;
+    /** Project directory this adapter was initialized with, or null. */
+    private projectDir;
+    /** Whether {@link initialize} has been called. */
+    private initialized;
+    constructor();
+    /**
+     * Initialize the adapter for a given project directory.
+     *
+     * @param projectDir - Root directory of the project.
+     */
+    initialize(projectDir: string): Promise<void>;
+    /**
+     * Dispose the adapter and release all resources.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Run a health check to verify the OpenAI SDK is usable.
+     *
+     * Checks:
+     * 1. Adapter has been initialized
+     * 2. `OPENAI_API_KEY` is set in the environment
+     *
+     * @returns Health status with details about each check.
+     */
+    healthCheck(): Promise<AdapterHealthStatus>;
+    /**
+     * Check whether the adapter has been initialized.
+     */
+    isInitialized(): boolean;
+    /**
+     * Get the project directory this adapter was initialized with.
+     */
+    getProjectDir(): string | null;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/providers/openai-sdk/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/providers/openai-sdk/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,gBAAiB,YAAW,mBAAmB;IAC1D,kCAAkC;IAClC,QAAQ,CAAC,EAAE,gBAAgB;IAC3B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,uBAAuB;IACpC,8BAA8B;IAC9B,QAAQ,CAAC,OAAO,WAAW;IAE3B,+CAA+C;IAC/C,YAAY,EAAE,mBAAmB,CAa/B;IAEF,sEAAsE;IACtE,KAAK,EAAE,sBAAsB,CAAC;IAC9B,+EAA+E;IAC/E,OAAO,EAAE,wBAAwB,CAAC;IAElC,oEAAoE;IACpE,OAAO,CAAC,UAAU,CAAuB;IACzC,kDAAkD;IAClD,OAAO,CAAC,WAAW,CAAS;;IAO5B;;;;OAIG;IACG,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK9B;;;;;;;;OAQG;IACG,WAAW,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAuBjD;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,aAAa,IAAI,MAAM,GAAG,IAAI;CAG/B"}

package/dist/providers/openai-sdk/guardrails.d.ts

@@ -0,0 +1,67 @@
+/**
+ * CLEO permission rules mapped to OpenAI Agents SDK guardrails.
+ *
+ * CLEO ACLs (file-glob path allowlists, tool allowlists) are expressed as
+ * `InputGuardrail` instances that run before agent execution. A path that
+ * falls outside the allowed glob list causes the guardrail to trip and
+ * the agent run is rejected.
+ *
+ * @task T582
+ */
+import type { InputGuardrail } from '@openai/agents';
+/**
+ * Check whether a file-system path is covered by at least one glob pattern.
+ *
+ * @param path - The absolute or relative path to test.
+ * @param allowedGlobs - Array of glob patterns (supports `*` and `**`).
+ * @returns `true` when the path matches at least one pattern.
+ */
+export declare function isPathAllowed(path: string, allowedGlobs: string[]): boolean;
+/**
+ * Build an input guardrail that enforces CLEO file-glob path ACLs.
+ *
+ * Inspects the serialised agent input for embedded `"path":"..."` fields
+ * and rejects the run when a path falls outside the allowlist. This provides
+ * an early-exit safety fence before the agent starts consuming model tokens.
+ *
+ * @param allowedGlobs - Glob patterns that tool path arguments must match.
+ *   Pass an empty array to allow all paths (permissive mode).
+ * @returns An {@link InputGuardrail} ready to attach to an `Agent`.
+ *
+ * @example
+ * ```typescript
+ * const guard = buildPathGuardrail(['/mnt/projects/**', '/tmp/**']);
+ * const agent = new Agent({ ..., inputGuardrails: [guard] });
+ * ```
+ */
+export declare function buildPathGuardrail(allowedGlobs: string[]): InputGuardrail;
+/**
+ * Build an input guardrail that documents the tool allowlist for audit purposes.
+ *
+ * In the OpenAI Agents SDK, tool-name enforcement is primarily structural —
+ * agents only receive the tools attached to their `tools` array. This guardrail
+ * provides an additional audit layer that records the active allowlist in the
+ * span metadata.
+ *
+ * @param allowedTools - Exact tool names permitted for this agent.
+ *   Pass an empty array to allow all tools (permissive mode).
+ * @returns An {@link InputGuardrail} ready to attach to an `Agent`.
+ *
+ * @example
+ * ```typescript
+ * const guard = buildToolAllowlistGuardrail(['read', 'write']);
+ * ```
+ */
+export declare function buildToolAllowlistGuardrail(allowedTools: string[]): InputGuardrail;
+/**
+ * Build the default CLEO guardrail set from spawn options.
+ *
+ * Combines path ACL and tool allowlist guards into a single array ready to
+ * pass as `inputGuardrails` on an `Agent` or `RunConfig`.
+ *
+ * @param allowedGlobs - File-path glob allowlist.
+ * @param allowedTools - Tool name allowlist.
+ * @returns Array of input guardrails to attach to the agent.
+ */
+export declare function buildDefaultGuardrails(allowedGlobs: string[], allowedTools: string[]): InputGuardrail[];
+//# sourceMappingURL=guardrails.d.ts.map

package/dist/providers/openai-sdk/guardrails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guardrails.d.ts","sourceRoot":"","sources":["../../../src/providers/openai-sdk/guardrails.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAA8B,MAAM,gBAAgB,CAAC;AAwBjF;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAG3E;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,cAAc,CA6BzE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,cAAc,CAclF;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EAAE,EACtB,YAAY,EAAE,MAAM,EAAE,GACrB,cAAc,EAAE,CAYlB"}

package/dist/providers/openai-sdk/handoff.d.ts

@@ -0,0 +1,94 @@
+/**
+ * CLEO Team topology → OpenAI Agents SDK handoff mapping.
+ *
+ * CLEO agents are organised in a Lead → Worker hierarchy. This module maps
+ * that topology to the SDK's first-class `handoffs` graph:
+ *
+ * - A Team Lead becomes an `Agent` whose `handoffs` array lists its workers.
+ * - Each Worker archetype (read-only, write, bash) is declared in
+ *   `WORKER_ARCHETYPES` and built on demand.
+ * - The mapping is driven by `SpawnContext.options.handoffs`, which is an
+ *   array of worker archetype names.
+ *
+ * @task T582
+ */
+import type { InputGuardrail } from '@openai/agents';
+import { Agent } from '@openai/agents';
+/**
+ * Descriptor for a pre-configured worker agent archetype.
+ *
+ * Archetypes are declarative templates. `buildWorkerAgent` inflates them into
+ * live SDK `Agent` instances.
+ */
+export interface WorkerArchetype {
+    /** Archetype identifier (also used as SDK agent name). */
+    name: string;
+    /** Short description passed as the SDK agent instructions. */
+    instructions: string;
+    /** Preferred model for this archetype. */
+    model: string;
+}
+/**
+ * Registry of built-in CLEO worker archetypes.
+ *
+ * Callers reference these by name in `SpawnContext.options.handoffs`.
+ * New archetypes can be added here without changing the spawn provider.
+ */
+export declare const WORKER_ARCHETYPES: Record<string, WorkerArchetype>;
+/**
+ * Build a worker `Agent` instance from a named archetype.
+ *
+ * @param archetypeName - Key in {@link WORKER_ARCHETYPES}.
+ * @param guardrails - Input guardrails to attach to the worker agent.
+ * @returns A configured SDK `Agent` or `null` when the archetype is unknown.
+ */
+export declare function buildWorkerAgent(archetypeName: string, guardrails: InputGuardrail[]): Agent | null;
+/**
+ * Build a team lead `Agent` whose `handoffs` reference the given workers.
+ *
+ * @param leadInstructions - System instructions for the lead agent.
+ * @param leadModel - Model to use for the lead agent.
+ * @param workers - Worker agents this lead can hand off to.
+ * @param guardrails - Input guardrails to attach to the lead agent.
+ * @returns A configured lead SDK `Agent`.
+ */
+export declare function buildLeadAgent(leadInstructions: string, leadModel: string, workers: Agent[], guardrails: InputGuardrail[]): Agent;
+/**
+ * Build a simple single-tier agent (no handoffs) from prompt and model.
+ *
+ * Used when `SpawnContext.options.tier` is `'worker'` or when no handoff
+ * names are provided.
+ *
+ * @param instructions - Agent system instructions.
+ * @param model - Model identifier.
+ * @param guardrails - Input guardrails.
+ * @returns A configured SDK `Agent`.
+ */
+export declare function buildStandaloneAgent(instructions: string, model: string, guardrails: InputGuardrail[]): Agent;
+/** Options for building the agent topology from a spawn context. */
+export interface TopologyOptions {
+    /** Prompt / instructions for the entry-point agent. */
+    instructions: string;
+    /** Model to use for the lead / standalone agent. */
+    model: string;
+    /** Agent tier determines whether workers and handoffs are wired. */
+    tier: 'lead' | 'worker' | 'orchestrator';
+    /** Names of worker archetypes to create and attach as handoffs. */
+    handoffNames: string[];
+    /** Input guardrails shared across all agents in the topology. */
+    guardrails: InputGuardrail[];
+}
+/**
+ * Build the entry-point agent and its worker topology from spawn options.
+ *
+ * - `tier === 'lead'` or `tier === 'orchestrator'`: creates a lead agent with
+ *   worker handoffs derived from `handoffNames`.
+ * - `tier === 'worker'`: creates a standalone agent with no handoffs.
+ *
+ * Unknown archetype names in `handoffNames` are silently skipped.
+ *
+ * @param options - Topology build options.
+ * @returns The entry-point agent to pass to `runner.run()`.
+ */
+export declare function buildAgentTopology(options: TopologyOptions): Agent;
+//# sourceMappingURL=handoff.d.ts.map

package/dist/providers/openai-sdk/handoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff.d.ts","sourceRoot":"","sources":["../../../src/providers/openai-sdk/handoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAMvC;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,YAAY,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAmB7D,CAAC;AAMF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,cAAc,EAAE,GAC3B,KAAK,GAAG,IAAI,CAUd;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,gBAAgB,EAAE,MAAM,EACxB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,KAAK,EAAE,EAChB,UAAU,EAAE,cAAc,EAAE,GAC3B,KAAK,CAQP;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,cAAc,EAAE,GAC3B,KAAK,CAOP;AAMD,oEAAoE;AACpE,MAAM,WAAW,eAAe;IAC9B,uDAAuD;IACvD,YAAY,EAAE,MAAM,CAAC;IACrB,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,cAAc,CAAC;IACzC,mEAAmE;IACnE,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,iEAAiE;IACjE,UAAU,EAAE,cAAc,EAAE,CAAC;CAC9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,GAAG,KAAK,CAkBlE"}

package/dist/providers/openai-sdk/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @packageDocumentation
+ *
+ * CLEO provider adapter for the OpenAI Agents SDK.
+ * Default export is the adapter class for dynamic loading by AdapterManager.
+ *
+ * @task T582
+ */
+import { OpenAiSdkAdapter } from './adapter.js';
+export { OpenAiSdkAdapter } from './adapter.js';
+export { buildDefaultGuardrails, buildPathGuardrail, buildToolAllowlistGuardrail, isPathAllowed, } from './guardrails.js';
+export type { TopologyOptions, WorkerArchetype } from './handoff.js';
+export { buildAgentTopology, buildLeadAgent, buildStandaloneAgent, buildWorkerAgent, WORKER_ARCHETYPES, } from './handoff.js';
+export { OpenAiSdkInstallProvider } from './install.js';
+export type { OpenAiSdkSpawnOptions } from './spawn.js';
+export { OpenAiSdkSpawnProvider } from './spawn.js';
+export { CleoConduitTraceProcessor } from './tracing.js';
+export default OpenAiSdkAdapter;
+/**
+ * Factory function for creating adapter instances.
+ * Used by AdapterManager's dynamic import fallback.
+ *
+ * @remarks
+ * This is the primary entry point for dynamic adapter loading.
+ * AdapterManager calls this function when it resolves the openai-sdk
+ * provider via its import-based discovery mechanism.
+ *
+ * @returns A new {@link OpenAiSdkAdapter} instance ready for initialization.
+ *
+ * @example
+ * ```typescript
+ * import { createAdapter } from '@cleocode/adapters/providers/openai-sdk';
+ *
+ * const adapter = createAdapter();
+ * await adapter.initialize('/path/to/project');
+ * ```
+ */
+export declare function createAdapter(): OpenAiSdkAdapter;
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/openai-sdk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/openai-sdk/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,2BAA2B,EAC3B,aAAa,GACd,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AACxD,YAAY,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAEzD,eAAe,gBAAgB,CAAC;AAEhC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,IAAI,gBAAgB,CAEhD"}