agent-afk 5.1.0 → 5.3.0

package/dist/agent/elicitation-router.d.ts

@@ -0,0 +1,22 @@
+import type { ElicitationRequest, ElicitationResult } from './types/sdk-types.js';
+export type ElicitationHandler = (request: ElicitationRequest, options: {
+    signal: AbortSignal;
+}) => Promise<ElicitationResult>;
+declare class ElicitationRouter {
+    private handler;
+    private queue;
+    private queueDepth;
+    install(handler: ElicitationHandler): void;
+    uninstall(): void;
+    pendingCount(): number;
+    route(request: ElicitationRequest, options: {
+        signal: AbortSignal;
+        onActive?: () => void;
+    }): Promise<ElicitationResult>;
+}
+export declare const elicitationRouter: ElicitationRouter;
+export declare function routeElicitation(request: ElicitationRequest, options: {
+    signal: AbortSignal;
+    onActive?: () => void;
+}): Promise<ElicitationResult>;
+export {};

package/dist/agent/facets/derive.d.ts

@@ -0,0 +1,7 @@
+import { type SessionFacet, type StoredSessionInput } from './schema.js';
+export interface DeriveOptions {
+    sourceSessionPath?: string;
+    sourceSessionMtimeMs?: number;
+    derivedAt?: Date;
+}
+export declare function deriveSessionFacet(session: StoredSessionInput, options?: DeriveOptions): SessionFacet;

package/dist/agent/facets/index.d.ts

@@ -0,0 +1,3 @@
+export { FACET_VERSION, SessionFacetSchema, StoredSessionInputSchema, FacetOutcomeSchema, SubagentPersistenceSchema, SubagentInvocationSchema, WorldChangesSchema, type SessionFacet, type StoredSessionInput, type ToolEventInput, type FacetOutcome, type SubagentInvocation, type WorldChanges, } from './schema.js';
+export { deriveSessionFacet, type DeriveOptions } from './derive.js';
+export { getOrDeriveFacet, loadStoredSession, listSessionIds, type FacetStoreOptions, } from './store.js';

package/dist/agent/facets/raw-input.d.ts

@@ -0,0 +1,3 @@
+export declare const RAW_INPUT_FIELDS: readonly ["file_path", "name", "id_prefix"];
+export declare const RAW_INPUT_FIELD_CAP = 4096;
+export declare function extractRawToolInput(input: unknown): string | undefined;

