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

package/dist/node/index.d.cts

@@ -1,180 +1,84 @@
-import { 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, 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';
+import { IHookTypeExecutor, IHookDefinition, IHookInput, IHookResult, THooksConfig, TTrustLevel, TPermissionMode, IAIProvider, TToolArgs, IToolWithEventService, IHistoryEntry, IContextWindowState, TUniversalMessage } from '@robota-sdk/agent-core';
+export { IAIProvider, IContextTokenUsage, IContextWindowState, IHistoryEntry, IHookInput, IPermissionLists, THookEvent, THooksConfig, TPermissionDecision, TPermissionMode, TRUST_TO_MODE, TToolArgs, TTrustLevel, chatEntryToMessage, evaluatePermission, getMessagesForAPI, isChatEntry, messageToHistoryEntry, runHooks } from '@robota-sdk/agent-core';
+import { ITerminalOutput, SessionStore, TPermissionHandler, ISessionLogger, Session, FileSessionLogger } from '@robota-sdk/agent-sessions';
+export { ISpinner, ITerminalOutput } from '@robota-sdk/agent-sessions';
+import { createZodFunctionTool } from '@robota-sdk/agent-tools';
+export { TToolResult } from '@robota-sdk/agent-tools';
+
+/**
+ * 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 {
@@ -196,13 +112,6 @@ interface ILoadedContext {
     /** Extracted "Compact Instructions" section from CLAUDE.md, if present */
     compactInstructions?: string;
 }
-/**
- * Load all AGENTS.md and CLAUDE.md files found by walking up from `cwd`.
- * Files from higher directories appear before files from lower directories.
- *
- * @param cwd - Starting directory for the walk-up search
- */
-declare function loadContext(cwd: string): Promise<ILoadedContext>;
 
 type TProjectType = 'node' | 'python' | 'rust' | 'go' | 'unknown';
 type TPackageManager = 'pnpm' | 'yarn' | 'npm' | 'bun';
@@ -213,10 +122,6 @@ interface IProjectInfo {
     packageManager?: TPackageManager;
     language: TLanguage;
 }
-/**
- * Detect the project type, language, name, and package manager from `cwd`.
- */
-declare function detectProject(cwd: string): Promise<IProjectInfo>;
 
 /**
  * System prompt builder — assembles the system message sent to the AI model
@@ -235,11 +140,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;
 
 /**
  * Session factory — assembles a fully-configured Session from config, context,
@@ -276,6 +187,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,76 +204,901 @@ 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[];
+}
+
+/**
+ * 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[];
+    /** AI provider instance. */
+    provider: IAIProvider;
+    /** 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 instance.
+ * Create a fully-configured Session for subagent execution.
  *
- * Assembles provider, tools, and system prompt, then passes them
- * to Session as pre-constructed dependencies.
+ * Assembles provider, tools, and system prompt from parent context and
+ * agent definition, then returns a new Session instance.
  */
-declare function createSession(options: ICreateSessionOptions): Session;
+declare function createSubagentSession(options: ISubagentOptions): Session;
 
 /**
- * Default tool set factory — creates the standard set of CLI tools.
+ * 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
  */
 
-/** 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[].
+ * 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 createDefaultTools(): IToolWithEventService[];
+declare function resolveSubagentLogDir(parentSessionId: string, baseLogsDir: string): string;
 
 /**
- * Provider factory — creates an AI provider from resolved config.
+ * Types for InteractiveSession — event-driven session wrapper.
  */
 
