@sctg/cline-core 3.84.0-beta.20260524130712

package/dist/extensions/config/unified-config-file-watcher.d.ts

@@ -0,0 +1,77 @@
+export interface UnifiedConfigFileContext<TType extends string = string> {
+    type: TType;
+    directoryPath: string;
+    fileName: string;
+    filePath: string;
+    content: string;
+}
+export interface UnifiedConfigFileCandidate {
+    directoryPath: string;
+    fileName: string;
+    filePath: string;
+}
+export interface UnifiedConfigDefinition<TType extends string = string, TItem = unknown> {
+    type: TType;
+    directories: ReadonlyArray<string>;
+    discoverFiles?: (directoryPath: string) => Promise<ReadonlyArray<UnifiedConfigFileCandidate>>;
+    includeFile?: (fileName: string, filePath: string) => boolean;
+    parseFile: (context: UnifiedConfigFileContext<TType>) => TItem;
+    resolveId: (item: TItem, context: UnifiedConfigFileContext<TType>) => string;
+}
+export interface UnifiedConfigWatcherOptions {
+    debounceMs?: number;
+    emitParseErrors?: boolean;
+}
+export interface UnifiedConfigRecord<TType extends string = string, TItem = unknown> {
+    type: TType;
+    id: string;
+    item: TItem;
+    filePath: string;
+}
+export type UnifiedConfigWatcherEvent<TType extends string = string, TItem = unknown> = {
+    kind: "upsert";
+    record: UnifiedConfigRecord<TType, TItem>;
+} | {
+    kind: "remove";
+    type: TType;
+    id: string;
+    filePath: string;
+} | {
+    kind: "error";
+    type: TType;
+    error: unknown;
+    filePath?: string;
+};
+export declare class UnifiedConfigFileWatcher<TType extends string = string, TItem = unknown> {
+    private readonly definitions;
+    private readonly debounceMs;
+    private readonly emitParseErrors;
+    private readonly listeners;
+    private readonly recordsByType;
+    private readonly watchersByDirectory;
+    private readonly baseTypesByDirectory;
+    private watchedTypesByDirectory;
+    private readonly discoveredDirectoriesByType;
+    private readonly definitionsByType;
+    private readonly pendingTypes;
+    private flushTimer;
+    private refreshQueue;
+    private started;
+    constructor(definitions: ReadonlyArray<UnifiedConfigDefinition<TType, TItem>>, options?: UnifiedConfigWatcherOptions);
+    subscribe(listener: (event: UnifiedConfigWatcherEvent<TType, TItem>) => void): () => void;
+    start(): Promise<void>;
+    stop(): void;
+    refreshAll(): Promise<void>;
+    refreshType(type: TType): Promise<void>;
+    getSnapshot(type: TType): Map<string, UnifiedConfigRecord<TType, TItem>>;
+    getAllSnapshots(): Map<TType, Map<string, UnifiedConfigRecord<TType, TItem>>>;
+    private emit;
+    private enqueueRefresh;
+    private startDirectoryWatchers;
+    private syncDirectoryWatchers;
+    private scheduleFlush;
+    private refreshTypeInternal;
+    private loadDefinition;
+    private buildDesiredTypesByDirectory;
+    private readDirectoryFileCandidates;
+}

package/dist/extensions/config/user-instruction-config-loader.d.ts

