@robota-sdk/agent-sdk 3.0.0-beta.4 → 3.0.0-beta.43

package/dist/node/index.d.cts

@@ -1,180 +1,84 @@
-import { TTrustLevel, TPermissionMode, IAIProvider, TToolArgs, IToolWithEventService } from '@robota-sdk/agent-core';
+import { IHookTypeExecutor, IHookDefinition, IHookInput, IHookResult, THooksConfig, TTrustLevel, TPermissionMode, IAIProvider, TToolArgs, IToolWithEventService, TUniversalMessage, IContextWindowState } 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';
+import { createZodFunctionTool } from '@robota-sdk/agent-tools';
 export { TToolResult, bashTool, editTool, globTool, grepTool, readTool, writeTool } from '@robota-sdk/agent-tools';
-import { ITerminalOutput, SessionStore, TPermissionHandler, ISessionLogger, Session } from '@robota-sdk/agent-sessions';
+import { ITerminalOutput, SessionStore, TPermissionHandler, ISessionLogger, Session, FileSessionLogger, TPermissionResult } 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';
+
+/**
+ * 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)
+ */
+
+/** 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>;
+}
+
+/**
+ * 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)
+ */
+
+/** 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;
@@ -185,7 +89,19 @@ 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;
+        };
+    }>;
 }
 
 interface ILoadedContext {
@@ -235,10 +151,17 @@ 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;
+    }>;
 }
-/**
- * Assemble the full system prompt string from the provided parameters.
- */
 declare function buildSystemPrompt(params: ISystemPromptParams): string;
 
 /**
@@ -276,6 +199,13 @@ interface ICreateSessionOptions {
     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) */