package/dist/agent/facets/schema.d.ts

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+export declare const FACET_VERSION = 1;
+export declare const ToolEventInputSchema: z.ZodObject<{
+    toolName: z.ZodString;
+    toolUseId: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodString>;
+    inputRaw: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodString>;
+    isError: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const TurnInputSchema: z.ZodObject<{
+    user: z.ZodDefault<z.ZodString>;
+    assistant: z.ZodDefault<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+    toolEvents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        toolName: z.ZodString;
+        toolUseId: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodString>;
+        inputRaw: z.ZodOptional<z.ZodString>;
+        result: z.ZodOptional<z.ZodString>;
+        isError: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export declare const StoredSessionInputSchema: z.ZodObject<{
+    sessionId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodEnum<{
+        telegram: "telegram";
+        cli: "cli";
+    }>>;
+    telegramChatId: z.ZodOptional<z.ZodNumber>;
+    model: z.ZodString;
+    startedAt: z.ZodNumber;
+    savedAt: z.ZodNumber;
+    totalTurns: z.ZodNumber;
+    totalCostUsd: z.ZodOptional<z.ZodNumber>;
+    totalTokens: z.ZodOptional<z.ZodNumber>;
+    totalDurationMs: z.ZodOptional<z.ZodNumber>;
+    turns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        user: z.ZodDefault<z.ZodString>;
+        assistant: z.ZodDefault<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodNumber>;
+        toolEvents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            toolName: z.ZodString;
+            toolUseId: z.ZodOptional<z.ZodString>;
+            input: z.ZodOptional<z.ZodString>;
+            inputRaw: z.ZodOptional<z.ZodString>;
+            result: z.ZodOptional<z.ZodString>;
+            isError: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>>;
+    forkedFrom: z.ZodOptional<z.ZodString>;
+    forkedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type StoredSessionInput = z.infer<typeof StoredSessionInputSchema>;
+export type ToolEventInput = z.infer<typeof ToolEventInputSchema>;
+export declare const FacetOutcomeSchema: z.ZodEnum<{
+    aborted: "aborted";
+    fully_achieved: "fully_achieved";
+    partially_achieved: "partially_achieved";
+    not_achieved: "not_achieved";
+}>;
+export type FacetOutcome = z.infer<typeof FacetOutcomeSchema>;
+export declare const SubagentPersistenceSchema: z.ZodEnum<{
+    unknown: "unknown";
+    persisted: "persisted";
+    not_persisted: "not_persisted";
+}>;
+export declare const SubagentInvocationSchema: z.ZodObject<{
+    tool: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const WorldChangesSchema: z.ZodObject<{
+    files_written: z.ZodNumber;
+    files_edited: z.ZodNumber;
+    bash_commands: z.ZodNumber;
+    commits: z.ZodNumber;
+    mutated: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const SessionFacetSchema: z.ZodObject<{
+    facet_version: z.ZodNumber;
+    session_id: z.ZodString;
+    source: z.ZodEnum<{
+        telegram: "telegram";
+        cli: "cli";
+        unknown: "unknown";
+    }>;
+    model: z.ZodString;
+    derived_at: z.ZodString;
+    derived_from: z.ZodLiteral<"afk-session">;
+    source_session_path: z.ZodString;
+    source_session_mtime_ms: z.ZodNumber;
+    subagent_persistence: z.ZodEnum<{
+        unknown: "unknown";
+        persisted: "persisted";
+        not_persisted: "not_persisted";
+    }>;
+    start_time: z.ZodString;
+    end_time: z.ZodString;
+    duration_minutes: z.ZodNumber;
+    underlying_goal: z.ZodString;
+    first_prompt: z.ZodString;
+    goal_categories: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    session_type: z.ZodString;
+    brief_summary: z.ZodString;
+    total_turns: z.ZodNumber;
+    user_message_count: z.ZodNumber;
+    assistant_message_count: z.ZodNumber;
+    tool_counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    commands: z.ZodArray<z.ZodString>;
+    skills: z.ZodArray<z.ZodString>;
+    subagents: z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    tool_errors: z.ZodNumber;
+    tool_error_categories: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    friction_counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    friction_detail: z.ZodString;
+    outcome: z.ZodEnum<{
+        aborted: "aborted";
+        fully_achieved: "fully_achieved";
+        partially_achieved: "partially_achieved";
+        not_achieved: "not_achieved";
+    }>;
+    primary_success: z.ZodString;
+    world_changes: z.ZodObject<{
+        files_written: z.ZodNumber;
+        files_edited: z.ZodNumber;
+        bash_commands: z.ZodNumber;
+        commits: z.ZodNumber;
+        mutated: z.ZodBoolean;
+    }, z.core.$strip>;
+    decisions: z.ZodArray<z.ZodString>;
+    evidence_pointers: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+export type SessionFacet = z.infer<typeof SessionFacetSchema>;
+export type SubagentInvocation = z.infer<typeof SubagentInvocationSchema>;
+export type WorldChanges = z.infer<typeof WorldChangesSchema>;

package/dist/agent/facets/store.d.ts

@@ -0,0 +1,9 @@
+import { type SessionFacet, type StoredSessionInput } from './schema.js';
+export interface FacetStoreOptions {
+    sessionsDir?: string;
+    cacheDir?: string;
+    force?: boolean;
+}
+export declare function loadStoredSession(sessionId: string, sessionsDir?: string): StoredSessionInput | undefined;
+export declare function getOrDeriveFacet(sessionId: string, options?: FacetStoreOptions): SessionFacet | undefined;
+export declare function listSessionIds(options?: Pick<FacetStoreOptions, 'sessionsDir'>): string[];

package/dist/agent/gh.d.ts

@@ -0,0 +1,41 @@
+export type GhErrorKind = 'not-found' | 'already-exists' | 'unauthed' | 'network' | 'timeout' | 'unknown';
+export declare class GhError extends Error {
+    readonly kind: GhErrorKind;
+    readonly exitCode: number;
+    readonly stderr: string;
+    constructor(message: string, kind: GhErrorKind, exitCode: number, stderr: string);
+}
+export type GhReadiness = {
+    ok: true;
+} | {
+    ok: false;
+    hint: string;
+};
+export interface CreatePrOpts {
+    base: string;
+    head: string;
+    title: string;
+    body: string;
+}
+export type ExecFn = (file: string, args: string[]) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function _resetCacheForTest(): void;
+export declare function checkGhReady(opts?: {
+    execFn?: ExecFn;
+    ttlMs?: number;
+    _now?: () => number;
+    log?: (msg: string) => void;
+}): Promise<GhReadiness>;
+export declare function createPr(opts: CreatePrOpts, execFn?: ExecFn): Promise<string>;
+export type ExecWithInputFn = (file: string, args: string[], input: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export interface PostPrCommentOpts {
+    pr: string;
+    body: string;
+}
+export declare function postPrComment(opts: PostPrCommentOpts, execFn?: ExecWithInputFn): Promise<string>;
+export declare function resolveCurrentBranchPr(execFn?: ExecFn): Promise<string | null>;

package/dist/agent/hook-registry.d.ts

@@ -0,0 +1,9 @@
+import type { HookRegistry } from './hooks.js';
+export declare const HOOK_HANDLER_TIMEOUT_MS = 30000;
+export declare class HookHandlerTimeoutError extends Error {
+    readonly hookEvent: string;
+    readonly timeoutMs: number;
+    readonly code: "HOOK_HANDLER_TIMEOUT";
+    constructor(hookEvent: string, timeoutMs: number);
+}
+export declare function createHookRegistryImpl(): HookRegistry;

package/dist/agent/hooks/command-executor.d.ts

@@ -0,0 +1,12 @@
+import type { HookContext, HookDecision } from '../hooks.js';
+export interface ExecuteCommandOptions {
+    command: string;
+    context: HookContext;
+    agentCwd: string;
+    sessionId?: string;
+    timeoutMs: number;
+}
+export interface CommandExecutorResult {
+    decision: HookDecision;
+}
+export declare function executeCommand(opts: ExecuteCommandOptions): Promise<CommandExecutorResult>;

package/dist/agent/hooks/config-bridge.d.ts

@@ -0,0 +1,7 @@
+import type { HookRegistry } from '../hooks.js';
+import type { LoadedHooksConfig } from './config-loader.js';
+export interface AgentConfigForBridge {
+    cwd?: string;
+    sessionId?: string;
+}
+export declare function loadAndRegisterConfigHooks(registry: HookRegistry, hookConfig: LoadedHooksConfig, agentConfig: AgentConfigForBridge): void;

package/dist/agent/hooks/config-loader.d.ts

@@ -0,0 +1,44 @@
+import type { HarnessHookEvent } from '../hooks.js';
+export interface RawCommandHook {
+    type: 'command';
+    command: string;
+    timeout_ms?: number;
+}
+export type RawHook = RawCommandHook;
+export interface RawMatcherGroup {
+    matcher?: string;
+    hooks: RawHook[];
+}
+export type RawHooksConfig = Partial<Record<HarnessHookEvent, RawMatcherGroup[]>>;
+export interface ResolvedCommandHook {
+    type: 'command';
+    command: string;
+    timeoutMs: number;
+}
+export interface ResolvedMatcherGroup {
+    matcher?: string;
+    hooks: ResolvedCommandHook[];
+    tier?: 'user-global' | 'project-local';
+}
+export type ResolvedHooksConfig = Partial<Record<HarnessHookEvent, ResolvedMatcherGroup[]>>;
+export interface LoadedHooksConfig {
+    hooks: ResolvedHooksConfig;
+    userGlobalEnabled: boolean;
+    allowProjectHooks: boolean;
+    sources: string[];
+    warnings: string[];
+}
+export declare function compileMatcher(matcher: string | undefined): (toolName: string) => boolean;
+interface SingleFileResult {
+    hooks: ResolvedHooksConfig;
+    enableShellHooks: boolean;
+    allowProjectHooks: boolean;
+    sources: string[];
+    warnings: string[];
+}
+export declare function loadHooksConfigFile(path: string, tier: 'user-global' | 'project-local'): SingleFileResult;
+export interface LoadHooksConfigOptions {
+    cwd?: string;
+}
+export declare function loadHooksConfig(opts?: LoadHooksConfigOptions): LoadedHooksConfig;
+export {};

package/dist/agent/hooks.d.ts

@@ -0,0 +1,88 @@
+import type { SubagentTrace } from './subagent/result.js';
+export type HarnessHookEvent = 'SessionStart' | 'SessionEnd' | 'SubagentStart' | 'SubagentStop' | 'PreToolUse' | 'PostToolUse' | 'PreCompact' | 'PostToolUseFailure' | 'Stop' | 'UserPromptSubmit';
+export interface HookDecision {
+    continue?: boolean;
+    decision?: 'block' | 'approve';
+    reason?: string;
+    injectContext?: string;
+}
+export type SubagentHookStatus = 'idle' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export interface SessionStartContext {
+    event: 'SessionStart';
+    sessionId?: string;
+}
+export interface SessionEndContext {
+    event: 'SessionEnd';
+    sessionId?: string;
+    reason?: string;
+    parentSessionId?: string;
+    tracePath?: string;
+}
+export interface SubagentStartContext {
+    event: 'SubagentStart';
+    subagentId: string;
+    parentSessionId?: string;
+}
+export interface SubagentStopContext {
+    event: 'SubagentStop';
+    subagentId: string;
+    status: SubagentHookStatus;
+    reason?: string;
+    lastMessage?: string;
+    agentType?: string;
+    durationMs?: number;
+    trace?: SubagentTrace;
+}
+export interface PreToolUseContext {
+    event: 'PreToolUse';
+    sessionId?: string;
+    subagentId?: string;
+    parentSessionId?: string;
+    toolName: string;
+    input?: unknown;
+}
+export interface PostToolUseContext {
+    event: 'PostToolUse';
+    sessionId?: string;
+    subagentId?: string;
+    parentSessionId?: string;
+    toolName: string;
+    input?: unknown;
+    output?: unknown;
+}
+export interface PreCompactContext {
+    event: 'PreCompact';
+    sessionId?: string;
+    trigger?: 'manual' | 'auto';
+}
+export interface PostToolUseFailureContext {
+    event: 'PostToolUseFailure';
+    sessionId?: string;
+    subagentId?: string;
+    parentSessionId?: string;
+    toolName: string;
+    input?: unknown;
+    error: string;
+}
+export interface StopContext {
+    event: 'Stop';
+    sessionId?: string;
+    parentSessionId?: string;
+}
+export interface UserPromptSubmitContext {
+    event: 'UserPromptSubmit';
+    prompt: string;
+    sessionId?: string;
+}
+export type HookContext = SessionStartContext | SessionEndContext | SubagentStartContext | SubagentStopContext | PreToolUseContext | PostToolUseContext | PreCompactContext | PostToolUseFailureContext | StopContext | UserPromptSubmitContext;
+export type HookHandler = (context: HookContext, signal?: AbortSignal) => HookDecision | Promise<HookDecision>;
+export interface RegisterOptions {
+    longRunning?: boolean;
+}
+export interface HookRegistry {
+    register(event: HarnessHookEvent, handler: HookHandler, options?: RegisterOptions): () => void;
+    dispatch(context: HookContext, signal?: AbortSignal, handlerTimeoutMs?: number): Promise<HookDecision>;
+    count(event: HarnessHookEvent): number;
+}
+export declare function createHookRegistry(): HookRegistry;
+export declare function resolveSessionHookRegistry(queryScoped: HookRegistry | undefined, constructorScoped: HookRegistry | undefined): HookRegistry | undefined;

package/dist/agent/index.d.ts

@@ -0,0 +1,31 @@
+export { AgentSession } from './session.js';
+export { query, queryText, queryStructured } from './query.js';
+export type { QueryOptions } from './query.js';
+export { SubagentManager } from './subagent.js';
+export { createCanUseToolHook } from './permissions.js';
+export { AbortGraph } from './abort-graph.js';
+export { DEFAULT_SESSION_TIMEOUT_MS, RESET_DRAIN_TIMEOUT_MS, withTimeout } from './timeout.js';
+export { extractStructuredOutput } from './output-extractor.js';
+export { createHookRegistry } from './hooks.js';
+export { HookBlockedError } from '../utils/errors.js';
+export { OpenAICompatibleProvider, openaiCompatibleProvider } from './providers/openai-compatible/index.js';
+export { providerForModel, resolveProvider } from './providers/index.js';
+export type { BundledProviderName } from './providers/index.js';
+export type { AccountInfo, AgentConfig, AgentModelInput, CanUseTool, ClaudeModel, IAgentSession, McpServerStatus, Message, MessageChunk, MessageRole, ModelInfo, OutputEvent, PermissionBubbler, PermissionMode, ResponseMetadata, SDKStatus, SendMessageOptions, StructuredMessageOptions, SessionIdentity, SessionMetadata, SessionState, SlashCommand, ToolConfig, ToolDiffChunk, ToolResultChunk, } from './types.js';
+export type { CanUseToolContext, PermissionDecision, ToolPermission, ToolPermissionMode, ToolPermissionRules, } from './permissions.js';
+export type { ForkSubagentOptions, SubagentHandle, SubagentManagerOptions, SubagentResult, SubagentStatus, } from './subagent.js';
+export type { ChildAbortedEvent, ChildAbortedListener } from './abort-graph.js';
+export type { WithTimeoutOptions } from './timeout.js';
+export { runDAG, validateDAG } from './dag.js';
+export { runSubagentDAG } from './dag-subagent.js';
+export type { DAGEdge, DAGGraph, DAGNode, DAGRunOptions, DAGRunResult } from './dag.js';
+export type { SubagentDAGNode, SubagentDAGOptions } from './dag-subagent.js';
+export type { HarnessHookEvent, HookContext, HookDecision, HookHandler, HookRegistry, PostToolUseContext, PreCompactContext, PreToolUseContext, SessionEndContext, SessionStartContext, StopContext, SubagentHookStatus, SubagentStartContext, SubagentStopContext, } from './hooks.js';
+export type { ModelProvider, ProviderQuery, ProviderQueryArgs, ProviderEvent, ProviderUserTurn, ProviderUsage, ProviderSessionInfo, ProviderProgress, ProviderCommandInfo, ProviderModelInfo, ProviderAgentInfo, ProviderContextUsage, ProviderMcpServerStatus, ProviderAccountInfo, ProviderRewindResult, } from './provider.js';
+export type { DaemonHandle, DaemonOptions } from './daemon.js';
+export type { SessionRef } from './session-ref.js';
+export { SessionToolDispatcher, createBuiltinHandlers, builtinToolSchemas, checkToolPermission } from './tools/index.js';
+export type { ToolHandler, ToolPermissionConfig, SessionToolDispatcherOptions } from './tools/index.js';
+export type { RenderHints } from './providers/anthropic-direct/types.js';
+export { tool } from './tools/custom-tool.js';
+export type { CustomToolDef } from './tools/custom-tool.js';

package/dist/agent/marketplaces/install.d.ts

@@ -0,0 +1,23 @@
+import * as git from '../plugins/git.js';
+import { type MarketplaceIndexEntry } from '../plugins/index-store.js';
+export interface MarketplaceInstallOptions {
+    name?: string;
+    ref?: string;
+    force?: boolean;
+}
+export interface MarketplaceInstallResult {
+    name: string;
+    dir: string;
+    entry: MarketplaceIndexEntry;
+    plugins: {
+        name: string;
+        description?: string;
+    }[];
+}
+export interface MarketplaceInstallDeps {
+    cacheDir?: string;
+    indexPath?: string;
+    gitRunner?: git.GitRunner;
+    now?: () => Date;
+}
+export declare function installMarketplace(source: string, options?: MarketplaceInstallOptions, deps?: MarketplaceInstallDeps): Promise<MarketplaceInstallResult>;

package/dist/agent/marketplaces/manifest.d.ts

@@ -0,0 +1,21 @@
+export interface MarketplacePluginEntry {
+    name: string;
+    source: string;
+    description?: string;
+}
+export interface MarketplaceManifest {
+    name: string;
+    metadata?: {
+        description?: string;
+    };
+    owner?: {
+        name?: string;
+        email?: string;
+    };
+    plugins: MarketplacePluginEntry[];
+}
+export declare const MARKETPLACE_MANIFEST_RELPATH = ".claude-plugin/marketplace.json";
+export declare function manifestPath(marketplaceDir: string): string;
+export declare function isMarketplaceDir(dir: string): boolean;
+export declare function readManifest(dir: string): MarketplaceManifest;
+export declare function tryReadManifest(dir: string): MarketplaceManifest | null;

package/dist/agent/marketplaces/remove.d.ts

@@ -0,0 +1,11 @@
+export interface RemoveMarketplaceOptions {
+    cacheDir?: string;
+    indexPath?: string;
+}
+export interface RemoveMarketplaceResult {
+    name: string;
+    removedDir: boolean;
+    removedIndexEntry: boolean;
+    removedPluginEntries: string[];
+}
+export declare function removeMarketplace(name: string, opts?: RemoveMarketplaceOptions): RemoveMarketplaceResult;

package/dist/agent/marketplaces/resolve.d.ts

@@ -0,0 +1,27 @@
+import { type PluginIndexEntry } from '../plugins/index-store.js';
+import { type InstallDeps } from '../plugins/install.js';
+export interface InstallFromMarketplaceOptions {
+    ref?: string;
+    force?: boolean;
+}
+export interface InstallFromMarketplaceDeps extends InstallDeps {
+    marketplaceDirFor?: (name: string) => string;
+}
+export interface InstallFromMarketplaceResult {
+    key: string;
+    name: string;
+    dir: string;
+    entry: PluginIndexEntry;
+}
+export declare function installFromMarketplace(marketplace: string, plugin: string, options?: InstallFromMarketplaceOptions, deps?: InstallFromMarketplaceDeps): Promise<InstallFromMarketplaceResult>;
+export declare function listMarketplacePlugins(marketplace: string, deps?: {
+    marketplaceDirFor?: (name: string) => string;
+    indexPath?: string;
+}): {
+    name: string;
+    description?: string;
+    installed: boolean;
+    key: string;
+}[];
+export declare function isLocalPluginSource(source: string): boolean;
+export declare function resolvePluginSourceDir(marketplaceDir: string, source: string): string;

package/dist/agent/marketplaces/update.d.ts

@@ -0,0 +1,38 @@
+import * as git from '../plugins/git.js';
+export interface UpdateMarketplaceOptions {
+    ref?: string;
+}
+export interface UpdateMarketplaceDeps {
+    cacheDir?: string;
+    indexPath?: string;
+    gitRunner?: git.GitRunner;
+    now?: () => Date;
+}
+export interface MarketplacePluginVersion {
+    name: string;
+    version: string | null;
+}
+export type UpdateMarketplaceOutcome = {
+    name: string;
+    status: 'updated';
+    fromRef: string | null;
+    toRef: string;
+    commit: string;
+    addedPlugins: string[];
+    removedPlugins: string[];
+    pluginVersions: MarketplacePluginVersion[];
+} | {
+    name: string;
+    status: 'up-to-date';
+    ref: string;
+    commit: string;
+} | {
+    name: string;
+    status: 'skipped-local';
+} | {
+    name: string;
+    status: 'missing-dir';
+    dir: string;
+};
+export declare function updateMarketplace(name: string, options?: UpdateMarketplaceOptions, deps?: UpdateMarketplaceDeps): Promise<UpdateMarketplaceOutcome>;
+export declare function updateAllMarketplaces(deps?: UpdateMarketplaceDeps): Promise<UpdateMarketplaceOutcome[]>;

package/dist/agent/mcp/client.d.ts

@@ -0,0 +1,28 @@
+import { type Tool as McpTool } from '@modelcontextprotocol/sdk/types.js';
+import { UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js';
+import type { ToolResult } from '../tools/types.js';
+import type { McpServerConfig } from './types.js';
+export interface McpClientConnectResult {
+    tools: McpTool[];
+    serverInfo: {
+        name: string;
+        version: string;
+    } | undefined;
+}
+export declare class McpClient {
+    private readonly serverName;
+    private readonly config;
+    private client;
+    private connected;
+    private pendingAuthTransport;
+    onTransportError?: (err: Error) => void;
+    onToolListChanged?: () => void;
+    constructor(serverName: string, config: McpServerConfig);
+    connect(): Promise<McpClientConnectResult>;
+    listTools(): Promise<McpTool[]>;
+    refreshTools(): Promise<McpTool[]>;
+    callTool(toolName: string, input: unknown, signal: AbortSignal): Promise<ToolResult>;
+    finishAuth(authorizationCode: string): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export { UnauthorizedError };

package/dist/agent/mcp/config-loader.d.ts

@@ -0,0 +1,22 @@
+import type { McpServerConfig } from './types.js';
+export interface McpConfigFile {
+    mcpServers?: Record<string, McpServerConfig>;
+}
+export interface LoadedMcpConfig {
+    mcpServers: Record<string, McpServerConfig>;
+    sources: string[];
+    warnings: string[];
+}
+export declare function getMcpConfigPath(): string;
+export declare function getProjectMcpConfigPath(cwd?: string): string;
+export declare function discoverPluginMcpConfigs(pluginsRoot?: string): string[];
+export declare function loadMcpConfigFile(path: string): LoadedMcpConfig;
+export interface LoadMcpConfigOptions {
+    cwd?: string;
+    pluginsRoot?: string | null;
+    cliOverride?: string;
+    skipUserGlobal?: boolean;
+    skipProjectLocal?: boolean;
+    importedMcpConfigs?: string[];
+}
+export declare function loadMcpConfig(opts?: LoadMcpConfigOptions): LoadedMcpConfig;

package/dist/agent/mcp/env.d.ts

@@ -0,0 +1,6 @@
+export interface EnvExpansionResult<T> {
+    value: T;
+    missing: string[];
+}
+export declare function expandEnvString(input: string, source?: NodeJS.ProcessEnv): EnvExpansionResult<string>;
+export declare function expandEnvRecord(input: Record<string, string> | undefined, source?: NodeJS.ProcessEnv): EnvExpansionResult<Record<string, string>>;

package/dist/agent/mcp/index.d.ts

@@ -0,0 +1,8 @@
+export type { McpServerConfig, McpClientState, McpClientStatus, McpTransportType, } from './types.js';
+export { McpClient, type McpClientConnectResult } from './client.js';
+export { McpManager, type McpManagerInitOptions } from './manager.js';
+export { loadMcpConfig, loadMcpConfigFile, getMcpConfigPath, getProjectMcpConfigPath, discoverPluginMcpConfigs, type LoadedMcpConfig, type LoadMcpConfigOptions, type McpConfigFile, } from './config-loader.js';
+export { buildMcpToolName, isMcpToolName, buildMcpNameRegistry, sanitizeNameSegment, type McpNameRegistry, } from './naming.js';
+export { expandEnvString, expandEnvRecord, type EnvExpansionResult } from './env.js';
+export { createTransport, createTransportWithFallbackHint, expandHeaders, type CreateTransportResult, } from './transport.js';
+export { KeychainOAuthProvider, readOauthPending, clearOauthPending, type KeychainBackend, type OauthPendingEntry, } from './oauth.js';

package/dist/agent/mcp/manager.d.ts

@@ -0,0 +1,23 @@
+import type { AnthropicToolDef, ToolHandler } from '../tools/types.js';
+import type { McpClientState, McpServerConfig } from './types.js';
+import type { TraceWriter } from '../trace/index.js';
+export interface McpManagerInitOptions {
+    warnings?: string[];
+    traceWriter?: TraceWriter;
+}
+export declare class McpManager {
+    private readonly records;
+    private readonly nameRegistry;
+    onToolsRefreshed?: (serverName: string) => void;
+    private constructor();
+    static fromConfig(servers: Record<string, McpServerConfig>, opts?: McpManagerInitOptions): Promise<McpManager>;
+    getMcpTools(): AnthropicToolDef[];
+    getMcpHandlers(): Map<string, ToolHandler>;
+    refreshServer(serverName: string): Promise<void>;
+    getServerStates(): McpClientState[];
+    getMcpToolWireNames(): string[];
+    completeAuth(serverName: string, authorizationCode: string): Promise<void>;
+    hasAnyConnected(): boolean;
+    size(): number;
+    disconnectAll(): Promise<void>;
+}