@@ -0,0 +1,64 @@
+import { RULES_CONFIG_DIRECTORY_NAME, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME } from "@cline/shared/storage";
+import { type UnifiedConfigDefinition, UnifiedConfigFileWatcher, type UnifiedConfigWatcherEvent } from "./unified-config-file-watcher";
+export { RULES_CONFIG_DIRECTORY_NAME, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME, };
+export interface ParseMarkdownFrontmatterResult {
+    data: Record<string, unknown>;
+    body: string;
+    hadFrontmatter: boolean;
+    parseError?: string;
+}
+export interface SkillConfig {
+    name: string;
+    description?: string;
+    disabled?: boolean;
+    instructions: string;
+    frontmatter: Record<string, unknown>;
+}
+export interface RuleConfig {
+    name: string;
+    disabled?: boolean;
+    instructions: string;
+    frontmatter: Record<string, unknown>;
+}
+export interface WorkflowConfig {
+    name: string;
+    disabled?: boolean;
+    description?: string;
+    instructions: string;
+    frontmatter: Record<string, unknown>;
+}
+export type UserInstructionConfigType = "skill" | "rule" | "workflow";
+export type UserInstructionConfig = SkillConfig | RuleConfig | WorkflowConfig;
+export type UserInstructionConfigWatcher = UnifiedConfigFileWatcher<UserInstructionConfigType, UserInstructionConfig>;
+export type UserInstructionConfigWatcherEvent = UnifiedConfigWatcherEvent<UserInstructionConfigType, UserInstructionConfig>;
+export interface CreateInstructionWatcherOptions {
+    debounceMs?: number;
+    emitParseErrors?: boolean;
+}
+export interface CreateSkillsConfigDefinitionOptions {
+    directories?: ReadonlyArray<string>;
+    workspacePath?: string;
+}
+export interface CreateRulesConfigDefinitionOptions {
+    directories?: ReadonlyArray<string>;
+    workspacePath?: string;
+}
+export interface CreateWorkflowsConfigDefinitionOptions {
+    directories?: ReadonlyArray<string>;
+    workspacePath?: string;
+}
+export declare function parseSkillConfigFromMarkdown(content: string, fallbackName: string): SkillConfig;
+export declare function parseRuleConfigFromMarkdown(content: string, fallbackName: string): RuleConfig;
+export declare function parseWorkflowConfigFromMarkdown(content: string, fallbackName: string): WorkflowConfig;
+export declare function resolveSkillsConfigSearchPaths(workspacePath?: string): string[];
+export declare function resolveRulesConfigSearchPaths(workspacePath?: string): string[];
+export declare function resolveWorkflowsConfigSearchPaths(workspacePath?: string): string[];
+export declare function createSkillsConfigDefinition(options?: CreateSkillsConfigDefinitionOptions): UnifiedConfigDefinition<"skill", SkillConfig>;
+export declare function createRulesConfigDefinition(options?: CreateRulesConfigDefinitionOptions): UnifiedConfigDefinition<"rule", RuleConfig>;
+export declare function createWorkflowsConfigDefinition(options?: CreateWorkflowsConfigDefinitionOptions): UnifiedConfigDefinition<"workflow", WorkflowConfig>;
+export interface CreateUserInstructionConfigWatcherOptions extends CreateInstructionWatcherOptions {
+    skills?: CreateSkillsConfigDefinitionOptions;
+    rules?: CreateRulesConfigDefinitionOptions;
+    workflows?: CreateWorkflowsConfigDefinitionOptions;
+}
+export declare function createUserInstructionConfigWatcher(options?: CreateUserInstructionConfigWatcherOptions): UserInstructionConfigWatcher;

package/dist/extensions/config/user-instruction-plugin.d.ts

@@ -0,0 +1,25 @@
+import type { AgentExtension } from "@cline/shared";
+import { type SkillsExecutorWithMetadata } from "../tools";
+import type { SkillConfig, UserInstructionConfigWatcher } from "./user-instruction-config-loader";
+type SkillsExecutorMetadataItem = {
+    id: string;
+    name: string;
+    description?: string;
+    disabled: boolean;
+};
+type ConfiguredSkill = SkillsExecutorMetadataItem & {
+    skill: SkillConfig;
+};
+export interface CreateUserInstructionPluginOptions {
+    watcher: UserInstructionConfigWatcher;
+    watcherReady?: Promise<void>;
+    includeRules?: boolean;
+    includeSkills?: boolean;
+    includeWorkflows?: boolean;
+    registerSkillsTool?: boolean;
+    allowedSkillNames?: ReadonlyArray<string>;
+}
+export declare function getConfiguredSkillsFromWatcher(watcher: UserInstructionConfigWatcher, allowedSkillNames?: ReadonlyArray<string>): ConfiguredSkill[];
+export declare function createUserInstructionSkillsExecutor(watcher: UserInstructionConfigWatcher, watcherReady?: Promise<void>, allowedSkillNames?: ReadonlyArray<string>): SkillsExecutorWithMetadata;
+export declare function createUserInstructionPlugin(options: CreateUserInstructionPluginOptions): AgentExtension;
+export {};