@@ -286,6 +216,12 @@ interface ICreateSessionOptions {
     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.
@@ -317,6 +253,146 @@ declare function createDefaultTools(): IToolWithEventService[];
  */
 declare function createProvider(config: IResolvedConfig): IAIProvider;
 
+/**
+ * Framework system prompt suffixes for subagent sessions.
+ *
+ * These functions generate the standard prompt content injected into
+ * subagent sessions to control output format and behavior.
+ */
+/** Options for assembling a subagent system prompt. */
+interface ISubagentPromptOptions {
+    /** Agent definition markdown body. */
+    agentBody: string;
+    /** CLAUDE.md content to include. */
+    claudeMd?: string;
+    /** AGENTS.md content to include. */
+    agentsMd?: string;
+    /** When true, use fork worker suffix instead of standard subagent suffix. */
+    isForkWorker: boolean;
+}
+/**
+ * Returns the standard subagent suffix appended to agent body for normal subagents.
+ */
+declare function getSubagentSuffix(): string;
+/**
+ * Returns the fork worker suffix for context:fork skill workers.
+ */
+declare function getForkWorkerSuffix(): string;
+/**
+ * Assembles the full system prompt for a subagent.
+ *
+ * Assembly order:
+ * 1. Agent definition body
+ * 2. CLAUDE.md content (if provided)
+ * 3. AGENTS.md content (if provided)
+ * 4. Framework suffix (fork worker OR standard subagent)
+ */
+declare function assembleSubagentPrompt(options: ISubagentPromptOptions): string;
+
+/**
+ * Definition of an agent that can be spawned as a subagent.
+ *
+ * Built-in agents and custom (user-defined) agents share this shape.
+ * Optional fields inherit from the parent session when omitted.
+ */
+interface IAgentDefinition {
+    /** Unique name used to reference the agent (e.g., 'Explore', 'Plan'). */
+    name: string;
+    /** Human-readable description of the agent's purpose. */
+    description: string;
+    /** Markdown body content used as the agent's system prompt. */
+    systemPrompt: string;
+    /** Model override (e.g., 'claude-haiku-4-5', 'sonnet', 'opus'). Inherits parent model when omitted. */
+    model?: string;
+    /** Maximum number of agentic turns the subagent may execute. */
+    maxTurns?: number;
+    /** Allowlist of tool names. Only these tools are available when set. */
+    tools?: string[];
+    /** Denylist of tool names. These tools are removed from the inherited set. */
+    disallowedTools?: string[];
+}
+
+/**
+ * Subagent session factory — assembles an isolated child Session for subagent execution.
+ *
+ * Unlike `createSession`, this factory does not load config files or context from disk.
+ * It receives pre-resolved config and context from the parent session, applies tool
+ * filtering and model resolution from the agent definition, and creates a lightweight
+ * Session suitable for subagent use.
+ */
+
+/** Options for creating a subagent session. */
+interface ISubagentOptions {
+    /** Agent definition (built-in or custom). */
+    agentDefinition: IAgentDefinition;
+    /** Parent's resolved config (for provider, permissions, etc.). */
+    parentConfig: IResolvedConfig;
+    /** Parent's loaded context (CLAUDE.md, AGENTS.md). */
+    parentContext: ILoadedContext;
+    /** Parent session's available tools (to inherit/filter). */
+    parentTools: IToolWithEventService[];
+    /** Terminal output interface. */
+    terminal: ITerminalOutput;
+    /** Whether this is a fork worker (uses fork suffix instead of standard). */
+    isForkWorker?: boolean;
+    /** Permission mode from parent (bypassPermissions, acceptEdits, etc.). */
+    permissionMode?: TPermissionMode;
+    /** Permission handler from parent. */
+    permissionHandler?: TPermissionHandler;
+    /** Plugin hooks configuration from parent session. */
+    hooks?: Record<string, unknown>;
+    /** Hook type executors from parent session (prompt, agent, etc.). */
+    hookTypeExecutors?: IHookTypeExecutor[];
+    /** Streaming callback. */
+    onTextDelta?: (delta: string) => void;
+    /** Tool execution callback. */
+    onToolExecution?: (event: {
+        type: 'start' | 'end';
+        toolName: string;
+        toolArgs?: TToolArgs;
+        success?: boolean;
+    }) => void;
+}
+/**
+ * Create a fully-configured Session for subagent execution.
+ *
+ * Assembles provider, tools, and system prompt from parent context and
+ * agent definition, then returns a new Session instance.
+ */
+declare function createSubagentSession(options: ISubagentOptions): Session;
+
+/**
+ * Subagent transcript logger — creates a FileSessionLogger that writes
+ * subagent session logs into a subdirectory of the parent session's log folder.
+ *
+ * Log structure:
+ *   {baseLogsDir}/{parentSessionId}/subagents/{agentId}.jsonl
+ */
+
+/**
+ * Create a FileSessionLogger for a subagent session.
+ *
+ * The logger writes JSONL files into a `subagents/` subdirectory under the
+ * parent session's log folder. The directory is created if it does not exist.
+ *
+ * @param parentSessionId - ID of the parent session (used as directory name)
+ * @param agentId - Unique identifier for this subagent run
+ * @param baseLogsDir - Root logs directory (e.g., `.robota/logs`)
+ * @returns A FileSessionLogger writing to the subagent directory
+ */
+declare function createSubagentLogger(parentSessionId: string, _agentId: string, baseLogsDir: string): FileSessionLogger;
+/**
+ * Resolve the subagent log directory path without creating it.
+ *
+ * Useful when the caller needs the path for display or configuration
+ * but does not want to create the directory immediately.
+ *
+ * @param parentSessionId - ID of the parent session
+ * @param baseLogsDir - Root logs directory
+ * @returns The resolved subagent log directory path
+ */
+declare function resolveSubagentLogDir(parentSessionId: string, baseLogsDir: string): string;
+
 /**
  * query() — single entry point for running an AI agent conversation.
  * Automatically loads config, context, and project info.
@@ -342,14 +418,14 @@ declare function query(prompt: string, options?: IQueryOptions): Promise<string>
 /**
  * Load and merge all settings files, validate with Zod, return resolved config.
  *
- * @param cwd - The working directory (project root) to search for .robota/
+ * @param cwd - The working directory (project root) to search for settings
  */
 declare function loadConfig(cwd: string): Promise<IResolvedConfig>;
 
 /**
- * Permission prompt — this is now CLI-specific.
- * Re-exported here for backward compatibility.
- * The canonical implementation lives in @robota-sdk/agent-cli.
+ * 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.
  */
 
 /**
@@ -376,14 +452,657 @@ declare function userPaths(): {
     sessions: string;
 };
 
-/** Dependencies injected at registration time */
+/**
+ * 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;
+}
+
+/**
+ * All built-in agent definitions shipped with the SDK.
+ * Order matters: general-purpose is the default fallback.
+ */
+declare const BUILT_IN_AGENTS: IAgentDefinition[];
+/**
+ * Look up a built-in agent definition by name.
+ * Returns `undefined` if no built-in agent matches.
+ */
+declare function getBuiltInAgent(name: string): IAgentDefinition | undefined;
+
+/**
+ * AgentTool — spawn a sub-agent with isolated context.
+ *
+ * Uses `createSubagentSession` to assemble a child Session with filtered tools,
+ * model resolution, and framework system prompt. The sub-agent shares the same
+ * config and context but has its own conversation history.
+ *
+ * Each call to `createAgentTool(deps)` returns a fresh tool instance with deps
+ * captured in closure, eliminating module-level mutable state and enabling
+ * multiple concurrent sessions without race conditions.
+ */
+
+/** Dependencies injected at creation time via createAgentTool factory */
 interface IAgentToolDeps {
     config: IResolvedConfig;
     context: ILoadedContext;
-    projectInfo?: IProjectInfo;
+    tools: IToolWithEventService[];
+    terminal: ITerminalOutput;
+    /** Permission mode from parent session (bypassPermissions, acceptEdits, etc.). */
+    permissionMode?: TPermissionMode;
+    permissionHandler?: TPermissionHandler;
+    /** Plugin hooks configuration from parent session. */
+    hooks?: Record<string, unknown>;
+    /** Hook type executors from parent session (prompt, agent, etc.). */
+    hookTypeExecutors?: IHookTypeExecutor[];
+    onTextDelta?: (delta: string) => void;
+    onToolExecution?: (event: {
+        type: 'start' | 'end';
+        toolName: string;
+        toolArgs?: TToolArgs;
+        success?: boolean;
+    }) => void;
+    /** Optional custom agent registry for resolving non-built-in agent types. */
+    customAgentRegistry?: (name: string) => IAgentDefinition | undefined;
+}
+/** Store agent tool deps keyed by a session (or any object). */
+declare function storeAgentToolDeps(key: object, deps: IAgentToolDeps): void;
+/** Retrieve agent tool deps for a given session key. */
+declare function retrieveAgentToolDeps(key: object): IAgentToolDeps | undefined;
+/**
+ * Create an agent tool instance with deps captured in closure.
+ *
+ * Each session gets its own tool instance — no shared mutable state.
+ */
+declare function createAgentTool(deps: IAgentToolDeps): ReturnType<typeof createZodFunctionTool>;
+
+/** A slash command entry */
+interface ISlashCommand {
+    /** Command name without slash (e.g., "mode") */
+    name: string;
+    /** Short description shown in autocomplete */
+    description: string;
+    /** Source identifier (e.g., "builtin", "skill") */
+    source: string;
+    /** Subcommands for hierarchical menus */
+    subcommands?: ISlashCommand[];
+    /** Execute the command. Args is everything after the command name. */
+    execute?: (args: string) => void | Promise<void>;
+    /** Full SKILL.md content (only for skill commands) */
+    skillContent?: string;
+    /** Hint for the expected argument (Claude Code frontmatter) */
+    argumentHint?: string;
+    /** When true, models cannot invoke this skill autonomously */
+    disableModelInvocation?: boolean;
+    /** When false, users cannot invoke this skill directly */
+    userInvocable?: boolean;
+    /** List of tools this skill is allowed to use */
+    allowedTools?: string[];
+    /** Preferred model for executing this skill */
+    model?: string;
+    /** Effort level hint for the skill */
+    effort?: string;
+    /** Context scope for the skill (e.g., "project") */
+    context?: string;
+    /** Agent identity to use when executing this skill */
+    agent?: string;
+    /** Plugin installation directory (plugin skills/commands only) */
+    pluginDir?: string;
+}
+/** A source that provides slash commands */
+interface ICommandSource {
+    name: string;
+    getCommands(): ISlashCommand[];
+}
+
+/** Aggregates commands from multiple sources */
+declare class CommandRegistry {
+    private sources;
+    addSource(source: ICommandSource): void;
+    /** Get all commands, optionally filtered by prefix */
+    getCommands(filter?: string): ISlashCommand[];
+    /** Resolve a short name to its fully qualified plugin:name form */
+    resolveQualifiedName(shortName: string): string | null;
+    /** Get subcommands for a specific command */
+    getSubcommands(commandName: string): ISlashCommand[];
+}
+
+/** Command source for built-in commands */
+declare class BuiltinCommandSource implements ICommandSource {
+    readonly name = "builtin";
+    private readonly commands;
+    constructor();
+    getCommands(): ISlashCommand[];
+}
+
+interface IFrontmatter {
+    name?: string;
+    description?: string;
+    argumentHint?: string;
+    disableModelInvocation?: boolean;
+    userInvocable?: boolean;
+    allowedTools?: string[];
+    model?: string;
+    effort?: string;
+    context?: string;
+    agent?: string;
+}
+/** Parse YAML-like frontmatter between --- markers */
+declare function parseFrontmatter(content: string): IFrontmatter | null;
+/** Command source that discovers skills from multiple directories */
+declare class SkillCommandSource implements ICommandSource {
+    readonly name = "skill";
+    private readonly cwd;
+    private readonly home;
+    private cachedCommands;
+    constructor(cwd: string, home?: string);
+    getCommands(): ISlashCommand[];
+    getModelInvocableSkills(): ISlashCommand[];
+    getUserInvocableSkills(): ISlashCommand[];
+}
+
+/**
+ * Types for InteractiveSession — event-driven session wrapper.
+ */
+
+/** Tool execution state visible to clients. */
+interface IToolState {
+    toolName: string;
+    firstArg: string;
+    isRunning: boolean;
+    result?: 'success' | 'error' | 'denied';
+    diffLines?: IDiffLine[];
+    diffFile?: string;
+}
+/** A single diff line for Edit tool display. */
+interface IDiffLine {
+    type: 'add' | 'remove' | 'context';
+    content: string;
+    lineNumber?: number;
+}
+/** Result of a completed prompt execution. */
+interface IExecutionResult {
+    response: string;
+    messages: TUniversalMessage[];
+    toolSummaries: IToolSummary[];
+    contextState: IContextWindowState;
+}
+/** Summary of a tool call extracted from history. */
+interface IToolSummary {
+    name: string;
+    args: string;
+}
+/** Permission handler delegate — clients provide their own UI. */
+type TInteractivePermissionHandler = (toolName: string, toolArgs: TToolArgs) => Promise<TPermissionResult>;
+/** Events emitted by InteractiveSession. */
+interface IInteractiveSessionEvents {
+    text_delta: (delta: string) => void;
+    tool_start: (state: IToolState) => void;
+    tool_end: (state: IToolState) => void;
+    thinking: (isThinking: boolean) => void;
+    complete: (result: IExecutionResult) => void;
+    error: (error: Error) => void;
+    context_update: (state: IContextWindowState) => void;
+    interrupted: (result: IExecutionResult) => void;
+}
+type TInteractiveEventName = keyof IInteractiveSessionEvents;
+
+/**
+ * InteractiveSession — event-driven session wrapper for any client.
+ *
+ * Wraps Session (composition) to provide streaming text accumulation,
+ * tool execution state tracking, prompt queuing, abort orchestration,
+ * and message history management. Previously embedded in CLI React hooks.
+ *
+ * Clients (CLI, web, API server, Dynamic Worker) subscribe to events
+ * and call submit/abort/cancelQueue.
+ */
+
+interface IInteractiveSessionOptions {
+    config: ICreateSessionOptions['config'];
+    context: ICreateSessionOptions['context'];
+    projectInfo?: ICreateSessionOptions['projectInfo'];
+    sessionStore?: ICreateSessionOptions['sessionStore'];
+    permissionMode?: ICreateSessionOptions['permissionMode'];
+    maxTurns?: number;
+    cwd?: string;
+    permissionHandler?: TInteractivePermissionHandler;
+    /** Optional: inject pre-built session (for testing). */
+    session?: Session;
+}
+declare class InteractiveSession {
+    private readonly session;
+    private readonly listeners;
+    private streamingText;
+    private flushTimer;
+    private activeTools;
+    private executing;
+    private pendingPrompt;
+    private pendingDisplayInput;
+    private pendingRawInput;
+    private messages;
+    constructor(options: IInteractiveSessionOptions);
+    on<E extends TInteractiveEventName>(event: E, handler: IInteractiveSessionEvents[E]): void;
+    off<E extends TInteractiveEventName>(event: E, handler: IInteractiveSessionEvents[E]): void;
+    private emit;
+    /** Submit a prompt. Queues if already executing (max 1 queued).
+     *  displayInput overrides what appears as the user message (e.g., "/audit" instead of full skill prompt).
+     *  rawInput is passed to Session.run() for hook matching (e.g., "/rulebased-harness:audit"). */
+    submit(input: string, displayInput?: string, rawInput?: string): Promise<void>;
+    /** Abort current execution and clear queue. */
+    abort(): void;
+    /** Cancel queued prompt without aborting current execution. */
+    cancelQueue(): void;
+    isExecuting(): boolean;
+    getPendingPrompt(): string | null;
+    getMessages(): TUniversalMessage[];
+    getStreamingText(): string;
+    getActiveTools(): IToolState[];
+    getContextState(): IContextWindowState;
+    getSession(): Session;
+    private executePrompt;
+    private handleTextDelta;
+    private handleToolExecution;
+    private clearStreaming;
+    private flushStreaming;
+    private buildResult;
+    private buildInterruptedResult;
+    private extractToolSummaries;
+    private trimCompletedTools;
+}
+
+/**
+ * System commands — SDK-level command execution logic.
+ *
+ * Pure functions that operate on InteractiveSession.
+ * No React, no TUI, no framework dependencies.
+ * CLI wraps these as slash commands with UI chrome.
+ */
+
+/** Result of a system command execution. */
+interface ICommandResult {
+    /** Human-readable output message */
+    message: string;
+    /** Command completed successfully */
+    success: boolean;
+    /** Additional structured data (command-specific) */
+    data?: Record<string, unknown>;
+}
+/** A system command with name, description, and execute logic. */
+interface ISystemCommand {
+    name: string;
+    description: string;
+    execute(session: InteractiveSession, args: string): Promise<ICommandResult> | ICommandResult;
+}
+/** Built-in system commands. */
+declare function createSystemCommands(): ISystemCommand[];
+/** Registry for system commands. */
+declare class SystemCommandExecutor {
+    private readonly commands;
+    constructor(commands?: ISystemCommand[]);
+    /** Register an additional command. */
+    register(command: ISystemCommand): void;
+    /** Execute a command by name. Returns null if command not found. */
+    execute(name: string, session: InteractiveSession, args: string): Promise<ICommandResult | null>;
+    /** List all registered commands. */
+    listCommands(): ISystemCommand[];
+    /** Check if a command exists. */
+    hasCommand(name: string): boolean;
 }
-/** 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 { DEFAULT_TOOL_DESCRIPTIONS, type ICreateSessionOptions, type ILoadedContext, type IProjectInfo, type IQueryOptions, type IResolvedConfig, type ISystemPromptParams, agentTool, buildSystemPrompt, createDefaultTools, createProvider, createSession, detectProject, loadConfig, loadContext, projectPaths, promptForApproval, query, setAgentToolDeps, userPaths };
+export { AgentExecutor, BUILT_IN_AGENTS, BuiltinCommandSource, BundlePluginInstaller, BundlePluginLoader, CommandRegistry, DEFAULT_TOOL_DESCRIPTIONS, type IAgentDefinition, type IAgentExecutorOptions, type IAgentSession, type IAgentToolDeps, type IBundlePluginFeatures, type IBundlePluginInstallerOptions, type IBundlePluginManifest, type IBundleSkill, type ICommandResult, type ICommandSource, type ICreateSessionOptions, type IDiffLine, type IExecutionResult, type IInstalledPluginRecord, type IInstalledPluginsRegistry, type IInteractiveSessionEvents, type IInteractiveSessionOptions, 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 ISlashCommand, type ISubagentOptions, type ISubagentPromptOptions, type ISystemCommand, type ISystemPromptParams, type IToolState, type IToolSummary, InteractiveSession, MarketplaceClient, PluginSettingsStore, PromptExecutor, SkillCommandSource, SystemCommandExecutor, type TEnabledPlugins, type TInteractiveEventName, type TInteractivePermissionHandler, type TProviderFactory, type TSessionFactory, assembleSubagentPrompt, buildSystemPrompt, createAgentTool, createDefaultTools, createProvider, createSession, createSubagentLogger, createSubagentSession, createSystemCommands, detectProject, getBuiltInAgent, getForkWorkerSuffix, getSubagentSuffix, loadConfig, loadContext, parseFrontmatter, projectPaths, promptForApproval, query, resolveSubagentLogDir, retrieveAgentToolDeps, storeAgentToolDeps, userPaths };