@robota-sdk/agent-sdk 3.0.0-beta.3 → 3.0.0-beta.31

package/dist/node/index.d.ts

@@ -1,202 +1,84 @@
-import { TPermissionMode, IAIProvider, TToolArgs, TTrustLevel } from '@robota-sdk/agent-core';
+import { IHookTypeExecutor, IHookDefinition, IHookInput, IHookResult, THooksConfig, TTrustLevel, TPermissionMode, IAIProvider, TToolArgs, IToolWithEventService } from '@robota-sdk/agent-core';
 export { IContextTokenUsage, IContextWindowState, IHookInput, IPermissionLists, THookEvent, THooksConfig, TPermissionDecision, TPermissionMode, TRUST_TO_MODE, TToolArgs, TTrustLevel, evaluatePermission, runHooks } from '@robota-sdk/agent-core';
 import * as _robota_sdk_agent_tools from '@robota-sdk/agent-tools';
 export { TToolResult, bashTool, editTool, globTool, grepTool, readTool, writeTool } from '@robota-sdk/agent-tools';
-import { ITerminalOutput, IResolvedConfig as IResolvedConfig$1, ILoadedContext as ILoadedContext$1, IProjectInfo as IProjectInfo$1 } from '@robota-sdk/agent-sessions';
+import { ITerminalOutput, SessionStore, TPermissionHandler, ISessionLogger, Session } from '@robota-sdk/agent-sessions';
 export { FileSessionLogger, ISessionLogger, ISessionOptions, ISessionRecord, ISpinner, ITerminalOutput, Session, SessionStore, SilentSessionLogger, TPermissionHandler, TPermissionResult, TSessionLogData } from '@robota-sdk/agent-sessions';
-import { z } from 'zod';
 
 /**
- * query() — single entry point for running an AI agent conversation.
- * Automatically loads config, context, and project info.
+ * Prompt hook executor — evaluates a prompt via an AI model.
+ *
+ * Makes a single-turn LLM call with hook input context as the prompt.
+ * Parses { ok: boolean, reason?: string } from the AI response.
+ *
+ * Exit codes:
+ * - 0: ok: true (allow/proceed)
+ * - 2: ok: false (block/deny), reason in stderr
+ * - 1: execution error (provider failure, parse error)
  */
 