package/dist/extensions/config/user-instruction-service.d.ts

@@ -0,0 +1,23 @@
+import type { AgentExtension } from "@cline/shared";
+import { type AvailableRuntimeCommand } from "./runtime-commands";
+import { type CreateUserInstructionConfigWatcherOptions, type UserInstructionConfig, type UserInstructionConfigType } from "./user-instruction-config-loader";
+import { type CreateUserInstructionPluginOptions } from "./user-instruction-plugin";
+export interface UserInstructionConfigRecord<TConfig extends UserInstructionConfig = UserInstructionConfig> {
+    type: UserInstructionConfigType;
+    id: string;
+    filePath: string;
+    item: TConfig;
+}
+export interface CreateUserInstructionConfigServiceOptions extends CreateUserInstructionConfigWatcherOptions {
+}
+export interface UserInstructionConfigService {
+    start(): Promise<void>;
+    stop(): void;
+    refreshType(type: UserInstructionConfigType): Promise<void>;
+    listRecords<TConfig extends UserInstructionConfig = UserInstructionConfig>(type: UserInstructionConfigType): UserInstructionConfigRecord<TConfig>[];
+    listRuntimeCommands(): AvailableRuntimeCommand[];
+    resolveRuntimeSlashCommand(input: string): string;
+    hasConfiguredSkills(allowedSkillNames?: ReadonlyArray<string>): boolean;
+    createExtension(options: Omit<CreateUserInstructionPluginOptions, "watcher" | "watcherReady">): AgentExtension;
+}
+export declare function createUserInstructionConfigService(options?: CreateUserInstructionConfigServiceOptions): UserInstructionConfigService;

package/dist/extensions/context/agentic-compaction.d.ts

@@ -0,0 +1,12 @@
+import type { BasicLogger } from "@cline/shared";
+import type { CoreCompactionContext, CoreCompactionResult, CoreCompactionSummarizerConfig } from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
+import { type EstimateMessageTokens } from "./compaction-shared";
+export declare function runAgenticCompaction(options: {
+    context: CoreCompactionContext;
+    providerConfig: ProviderConfig;
+    summarizer?: CoreCompactionSummarizerConfig;
+    preserveRecentTokens: number;
+    estimateMessageTokens: EstimateMessageTokens;
+    logger?: BasicLogger;
+}): Promise<CoreCompactionResult | undefined>;

package/dist/extensions/context/basic-compaction.d.ts

@@ -0,0 +1,8 @@
+import type { BasicLogger } from "@cline/shared";
+import type { CoreCompactionContext, CoreCompactionResult } from "../../types/config";
+import { type EstimateMessageTokens } from "./compaction-shared";
+export declare function runBasicCompaction(options: {
+    context: CoreCompactionContext;
+    estimateMessageTokens: EstimateMessageTokens;
+    logger?: BasicLogger;
+}): CoreCompactionResult | undefined;

package/dist/extensions/context/compaction-shared.d.ts