+/** Permission handler result — SDK-owned type (mirrors agent-sessions TPermissionResult).
+ *  true = allow, false = deny, 'allow-session' = allow and remember for this session. */
+type TPermissionResultValue = boolean | 'allow-session';
+/** 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';
+    text: string;
+    lineNumber: number;
+}
+/** Result of a completed prompt execution. */
+interface IExecutionResult {
+    response: string;
+    history: IHistoryEntry[];
+    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<TPermissionResultValue>;
+/** 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;
+
 /**
- * Create an AI provider from the resolved config.
- * Currently supports Anthropic only. Throws if no API key is available.
+ * InteractiveSession — the single entry point for all SDK consumers.
+ *
+ * Wraps Session (composition). Manages streaming text accumulation,
+ * tool execution state tracking, prompt queuing, abort orchestration,
+ * message history, and system command execution.
+ *
+ * Config/context loading is internal. Consumer provides cwd + provider.
  */
-declare function createProvider(config: IResolvedConfig): IAIProvider;
+
+/** Standard construction: cwd + provider. Config/context loaded internally. */
+interface IInteractiveSessionStandardOptions {
+    cwd: string;
+    provider: IAIProvider;
+    permissionMode?: ICreateSessionOptions['permissionMode'];
+    maxTurns?: number;
+    permissionHandler?: TInteractivePermissionHandler;
+}
+/** Test/advanced construction: inject pre-built session directly. */
+interface IInteractiveSessionInjectedOptions {
+    session: Session;
+    cwd?: string;
+    provider?: IAIProvider;
+    permissionMode?: ICreateSessionOptions['permissionMode'];
+    maxTurns?: number;
+    permissionHandler?: TInteractivePermissionHandler;
+}
+type IInteractiveSessionOptions = IInteractiveSessionStandardOptions | IInteractiveSessionInjectedOptions;
+declare class InteractiveSession {
+    private session;
+    private readonly commandExecutor;
+    private readonly listeners;
+    private initialized;
+    private initPromise;
+    private streamingText;
+    private flushTimer;
+    private activeTools;
+    private executing;
+    private pendingPrompt;
+    private pendingDisplayInput;
+    private pendingRawInput;
+    private history;
+    constructor(options: IInteractiveSessionOptions);
+    private initializeAsync;
+    private ensureInitialized;
+    private getSessionOrThrow;
+    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). */
+    submit(input: string, displayInput?: string, rawInput?: string): Promise<void>;
+    /** Execute a system command by name. Returns null if not found. */
+    executeCommand(name: string, args: string): Promise<{
+        message: string;
+        success: boolean;
+        data?: Record<string, unknown>;
+    } | null>;
+    /** Abort current execution and clear queue. */
+    abort(): void;
+    /** Cancel queued prompt without aborting current execution. */
+    cancelQueue(): void;
+    isExecuting(): boolean;
+    getPendingPrompt(): string | null;
+    /** Get full history timeline (chat + events) for TUI rendering */
+    getFullHistory(): IHistoryEntry[];
+    /** Get chat messages only (backward compatible) */
+    getMessages(): TUniversalMessage[];
+    getStreamingText(): string;
+    getActiveTools(): IToolState[];
+    getContextState(): IContextWindowState;
+    /** Access underlying Session. For advanced use / testing only. */
+    getSession(): Session;
+    private executePrompt;
+    private handleTextDelta;
+    private handleToolExecution;
+    /** Push tool execution summary into messages (before Robota response).
+     *  Moves tool info from activeTools (real-time display) to messages (permanent display).
+     *  After this, activeTools will be cleared by clearStreaming(). */
+    private pushToolSummaryMessage;
+    private clearStreaming;
+    private flushStreaming;
+    private buildResult;
+    private buildInterruptedResult;
+    private extractToolSummaries;
+    private trimCompletedTools;
+}
 
 /**
- * query() — single entry point for running an AI agent conversation.
- * Automatically loads config, context, and project info.
+ * createQuery() — factory that returns a prompt-only convenience function.
+ *
+ * Usage:
+ *   const query = createQuery({ provider });
+ *   const answer = await query('What files are here?');
  */
 