-interface IQueryOptions {
-    cwd?: string;
-    permissionMode?: TPermissionMode;
-    maxTurns?: number;
-    provider?: IAIProvider;
-    permissionHandler?: (toolName: string, toolArgs: TToolArgs) => Promise<boolean>;
-    onTextDelta?: (delta: string) => void;
-    /** Callback when context is compacted */
-    onCompact?: (summary: string) => void;
+/** A minimal provider interface for single-turn completion. */
+interface IPromptProvider {
+    complete(prompt: string): Promise<string>;
 }
+/** Factory that creates a provider instance, optionally for a specific model. */
+type TProviderFactory = (model?: string) => IPromptProvider;
+/** Constructor options for PromptExecutor. */
+interface IPromptExecutorOptions {
+    providerFactory: TProviderFactory;
+    defaultModel?: string;
+}
+declare class PromptExecutor implements IHookTypeExecutor {
+    readonly type: "prompt";
+    private readonly providerFactory;
+    private readonly defaultModel;
+    constructor(options: IPromptExecutorOptions);
+    execute(definition: IHookDefinition, input: IHookInput): Promise<IHookResult>;
+}
+
 /**
- * query() — single entry point for running an AI agent conversation.
- * Equivalent to Claude Agent SDK's query() function.
- * Automatically loads config, context, and project info.
+ * Agent hook executor — delegates to a sub-agent session.
+ *
+ * Creates a subagent session with maxTurns and timeout limits,
+ * runs hook input as the initial prompt, and parses the result.
+ *
+ * Exit codes:
+ * - 0: ok: true (allow/proceed)
+ * - 2: ok: false (block/deny), reason in stderr
+ * - 1: execution error (session failure, parse error)
  */
-declare function query(prompt: string, options?: IQueryOptions): Promise<string>;
+
+/** A minimal session interface for running a prompt. */
+interface IAgentSession {
+    run(prompt: string): Promise<string>;
+}
+/** Factory that creates a session instance with the given options. */
+type TSessionFactory = (options: {
+    maxTurns?: number;
+    timeout?: number;
+}) => IAgentSession;
+/** Constructor options for AgentExecutor. */
+interface IAgentExecutorOptions {
+    sessionFactory: TSessionFactory;
+}
+declare class AgentExecutor implements IHookTypeExecutor {
+    readonly type: "agent";
+    private readonly sessionFactory;
+    constructor(options: IAgentExecutorOptions);
+    execute(definition: IHookDefinition, input: IHookInput): Promise<IHookResult>;
+}
 
 /**
  * Zod schemas and TypeScript types for Robota CLI settings
  */
 
-declare const HooksSchema: z.ZodOptional<z.ZodObject<{
-    PreToolUse: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        matcher: z.ZodString;
-        hooks: z.ZodArray<z.ZodObject<{
-            type: z.ZodLiteral<"command">;
-            command: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            type: "command";
-            command: string;
-        }, {
-            type: "command";
-            command: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }>, "many">>;
-    PostToolUse: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        matcher: z.ZodString;
-        hooks: z.ZodArray<z.ZodObject<{
-            type: z.ZodLiteral<"command">;
-            command: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            type: "command";
-            command: string;
-        }, {
-            type: "command";
-            command: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }>, "many">>;
-    SessionStart: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        matcher: z.ZodString;
-        hooks: z.ZodArray<z.ZodObject<{
-            type: z.ZodLiteral<"command">;
-            command: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            type: "command";
-            command: string;
-        }, {
-            type: "command";
-            command: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }>, "many">>;
-    Stop: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        matcher: z.ZodString;
-        hooks: z.ZodArray<z.ZodObject<{
-            type: z.ZodLiteral<"command">;
-            command: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            type: "command";
-            command: string;
-        }, {
-            type: "command";
-            command: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }>, "many">>;
-}, "strip", z.ZodTypeAny, {
-    PreToolUse?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    PostToolUse?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    SessionStart?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    Stop?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-}, {
-    PreToolUse?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    PostToolUse?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    SessionStart?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    Stop?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-}>>;
 /**
  * Fully resolved config after merging all settings files and applying defaults.
  */
 interface IResolvedConfig {
     defaultTrustLevel: 'safe' | 'moderate' | 'full';
+    /** Response language code (e.g., "ko", "en"). Undefined = no language constraint. */
+    language?: string;
     provider: {
         name: string;
         model: string;
@@ -207,16 +89,21 @@ interface IResolvedConfig {
         deny: string[];
     };
     env: Record<string, string>;
-    hooks?: z.infer<typeof HooksSchema>;
+    hooks?: THooksConfig;
+    /** Plugin enablement map: plugin name -> enabled/disabled */
+    enabledPlugins?: Record<string, boolean>;
+    /** Extra marketplace sources: name -> { source } */
+    extraKnownMarketplaces?: Record<string, {
+        source: {
+            type: string;
+            repo?: string;
+            url?: string;
+            path?: string;
+            ref?: string;
+        };
+    }>;
 }
 
-/**
- * Load and merge all settings files, validate with Zod, return resolved config.
- *
- * @param cwd - The working directory (project root) to search for .robota/
- */
-declare function loadConfig(cwd: string): Promise<IResolvedConfig>;
-
 interface ILoadedContext {
     /** Concatenated content of all AGENTS.md files found (root-first) */
     agentsMd: string;
@@ -264,16 +151,141 @@ interface ISystemPromptParams {
     trustLevel: TTrustLevel;
     /** Detected project metadata */
     projectInfo: IProjectInfo;
+    /** Current working directory */
+    cwd?: string;
+    /** Response language code (e.g., "ko", "en"). If set, AI must respond in this language. */
+    language?: string;
+    /** Discovered skills to expose in the system prompt */
+    skills?: Array<{
+        name: string;
+        description: string;
+        disableModelInvocation?: boolean;
+    }>;
 }
+declare function buildSystemPrompt(params: ISystemPromptParams): string;
+
 /**
- * Assemble the full system prompt string from the provided parameters.
+ * Session factory — assembles a fully-configured Session from config, context,
+ * tools, and provider.
+ *
+ * This is the main entry point for creating sessions. It wires together
+ * the provider, tools, system prompt, and configuration that Session now
+ * expects as pre-constructed dependencies.
  */
-declare function buildSystemPrompt(params: ISystemPromptParams): string;
+
+/** Options for the createSession factory */
+interface ICreateSessionOptions {
+    /** Resolved CLI configuration (model, API key, permissions) */
+    config: IResolvedConfig;
+    /** Loaded AGENTS.md / CLAUDE.md context */
+    context: ILoadedContext;
+    /** Terminal I/O for permission prompts */
+    terminal: ITerminalOutput;
+    /** Project metadata for system prompt */
+    projectInfo?: IProjectInfo;
+    /** Initial permission mode (defaults to config.defaultTrustLevel → mode mapping) */
+    permissionMode?: TPermissionMode;
+    /** Maximum number of agentic turns per run() call. Undefined = unlimited. */
+    maxTurns?: number;
+    /** Optional session store for persistence */
+    sessionStore?: SessionStore;
+    /** Inject a pre-constructed AI provider (used by tests to avoid real API calls) */
+    provider?: IAIProvider;
+    /** Custom permission handler (overrides terminal-based prompts, used by Ink UI) */
+    permissionHandler?: TPermissionHandler;
+    /** Callback for text deltas — enables streaming text to the UI in real-time */
+    onTextDelta?: (delta: string) => void;
+    /** Custom prompt-for-approval function (injected from CLI) */
+    promptForApproval?: (terminal: ITerminalOutput, toolName: string, toolArgs: TToolArgs) => Promise<boolean>;
+    /** Additional tools to register beyond the defaults (e.g. agent-tool) */
+    additionalTools?: IToolWithEventService[];
+    /** Callback when a tool starts or finishes execution — enables real-time tool display in UI */
+    onToolExecution?: (event: {
+        type: 'start' | 'end';
+        toolName: string;
+        toolArgs?: TToolArgs;
+        success?: boolean;
+    }) => void;
+    /** Callback when context is compacted */
+    onCompact?: (summary: string) => void;
+    /** Instructions to include in the compaction prompt (e.g. from CLAUDE.md) */
+    compactInstructions?: string;
+    /** Custom system prompt builder function */
+    systemPromptBuilder?: (params: ISystemPromptParams) => string;
+    /** Custom tool descriptions for the system prompt */
+    toolDescriptions?: string[];
+    /** Session logger — injected for pluggable session event logging. */
+    sessionLogger?: ISessionLogger;
+    /** Provider factory for prompt hook executors (DI). */
+    providerFactory?: TProviderFactory;
+    /** Session factory for agent hook executors (DI). */
+    sessionFactory?: TSessionFactory;
+    /** Additional hook type executors beyond the defaults (prompt, agent). */
+    additionalHookExecutors?: IHookTypeExecutor[];
+}
+/**
+ * Create a fully-configured Session instance.
+ *
+ * Assembles provider, tools, and system prompt, then passes them
+ * to Session as pre-constructed dependencies.
+ */
+declare function createSession(options: ICreateSessionOptions): Session;
+
+/**
+ * Default tool set factory — creates the standard set of CLI tools.
+ */
+
+/** Human-readable descriptions of the built-in tools (for system prompt) */
+declare const DEFAULT_TOOL_DESCRIPTIONS: string[];
+/**
+ * Create the default set of CLI tools.
+ * Returns the 8 standard tools as IToolWithEventService[].
+ */
+declare function createDefaultTools(): IToolWithEventService[];
+
+/**
+ * Provider factory — creates an AI provider from resolved config.
+ */
+
+/**
+ * Create an AI provider from the resolved config.
+ * Currently supports Anthropic only. Throws if no API key is available.
+ */
+declare function createProvider(config: IResolvedConfig): IAIProvider;
+
+/**
+ * query() — single entry point for running an AI agent conversation.
+ * Automatically loads config, context, and project info.
+ */
+
+interface IQueryOptions {
+    cwd?: string;
+    permissionMode?: TPermissionMode;
+    maxTurns?: number;
+    provider?: IAIProvider;
+    permissionHandler?: (toolName: string, toolArgs: TToolArgs) => Promise<boolean>;
+    onTextDelta?: (delta: string) => void;
+    /** Callback when context is compacted */
+    onCompact?: (summary: string) => void;
+}
+/**
+ * query() — single entry point for running an AI agent conversation.
+ * Equivalent to Claude Agent SDK's query() function.
+ * Automatically loads config, context, and project info.
+ */
+declare function query(prompt: string, options?: IQueryOptions): Promise<string>;
 
 /**
- * Permission prompt — this is now CLI-specific.
- * Re-exported here for backward compatibility.
- * The canonical implementation lives in @robota-sdk/agent-cli.
+ * Load and merge all settings files, validate with Zod, return resolved config.
+ *
+ * @param cwd - The working directory (project root) to search for settings
+ */
+declare function loadConfig(cwd: string): Promise<IResolvedConfig>;
+
+/**
+ * Interactive permission prompt — asks the user whether to allow a tool invocation
+ * using an arrow-key selector. Canonical implementation (SSOT).
+ * Used by both agent-sdk query() and agent-cli.
  */
 
 /**
@@ -300,14 +312,376 @@ declare function userPaths(): {
     sessions: string;
 };
 
+/**
+ * PluginSettingsStore — single point of read/write for plugin-related settings.
+ *
+ * Shared by MarketplaceClient and BundlePluginInstaller to prevent
+ * concurrent writes from overwriting each other's changes.
+ */
+/** Source type for a marketplace registry. */
+type IMarketplaceSource$1 = {
+    type: 'github';
+    repo: string;
+    ref?: string;
+} | {
+    type: 'git';
+    url: string;
+    ref?: string;
+} | {
+    type: 'local';
+    path: string;
+} | {
+    type: 'url';
+    url: string;
+};
+/** Persisted marketplace source entry. */
+interface IPersistedMarketplaceSource {
+    source: IMarketplaceSource$1;
+}
+/** Shape of the plugin-related keys in settings.json. */
+interface IPluginSettings {
+    enabledPlugins: Record<string, boolean>;
+    extraKnownMarketplaces: Record<string, IPersistedMarketplaceSource>;
+}
+/** Centralized settings store for plugin configuration. */
+declare class PluginSettingsStore {
+    private readonly settingsPath;
+    constructor(settingsPath: string);
+    /** Read the full settings file from disk. */
+    private readAll;
+    /** Write the full settings file to disk. */
+    private writeAll;
+    /** Get the enabledPlugins map. */
+    getEnabledPlugins(): Record<string, boolean>;
+    /** Set a single plugin's enabled state. */
+    setPluginEnabled(pluginId: string, enabled: boolean): void;
+    /** Remove a plugin from enabledPlugins. */
+    removePluginEntry(pluginId: string): void;
+    /** Get all persisted marketplace sources. */
+    getMarketplaceSources(): Record<string, IPersistedMarketplaceSource>;
+    /** Add or update a marketplace source. */
+    setMarketplaceSource(name: string, source: IMarketplaceSource$1): void;
+    /** Remove a marketplace source. */
+    removeMarketplaceSource(name: string): void;
+    private getEnabledPluginsFrom;
+    private getMarketplaceSourcesFrom;
+}
+
+/**
+ * Types for the BundlePlugin system.
+ *
+ * A BundlePlugin is a directory-based plugin package that bundles
+ * skills, hooks, agents, and MCP server configurations.
+ */
+/** Feature flags indicating what a bundle plugin provides. */
+interface IBundlePluginFeatures {
+    commands?: boolean;
+    agents?: boolean;
+    skills?: boolean;
+    hooks?: boolean;
+    mcp?: boolean;
+}
+/** Manifest read from `.claude-plugin/plugin.json`. */
+interface IBundlePluginManifest {
+    name: string;
+    version: string;
+    description: string;
+    features: IBundlePluginFeatures;
+}
+/** A skill loaded from a bundle plugin's `skills/` directory. */
+interface IBundleSkill {
+    name: string;
+    description: string;
+    skillContent: string;
+    [key: string]: unknown;
+}
+/** A fully loaded bundle plugin with all its assets. */
+interface ILoadedBundlePlugin {
+    manifest: IBundlePluginManifest;
+    skills: IBundleSkill[];
+    commands: IBundleSkill[];
+    hooks: Record<string, unknown>;
+    mcpConfig?: unknown;
+    agents: string[];
+    pluginDir: string;
+}
+/** Map of plugin identifiers to enabled/disabled state. */
+type TEnabledPlugins = Record<string, boolean>;
+
+/**
+ * BundlePluginLoader — discovers and loads directory-based bundle plugins.
+ *
+ * Scans the cache directory (`<pluginsDir>/cache/<marketplace>/<plugin>/<version>/`)
+ * for subdirectories containing `.claude-plugin/plugin.json`,
+ * reads manifests, loads skills (with frontmatter parsing), hooks, and agent definitions.
+ *
+ * For each plugin, the latest version directory (lexicographically last) is loaded.
+ */
+
+/** Loader for directory-based bundle plugins from the cache directory. */
+declare class BundlePluginLoader {
+    private readonly pluginsDir;
+    private readonly enabledPlugins;
+    constructor(pluginsDir: string, enabledPlugins?: TEnabledPlugins);
+    /** Load all discovered and enabled bundle plugins (sync). */
+    loadPluginsSync(): ILoadedBundlePlugin[];
+    /** Load all discovered and enabled bundle plugins (async wrapper). */
+    loadAll(): Promise<ILoadedBundlePlugin[]>;
+    /**
+     * Discover and load plugins from the cache directory.
+     *
+     * Directory structure: `<pluginsDir>/cache/<marketplace>/<plugin>/<version>/`
+     * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
+     */
+    private discoverAndLoad;
+    /** Read and validate a plugin.json manifest. Returns null on failure. */
+    private readManifest;
+    /**
+     * Check if a plugin is explicitly disabled.
+     * Checks both `name@marketplace` and `name` keys.
+     * Plugins not listed in enabledPlugins are enabled by default.
+     */
+    private isDisabled;
+    /** Load a single plugin's skills, hooks, agents, and MCP config. */
+    private loadPlugin;
+    /** Load skills from the plugin's skills/ directory. */
+    private loadSkills;
+    /** Load commands from the plugin's commands/ directory (flat .md files). */
+    private loadCommands;
+    /** Load hooks from hooks/hooks.json if present. */
+    private loadHooks;
+    /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
+    private loadMcpConfig;
+    /** Load agent definitions from agents/ directory if present. */
+    private loadAgents;
+}
+
+/**
+ * MarketplaceClient — manages marketplace registries via shallow git clones.
+ *
+ * Marketplaces are git repositories containing `.claude-plugin/marketplace.json`.
+ * They are cloned to `~/.robota/plugins/marketplaces/<name>/` and tracked
+ * in `known_marketplaces.json`.
+ */
+/** Source specification for a marketplace. */
+type IMarketplaceSource = {
+    type: 'github';
+    repo: string;
+    ref?: string;
+} | {
+    type: 'git';
+    url: string;
+    ref?: string;
+} | {
+    type: 'local';
+    path: string;
+} | {
+    type: 'url';
+    url: string;
+};
+/** A single plugin entry in a marketplace manifest. */
+interface IMarketplacePluginEntry {
+    name: string;
+    title: string;
+    description: string;
+    source: string | {
+        type: 'github';
+        repo: string;
+    } | {
+        type: 'url';
+        url: string;
+    };
+    tags: string[];
+}
+/** Manifest format read from `.claude-plugin/marketplace.json`. */
+interface IMarketplaceManifest {
+    name: string;
+    version: string;
+    plugins: IMarketplacePluginEntry[];
+}
+/** Entry in known_marketplaces.json. */
+interface IKnownMarketplaceEntry {
+    source: IMarketplaceSource;
+    installLocation: string;
+    lastUpdated: string;
+}
+/** Shape of known_marketplaces.json. */
+type IKnownMarketplacesRegistry = Record<string, IKnownMarketplaceEntry>;
+/** Exec function type for running shell commands. */
+type ExecFn$1 = (command: string, options: {
+    timeout: number;
+    stdio?: string;
+}) => string | Buffer;
+/** Options for constructing a MarketplaceClient. */
+interface IMarketplaceClientOptions {
+    /** Base plugins directory (e.g., `~/.robota/plugins`). */
+    pluginsDir: string;
+    /** Custom exec function for testing (replaces child_process.execSync). */
+    exec?: ExecFn$1;
+}
+/** Manages marketplace registries via shallow git clones. */
+declare class MarketplaceClient {
+    private readonly pluginsDir;
+    private readonly exec;
+    private readonly marketplacesDir;
+    private readonly registryPath;
+    constructor(options: IMarketplaceClientOptions);
+    /**
+     * Add a marketplace by cloning its repository.
+     *
+     * 1. Parse source: `owner/repo` string becomes a GitHub source.
+     * 2. Shallow git clone (`--depth 1`) to `marketplaces/<name>/`.
+     * 3. Read `.claude-plugin/marketplace.json` for the `name` field.
+     * 4. Register in `known_marketplaces.json`.
+     *
+     * Returns the registered marketplace name from the manifest.
+     */
+    addMarketplace(source: IMarketplaceSource): string;
+    /**
+     * Remove a marketplace.
+     * Uninstalls all plugins from that marketplace, then deletes the clone directory
+     * and removes from the registry.
+     */
+    removeMarketplace(name: string): void;
+    /**
+     * Update a marketplace by running git pull on its clone.
+     * The manifest is re-read from disk on demand (via fetchManifest), so the
+     * updated manifest is automatically available after pull.
+     *
+     * TODO: After pull, detect version changes in installed plugins and offer
+     * to update them (re-install at new version).
+     */
+    updateMarketplace(name: string): void;
+    /** List all registered marketplaces. */
+    listMarketplaces(): Array<{
+        name: string;
+        source: IMarketplaceSource;
+        lastUpdated: string;
+    }>;
+    /**
+     * Read the marketplace manifest from a registered marketplace's clone.
+     */
+    fetchManifest(marketplaceName: string): IMarketplaceManifest;
+    /** Get the clone directory path for a registered marketplace. */
+    getMarketplaceDir(name: string): string;
+    /**
+     * Get the current git SHA (first 12 chars) for a marketplace clone.
+     * Used as a version identifier when plugins lack explicit versions.
+     */
+    getMarketplaceSha(name: string): string;
+    /** List all available plugins across all marketplaces. */
+    listAvailablePlugins(): Array<IMarketplacePluginEntry & {
+        marketplace: string;
+    }>;
+    /** Resolve a marketplace source to a git clone URL. */
+    private resolveCloneUrl;
+    /**
+     * Remove all installed plugins that belong to a given marketplace.
+     * Reads installed_plugins.json, deletes cache directories for matching plugins,
+     * and updates the registry.
+     */
+    private removeInstalledPluginsForMarketplace;
+    /** Read and parse a marketplace.json from a file path. */
+    private readManifestFromPath;
+    /** Read the known_marketplaces.json registry. */
+    private readRegistry;
+    /** Write the known_marketplaces.json registry. */
+    private writeRegistry;
+    /** Default exec implementation using child_process. */
+    private defaultExec;
+}
+
+/**
+ * BundlePluginInstaller — installs, uninstalls, enables, and disables bundle plugins.
+ *
+ * Resolves plugin sources from marketplace manifests, copies/clones to the
+ * cache directory, and tracks installations in `installed_plugins.json`.
+ */
+
+/** Record of an installed plugin in installed_plugins.json. */
+interface IInstalledPluginRecord {
+    pluginName: string;
+    marketplace: string;
+    version: string;
+    installPath: string;
+    installedAt: string;
+}
+/** Shape of installed_plugins.json. */
+type IInstalledPluginsRegistry = Record<string, IInstalledPluginRecord>;
+/** Exec function type for running shell commands. */
+type ExecFn = (command: string, options: {
+    timeout: number;
+    stdio?: string;
+}) => string | Buffer;
+/** Options for constructing a BundlePluginInstaller. */
+interface IBundlePluginInstallerOptions {
+    /** Base plugins directory (e.g., `~/.robota/plugins`). */
+    pluginsDir: string;
+    /** Shared settings store for enable/disable persistence. */
+    settingsStore: PluginSettingsStore;
+    /** MarketplaceClient for reading marketplace manifests. */
+    marketplaceClient: MarketplaceClient;
+    /** Custom exec function for testing (replaces child_process.execSync). */
+    exec?: ExecFn;
+}
+/** Installs, uninstalls, enables, and disables bundle plugins. */
+declare class BundlePluginInstaller {
+    private readonly pluginsDir;
+    private readonly cacheDir;
+    private readonly registryPath;
+    private readonly settingsStore;
+    private readonly marketplaceClient;
+    private readonly exec;
+    constructor(options: IBundlePluginInstallerOptions);
+    /**
+     * Install a plugin from a marketplace.
+     *
+     * 1. Read marketplace manifest to find the plugin entry.
+     * 2. Resolve source (relative path, github, or url).
+     * 3. Copy/clone to `cache/<marketplace>/<plugin>/<version>/`.
+     * 4. Record in `installed_plugins.json`.
+     */
+    install(pluginName: string, marketplaceName: string): Promise<void>;
+    /**
+     * Uninstall a plugin.
+     * Removes from cache and from installed_plugins.json.
+     */
+    uninstall(pluginId: string): Promise<void>;
+    /** Enable a plugin by setting its enabledPlugins entry to true. */
+    enable(pluginId: string): Promise<void>;
+    /** Disable a plugin by setting its enabledPlugins entry to false. */
+    disable(pluginId: string): Promise<void>;
+    /** Get all installed plugins. */
+    getInstalledPlugins(): IInstalledPluginsRegistry;
+    /** Get plugins installed from a specific marketplace. */
+    getPluginsByMarketplace(marketplaceName: string): IInstalledPluginRecord[];
+    /** Resolve the version for a plugin entry. */
+    private resolveVersion;
+    /**
+     * Normalize source object — Claude Code manifests use `source` key instead of `type`.
+     * e.g., { source: "url", url: "..." } → { type: "url", url: "..." }
+     */
+    private normalizeSource;
+    /** Resolve the source and install the plugin. */
+    private resolveAndInstall;
+    /** Clone a git repository to the target directory. */
+    private cloneToDir;
+    /** Read the installed_plugins.json registry. */
+    private readRegistry;
+    /** Write the installed_plugins.json registry. */
+    private writeRegistry;
+    /** Default exec implementation using child_process. */
+    private defaultExec;
+}
+
 /** Dependencies injected at registration time */
 interface IAgentToolDeps {
-    config: IResolvedConfig$1;
-    context: ILoadedContext$1;
-    projectInfo?: IProjectInfo$1;
+    config: IResolvedConfig;
+    context: ILoadedContext;
+    projectInfo?: IProjectInfo;
 }
 /** Set dependencies for the agent tool. Must be called before tool is used. */
 declare function setAgentToolDeps(deps: IAgentToolDeps): void;
 declare const agentTool: _robota_sdk_agent_tools.FunctionTool;
 
-export { type ILoadedContext, type IProjectInfo, type IQueryOptions, type IResolvedConfig, type ISystemPromptParams, agentTool, buildSystemPrompt, detectProject, loadConfig, loadContext, projectPaths, promptForApproval, query, setAgentToolDeps, userPaths };
+export { AgentExecutor, BundlePluginInstaller, BundlePluginLoader, DEFAULT_TOOL_DESCRIPTIONS, type IAgentExecutorOptions, type IAgentSession, type IBundlePluginFeatures, type IBundlePluginInstallerOptions, type IBundlePluginManifest, type IBundleSkill, type ICreateSessionOptions, type IInstalledPluginRecord, type IInstalledPluginsRegistry, type IKnownMarketplaceEntry, type IKnownMarketplacesRegistry, type ILoadedBundlePlugin, type ILoadedContext, type IMarketplaceClientOptions, type IMarketplaceManifest, type IMarketplacePluginEntry, type IMarketplaceSource, type IPluginSettings, type IProjectInfo, type IPromptExecutorOptions, type IPromptProvider, type IQueryOptions, type IResolvedConfig, type ISystemPromptParams, MarketplaceClient, PluginSettingsStore, PromptExecutor, type TEnabledPlugins, type TProviderFactory, type TSessionFactory, agentTool, buildSystemPrompt, createDefaultTools, createProvider, createSession, detectProject, loadConfig, loadContext, projectPaths, promptForApproval, query, setAgentToolDeps, userPaths };