@@ -0,0 +1,61 @@
+import type { ToolResultContent } from "@cline/llms";
+import { estimateTokens, type MessageWithMetadata } from "@cline/shared";
+export { estimateTokens };
+import type { CoreCompactionContext, CoreCompactionSummarizerConfig } from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
+export declare const DEFAULT_MAX_INPUT_TOKENS = 200000;
+export declare const DEFAULT_THRESHOLD_RATIO = 0.9;
+export declare const DEFAULT_RESERVE_TOKENS = 16384;
+export declare const DEFAULT_PRESERVE_RECENT_TOKENS = 20000;
+export declare const DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS = 1024;
+export declare const TOOL_RESULT_CHAR_LIMIT = 2000;
+export declare const FILE_CONTENT_CHAR_LIMIT = 2000;
+export declare const MIN_TRUNCATED_MESSAGE_TOKENS = 8;
+export interface FileOperationSummary {
+    readFiles: string[];
+    modifiedFiles: string[];
+}
+export interface CompactionSummaryMetadata {
+    kind: "compaction_summary";
+    summary: string;
+    details: FileOperationSummary;
+    tokensBefore: number;
+    generatedAt: number;
+}
+export type EstimateMessageTokens = (message: MessageWithMetadata) => number;
+export declare function truncateText(text: string, limit: number): string;
+export declare function flattenToolResultContent(content: ToolResultContent["content"]): string;
+export declare function truncateToolResultContentForCompaction(content: ToolResultContent["content"]): ToolResultContent["content"];
+export declare function formatToolInput(input: Record<string, unknown>): string;
+export declare function serializeMessage(message: MessageWithMetadata): string;
+export declare function serializeConversation(messages: MessageWithMetadata[]): string;
+export declare function createTokenEstimator(): EstimateMessageTokens;
+export declare function isCompactionSummaryMessage(message: MessageWithMetadata): boolean;
+export declare function getCompactionSummaryMetadata(message: MessageWithMetadata): CompactionSummaryMetadata | undefined;
+export declare function isToolResultOnlyUserMessage(message: MessageWithMetadata): boolean;
+export declare function isTurnStartMessage(message: MessageWithMetadata): boolean;
+export declare function findFirstUserMessageIndex(messages: MessageWithMetadata[]): number;
+export declare function findLastTurnStartIndex(messages: MessageWithMetadata[]): number;
+export declare function findLastAssistantIndex(messages: MessageWithMetadata[]): number;
+export declare function findLatestSummaryIndex(messages: MessageWithMetadata[]): number;
+export declare function findCutIndex(messages: MessageWithMetadata[], preserveRecentTokens: number, estimateMessageTokens: EstimateMessageTokens): number;
+export declare function collectPaths(value: unknown): string[];
+export declare function mergeUnique(base: string[], next: Iterable<string>): string[];
+export declare function extractFileOps(messages: MessageWithMetadata[]): FileOperationSummary;
+export declare function renderFilesSection(fileOps: FileOperationSummary): string;
+export declare function ensureFilesSection(summary: string, fileOps: FileOperationSummary): string;
+export declare function buildSummaryRequest(options: {
+    previousSummary?: string;
+    conversationText: string;
+    fileOps: FileOperationSummary;
+}): string;
+export declare function resolveSummarizerConfig(options: {
+    activeProviderConfig: ProviderConfig;
+    summarizer?: CoreCompactionSummarizerConfig;
+}): ProviderConfig;
+export declare function buildSummaryMessage(options: {
+    summary: string;
+    fileOps: FileOperationSummary;
+    tokensBefore: number;
+}): MessageWithMetadata;
+export declare function getMaxInputTokens(context: Pick<CoreCompactionContext, "maxInputTokens">): number;

package/dist/extensions/context/compaction.d.ts

@@ -0,0 +1,38 @@
+import type { CoreCompactionContext, CoreSessionConfig } from "../../types/config";
+export interface ContextPipelinePrepareTurnInput {
+    agentId: string;
+    conversationId: string;
+    parentAgentId: string | null;
+    iteration: number;
+    messages: CoreCompactionContext["messages"];
+    apiMessages: CoreCompactionContext["messages"];
+    abortSignal: AbortSignal;
+    systemPrompt: string;
+    tools: unknown[];
+    model: CoreCompactionContext["model"];
+    emitStatusNotice?: (message: string, metadata?: Record<string, unknown>) => void;
+}
+export interface ContextPipelinePrepareTurnResult {
+    messages: CoreCompactionContext["messages"];
+    systemPrompt?: string;
+}
+export type ContextCompactionMode = "auto" | "manual";
+export interface ContextCompactionPrepareTurnOptions {
+    mode?: ContextCompactionMode;
+    manualTargetRatio?: number;
+}
+/**
+ * Build the `prepareTurn` callback used by the agent runtime to compact the
+ * transcript before each model request.
+ *
+ * Telemetry: emits `task.compaction_executed` on a successful compaction and
+ * `task.compaction_skipped` when the configured strategy returns `undefined`.
+ * Telemetry is keyed by `config.sessionId` (falling back to the per-turn
+ * `conversationId`) and tagged with `provider` / `modelId`.
+ *
+ * Known gap: compactions performed via plugin `registerMessageBuilder()` or
+ * via the `beforeModel` runtime hook bypass this wrapper entirely, so they
+ * do not emit compaction telemetry. If we want coverage there too, the
+ * plugin/hook pipelines must be instrumented separately.
+ */
+export declare function createContextCompactionPrepareTurn(config: Pick<CoreSessionConfig, "providerConfig" | "providerId" | "modelId" | "compaction" | "logger" | "telemetry" | "sessionId">, options?: ContextCompactionPrepareTurnOptions): ((context: ContextPipelinePrepareTurnInput) => Promise<ContextPipelinePrepareTurnResult | undefined>) | undefined;