-interface IQueryOptions {
+interface ICreateQueryOptions {
+    /** AI provider instance (required). */
+    provider: IAIProvider;
+    /** Working directory. Defaults to process.cwd(). */
     cwd?: string;
+    /** Permission mode. Defaults to 'bypassPermissions' for programmatic use. */
     permissionMode?: TPermissionMode;
+    /** Maximum agentic turns per query. */
     maxTurns?: number;
-    provider?: IAIProvider;
-    permissionHandler?: (toolName: string, toolArgs: TToolArgs) => Promise<boolean>;
+    /** Permission handler callback. */
+    permissionHandler?: TInteractivePermissionHandler;
+    /** Streaming text callback. */
     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.
+ * Create a prompt-only query function bound to a provider.
+ *
+ * ```typescript
+ * import { createQuery } from '@robota-sdk/agent-sdk';
+ * import { AnthropicProvider } from '@robota-sdk/agent-provider-anthropic';
+ *
+ * const query = createQuery({ provider: new AnthropicProvider({ apiKey: '...' }) });
+ * const answer = await query('List all TypeScript files');
+ * ```
  */
-declare function query(prompt: string, options?: IQueryOptions): Promise<string>;
+declare function createQuery(options: ICreateQueryOptions): (prompt: string) => Promise<string>;
+
+/** A command entry */
+interface ICommand {
+    /** 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?: ICommand[];
+    /** 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 commands */
+interface ICommandSource {
+    name: string;
+    getCommands(): ICommand[];
+}
+
+/** Aggregates commands from multiple sources */
+declare class CommandRegistry {
+    private sources;
+    addSource(source: ICommandSource): void;
+    /** Get all commands, optionally filtered by prefix */
+    getCommands(filter?: string): ICommand[];
+    /** 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): ICommand[];
+}
+
+/** Command source for built-in commands */
+declare class BuiltinCommandSource implements ICommandSource {
+    readonly name = "builtin";
+    private readonly commands;
+    constructor();
+    getCommands(): ICommand[];
+}
+
+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(): ICommand[];
+    getModelInvocableSkills(): ICommand[];
+    getUserInvocableSkills(): ICommand[];
+}
 
 /**
- * Load and merge all settings files, validate with Zod, return resolved config.
+ * PluginSettingsStore — single point of read/write for plugin-related settings.
  *
- * @param cwd - The working directory (project root) to search for .robota/
+ * Shared by MarketplaceClient and BundlePluginInstaller to prevent
+ * concurrent writes from overwriting each other's changes.
  */
-declare function loadConfig(cwd: string): Promise<IResolvedConfig>;
+/** 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;
+}
 
 /**
- * Permission prompt — this is now CLI-specific.
- * Re-exported here for backward compatibility.
- * The canonical implementation lives in @robota-sdk/agent-cli.
+ * 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>;
 
 /**
- * Prompt the user for approval before running a tool.
+ * 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.
  */
-declare function promptForApproval(terminal: ITerminalOutput, toolName: string, toolArgs: TToolArgs): Promise<boolean>;
+
+/** 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;
+}
+
+/**
+ * Command source that discovers skills and commands from loaded BundlePlugins.
+ *
+ * - Skills: exposed as `/name` with `(plugin-name)` hint in description.
+ * - Commands: exposed as `/plugin:command` (already namespaced by the loader).
+ */
+declare class PluginCommandSource implements ICommandSource {
+    readonly name = "plugin";
+    private readonly plugins;
+    constructor(plugins: ILoadedBundlePlugin[]);
+    getCommands(): ICommand[];
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Build a skill prompt from slash command input.
+ * Supports variable substitution and shell command preprocessing.
+ */
+
+/** Context variables available during skill prompt processing */
+interface SkillPromptContext {
+    /** Current session ID — substituted for ${CLAUDE_SESSION_ID} */
+    sessionId?: string;
+    /** Directory containing SKILL.md — substituted for ${CLAUDE_SKILL_DIR} */
+    skillDir?: string;
+}
+/**
+ * Substitute variables in skill content.
+ *
+ * Supported variables:
+ * - `$ARGUMENTS` — all arguments passed to the skill
+ * - `$ARGUMENTS[N]` — argument by index (0-based)
+ * - `$N` — shorthand for `$ARGUMENTS[N]` (single digit, 0-9)
+ * - `${CLAUDE_SESSION_ID}` — current session ID
+ * - `${CLAUDE_SKILL_DIR}` — directory containing SKILL.md
+ */
+declare function substituteVariables(content: string, args: string, context?: SkillPromptContext): string;
+/**
+ * Preprocess shell commands in skill content.
+ * Matches `` !`...` `` patterns and replaces them with command output.
+ * Commands have a 5-second timeout.
+ */
+declare function preprocessShellCommands(content: string): Promise<string>;
+/** Build a skill prompt from a slash command input and registry */
+declare function buildSkillPrompt(input: string, registry: CommandRegistry, context?: SkillPromptContext): Promise<string | null>;
+
+/**
+ * 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;
+    tools: IToolWithEventService[];
+    terminal: ITerminalOutput;
+    /** AI provider instance (passed from consumer). */
+    provider: IAIProvider;
+    /** 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>;
 
 /**
  * Standard Robota storage paths.
@@ -376,14 +1119,15 @@ declare function userPaths(): {
     sessions: string;
 };
 
-/** Dependencies injected at registration time */
-interface IAgentToolDeps {
-    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;
+/**
+ * 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.
+ */
+
+/**
+ * Prompt the user for approval before running a tool.
+ */
+declare function promptForApproval(terminal: ITerminalOutput, toolName: string, toolArgs: TToolArgs): Promise<boolean>;
 
-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, type IAgentDefinition, type IAgentExecutorOptions, type IAgentSession, type IAgentToolDeps, type IBundlePluginFeatures, type IBundlePluginInstallerOptions, type IBundlePluginManifest, type IBundleSkill, type ICommand, type ICommandResult, type ICommandSource, type ICreateQueryOptions, type IDiffLine, type IExecutionResult, type IInstalledPluginRecord, type IInstalledPluginsRegistry, type IInteractiveSessionEvents, type IInteractiveSessionOptions, type IKnownMarketplaceEntry, type IKnownMarketplacesRegistry, type ILoadedBundlePlugin, type IMarketplaceClientOptions, type IMarketplaceManifest, type IMarketplacePluginEntry, type IMarketplaceSource, type IPluginSettings, type IPromptExecutorOptions, type IPromptProvider, type ISubagentOptions, type ISubagentPromptOptions, type ISystemCommand, type IToolState, type IToolSummary, InteractiveSession, MarketplaceClient, PluginCommandSource, PluginSettingsStore, PromptExecutor, SkillCommandSource, type SkillPromptContext, type TEnabledPlugins, type TInteractiveEventName, type TInteractivePermissionHandler, type TPermissionResultValue, type TProviderFactory, type TSessionFactory, assembleSubagentPrompt, buildSkillPrompt, createAgentTool, createQuery, createSubagentLogger, createSubagentSession, getBuiltInAgent, getForkWorkerSuffix, getSubagentSuffix, parseFrontmatter, preprocessShellCommands, projectPaths, promptForApproval, resolveSubagentLogDir, retrieveAgentToolDeps, storeAgentToolDeps, substituteVariables, userPaths };