package/dist/extensions/index.d.ts

@@ -0,0 +1,5 @@
+export type { ResolveAgentPluginPathsOptions } from "./plugin/plugin-config-loader";
+export { discoverPluginModulePaths, resolveAgentPluginPaths, resolveAndLoadAgentPlugins, resolvePluginConfigSearchPaths, } from "./plugin/plugin-config-loader";
+export type { PluginInitializationFailure, PluginInitializationWarning, PluginLoadDiagnostics, } from "./plugin/plugin-load-report";
+export type { LoadAgentPluginFromPathOptions } from "./plugin/plugin-loader";
+export { loadAgentPluginFromPath, loadAgentPluginsFromPaths, loadAgentPluginsFromPathsWithDiagnostics, } from "./plugin/plugin-loader";

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

@@ -0,0 +1,9 @@
+import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { McpServerClientFactory } from "./types";
+export interface DefaultMcpServerClientFactoryOptions {
+    settingsPath?: string;
+    clientName?: string;
+    clientVersion?: string;
+    fetch?: FetchLike;
+}
+export declare function createDefaultMcpServerClientFactory(options?: DefaultMcpServerClientFactoryOptions): McpServerClientFactory;

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

@@ -0,0 +1,25 @@
+import type { McpManager, McpServerOAuthState, McpServerOAuthStatus, McpServerRegistration } from "./types";
+export interface McpSettingsFile {
+    mcpServers: Record<string, Omit<McpServerRegistration, "name">>;
+}
+export interface LoadMcpSettingsOptions {
+    filePath?: string;
+}
+export interface RegisterMcpServersFromSettingsOptions {
+    filePath?: string;
+}
+export interface SetMcpServerDisabledOptions {
+    filePath?: string;
+    name: string;
+    disabled: boolean;
+}
+export declare function resolveDefaultMcpSettingsPath(): string;
+export declare function loadMcpSettingsFile(options?: LoadMcpSettingsOptions): McpSettingsFile;
+export declare function normalizeMcpServerOAuthState(value: McpServerOAuthState | undefined): McpServerOAuthState | undefined;
+export declare function hasMcpSettingsFile(options?: LoadMcpSettingsOptions): boolean;
+export declare function resolveMcpServerRegistrations(options?: LoadMcpSettingsOptions): McpServerRegistration[];
+export declare function setMcpServerDisabled(options: SetMcpServerDisabledOptions): void;
+export declare function getMcpServerOAuthState(serverName: string, options?: LoadMcpSettingsOptions): McpServerOAuthState | undefined;
+export declare function updateMcpServerOAuthState(serverName: string, updater: (current: McpServerOAuthState) => McpServerOAuthState, options?: LoadMcpSettingsOptions): McpServerOAuthState;
+export declare function listMcpServerOAuthStatuses(options?: LoadMcpSettingsOptions): McpServerOAuthStatus[];
+export declare function registerMcpServersFromSettingsFile(manager: Pick<McpManager, "registerServer">, options?: RegisterMcpServersFromSettingsOptions): Promise<McpServerRegistration[]>;

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

@@ -0,0 +1,11 @@
+export type { DefaultMcpServerClientFactoryOptions } from "./client";
+export { createDefaultMcpServerClientFactory } from "./client";
+export type { LoadMcpSettingsOptions, McpSettingsFile, RegisterMcpServersFromSettingsOptions, SetMcpServerDisabledOptions, } from "./config-loader";
+export { getMcpServerOAuthState, hasMcpSettingsFile, listMcpServerOAuthStatuses, loadMcpSettingsFile, registerMcpServersFromSettingsFile, resolveDefaultMcpSettingsPath, resolveMcpServerRegistrations, setMcpServerDisabled, updateMcpServerOAuthState, } from "./config-loader";
+export { InMemoryMcpManager } from "./manager";
+export type { AuthorizeMcpServerOAuthOptions, AuthorizeMcpServerOAuthResult, CreateMcpOAuthProviderContextOptions, McpOAuthProviderContext, } from "./oauth";
+export { authorizeMcpServerOAuth } from "./oauth";
+export type { CreateDisabledMcpToolPoliciesOptions, CreateDisabledMcpToolPolicyOptions, } from "./policies";
+export { createDisabledMcpToolPolicies, createDisabledMcpToolPolicy, } from "./policies";
+export { createMcpTools } from "./tools";
+export type { CreateMcpToolsOptions, McpConnectionStatus, McpManager, McpManagerOptions, McpServerClient, McpServerClientFactory, McpServerOAuthState, McpServerOAuthStatus, McpServerRegistration, McpServerSnapshot, McpServerTransportConfig, McpSseTransportConfig, McpStdioTransportConfig, McpStreamableHttpTransportConfig, McpToolCallRequest, McpToolCallResult, McpToolDescriptor, McpToolNameTransform, McpToolProvider, } from "./types";

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

@@ -0,0 +1,23 @@
+import type { McpManager, McpManagerOptions, McpServerRegistration, McpServerSnapshot, McpToolCallRequest, McpToolCallResult, McpToolDescriptor } from "./types";
+export declare class InMemoryMcpManager implements McpManager {
+    private readonly toolsCacheTtlMs;
+    private readonly clientFactory;
+    private readonly servers;
+    private readonly operationLocks;
+    constructor(options: McpManagerOptions);
+    registerServer(registration: McpServerRegistration): Promise<void>;
+    unregisterServer(serverName: string): Promise<void>;
+    connectServer(serverName: string): Promise<void>;
+    disconnectServer(serverName: string): Promise<void>;
+    setServerDisabled(serverName: string, disabled: boolean): Promise<void>;
+    listServers(): readonly McpServerSnapshot[];
+    listTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    refreshTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+    dispose(): Promise<void>;
+    private ensureConnectedClient;
+    private connectState;
+    private disconnectState;
+    private requireServer;
+    private runExclusive;
+}

package/dist/extensions/mcp/name-transform.d.ts

@@ -0,0 +1,2 @@
+import type { McpToolNameTransform } from "./types";
+export declare const defaultMcpToolNameTransform: McpToolNameTransform;

package/dist/extensions/mcp/oauth.d.ts

@@ -0,0 +1,48 @@
+import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { type OAuthServerCloseInfo, type OAuthServerListeningInfo } from "../../auth/server";
+import type { McpServerRegistration } from "./types";
+export type McpSdkAuthCapableTransport = SSEClientTransport | StreamableHTTPClientTransport;
+export interface CreateMcpOAuthProviderContextOptions {
+    settingsPath?: string;
+    serverName: string;
+    redirectUrl: string;
+    onAuthorizationUrl?: (url: string) => void | Promise<void>;
+}
+export interface McpOAuthProviderContext {
+    provider: OAuthClientProvider;
+    getLastAuthorizationUrl(): string | undefined;
+    getLastOAuthState(): string | undefined;
+    resetInteractiveState(): Promise<void>;
+    markError(errorMessage: string): Promise<void>;
+    clearError(): Promise<void>;
+}
+export interface AuthorizeMcpServerOAuthOptions {
+    serverName: string;
+    filePath?: string;
+    clientName?: string;
+    clientVersion?: string;
+    fetch?: FetchLike;
+    openUrl?: (url: string) => void | Promise<void>;
+    callbackHost?: string;
+    callbackPorts?: number[];
+    callbackPath?: string;
+    timeoutMs?: number;
+    successHtml?: string;
+    onServerListening?: (info: OAuthServerListeningInfo) => void | Promise<void>;
+    onServerClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
+}
+export interface AuthorizeMcpServerOAuthResult {
+    serverName: string;
+    authorized: true;
+    message: string;
+}
+export declare function createMcpOAuthProviderContext(options: CreateMcpOAuthProviderContextOptions): McpOAuthProviderContext;
+export declare function createMcpSdkTransport(input: {
+    registration: McpServerRegistration;
+    oauthProvider?: OAuthClientProvider;
+    fetch?: FetchLike;
+}): McpSdkAuthCapableTransport;
+export declare function authorizeMcpServerOAuth(options: AuthorizeMcpServerOAuthOptions): Promise<AuthorizeMcpServerOAuthResult>;

package/dist/extensions/mcp/policies.d.ts

@@ -0,0 +1,14 @@
+import type { ToolPolicy } from "@cline/shared";
+import type { McpToolNameTransform } from "./types";
+export interface CreateDisabledMcpToolPolicyOptions {
+    serverName: string;
+    toolName: string;
+    nameTransform?: McpToolNameTransform;
+}
+export interface CreateDisabledMcpToolPoliciesOptions {
+    serverName: string;
+    toolNames: readonly string[];
+    nameTransform?: McpToolNameTransform;
+}
+export declare function createDisabledMcpToolPolicy(options: CreateDisabledMcpToolPolicyOptions): Record<string, ToolPolicy>;
+export declare function createDisabledMcpToolPolicies(options: CreateDisabledMcpToolPoliciesOptions): Record<string, ToolPolicy>;

package/dist/extensions/mcp/tools.d.ts

@@ -0,0 +1,3 @@
+import { type AgentTool } from "@cline/shared";
+import type { CreateMcpToolsOptions } from "./types";
+export declare function createMcpTools(options: CreateMcpToolsOptions): Promise<AgentTool[]>;

package/dist/extensions/mcp/types.d.ts

@@ -0,0 +1,111 @@
+import type { AgentToolContext } from "@cline/shared";
+export interface McpToolDescriptor {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface McpToolCallRequest {
+    serverName: string;
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    context?: AgentToolContext;
+}
+export type McpToolCallResult = unknown;
+export interface McpToolProvider {
+    listTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+}
+export type McpToolNameTransform = (input: {
+    serverName: string;
+    toolName: string;
+}) => string;
+export interface CreateMcpToolsOptions {
+    serverName: string;
+    provider: McpToolProvider;
+    nameTransform?: McpToolNameTransform;
+    timeoutMs?: number;
+    retryable?: boolean;
+    maxRetries?: number;
+}
+export type McpConnectionStatus = "disconnected" | "connecting" | "connected";
+export interface McpStdioTransportConfig {
+    type: "stdio";
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface McpSseTransportConfig {
+    type: "sse";
+    url: string;
+    headers?: Record<string, string>;
+}
+export interface McpStreamableHttpTransportConfig {
+    type: "streamableHttp";
+    url: string;
+    headers?: Record<string, string>;
+}
+export type McpServerTransportConfig = McpStdioTransportConfig | McpSseTransportConfig | McpStreamableHttpTransportConfig;
+export interface McpServerOAuthState {
+    clientInformation?: Record<string, unknown>;
+    tokens?: Record<string, unknown>;
+    codeVerifier?: string;
+    discoveryState?: Record<string, unknown>;
+    redirectUrl?: string;
+    lastError?: string;
+    lastAuthenticatedAt?: number;
+}
+export interface McpServerRegistration {
+    name: string;
+    transport: McpServerTransportConfig;
+    disabled?: boolean;
+    metadata?: Record<string, unknown>;
+    oauth?: McpServerOAuthState;
+}
+export interface McpServerSnapshot {
+    name: string;
+    status: McpConnectionStatus;
+    disabled: boolean;
+    lastError?: string;
+    toolCount: number;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
+}
+export interface McpServerClient {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    listTools(): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: {
+        name: string;
+        arguments?: Record<string, unknown>;
+        context?: AgentToolContext;
+    }): Promise<McpToolCallResult>;
+}
+export type McpServerClientFactory = (registration: McpServerRegistration) => Promise<McpServerClient> | McpServerClient;
+export interface McpServerOAuthStatus {
+    serverName: string;
+    oauthSupported: boolean;
+    oauthConfigured: boolean;
+    lastError?: string;
+    lastAuthenticatedAt?: number;
+}
+export interface McpManagerOptions {
+    clientFactory: McpServerClientFactory;
+    /**
+     * Cache TTL for tools/list responses.
+     * A short cache avoids repeated list requests while keeping server metadata fresh.
+     * @default 5000
+     */
+    toolsCacheTtlMs?: number;
+}
+export interface McpManager extends McpToolProvider {
+    registerServer(registration: McpServerRegistration): Promise<void>;
+    unregisterServer(serverName: string): Promise<void>;
+    connectServer(serverName: string): Promise<void>;
+    disconnectServer(serverName: string): Promise<void>;
+    setServerDisabled(serverName: string, disabled: boolean): Promise<void>;
+    listServers(): readonly McpServerSnapshot[];
+    refreshTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+    dispose(): Promise<void>;
+}

package/dist/extensions/plugin/plugin-config-loader.d.ts

@@ -0,0 +1,40 @@
+import type { AgentConfig, PluginSetupContext, WorkspaceInfo } from "@cline/shared";
+import type { PluginLoadDiagnostics } from "./plugin-load-report";
+import type { PluginTargeting } from "./plugin-targeting";
+type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
+export declare function resolvePluginConfigSearchPaths(workspacePath?: string): string[];
+export declare function discoverPluginModulePaths(directoryPath: string): string[];
+export interface ResolveAgentPluginPathsOptions {
+    pluginPaths?: ReadonlyArray<string>;
+    workspacePath?: string;
+    cwd?: string;
+}
+export declare function resolveAgentPluginPaths(options?: ResolveAgentPluginPathsOptions): string[];
+export interface ResolveAndLoadAgentPluginsOptions extends ResolveAgentPluginPathsOptions, PluginTargeting {
+    mode?: "sandbox" | "in_process";
+    exportName?: string;
+    importTimeoutMs?: number;
+    hookTimeoutMs?: number;
+    contributionTimeoutMs?: number;
+    onEvent?: (event: {
+        name: string;
+        payload?: unknown;
+    }) => void;
+    /**
+     * Structured workspace and git metadata. Forwarded to sandboxed plugins
+     * via PluginSetupCtx.workspaceInfo and made available to in-process plugins
+     * in the extension context.
+     */
+    workspaceInfo?: WorkspaceInfo;
+    session?: PluginSetupContext["session"];
+    client?: PluginSetupContext["client"];
+    user?: PluginSetupContext["user"];
+    automation?: PluginSetupContext["automation"];
+    logger?: PluginSetupContext["logger"];
+    telemetry?: PluginSetupContext["telemetry"];
+}
+export declare function resolveAndLoadAgentPlugins(options?: ResolveAndLoadAgentPluginsOptions): Promise<{
+    extensions: AgentPlugin[];
+    shutdown?: () => Promise<void>;
+} & PluginLoadDiagnostics>;
+export {};

package/dist/extensions/plugin/plugin-load-report.d.ts

@@ -0,0 +1,18 @@
+export interface PluginInitializationFailure {
+    pluginPath: string;
+    pluginName?: string;
+    phase: "load" | "setup";
+    message: string;
+    stack?: string;
+}
+export interface PluginInitializationWarning {
+    type: "duplicate_plugin_override";
+    pluginPath: string;
+    pluginName: string;
+    overriddenPluginPath: string;
+    message: string;
+}
+export interface PluginLoadDiagnostics {
+    failures: PluginInitializationFailure[];
+    warnings: PluginInitializationWarning[];
+}