@cline/core 0.0.38-nightly.1778113663

package/dist/runtime/orchestration/session-runtime-orchestrator.d.ts

@@ -0,0 +1,218 @@
+/**
+ * Per-session `SessionRuntime` orchestrator.
+ *
+ * Owns all cross-turn state for one logical agent session:
+ *
+ *   - `ConversationStore`      — message transcript + session-started gate
+ *   - `MistakeTracker`         — per-session consecutive-mistake counter
+ *   - `LoopDetectionTracker`   — per-session repeated-tool-call detector
+ *   - `MessageBuilder`         — provider-message assembly cache
+ *   - `AgentRuntimeHooks`      — runtime-native hooks from config/extensions
+ *   - `RuntimeEventAdapter`    — per-run stateful `AgentRuntimeEvent`
+ *                                → legacy `AgentEvent` translator
+ *   - listener registry        — host subscribers see legacy `AgentEvent`s
+ *   - pending tool set, abort  — per-run lifecycle housekeeping
+ *
+ * A fresh `AgentRuntime` is instantiated per run via
+ * `createAgentRuntime(createAgentRuntimeConfig({...}))`. All
+ * session-level state outlives any one `AgentRuntime`, making
+ * OAuth-retry and run replay feasible.
+ */
+import type { AgentRuntime } from "@cline/agents";
+import { createAgentRuntime } from "@cline/agents";
+import { type AgentConfig, type AgentEvent, type AgentExtensionRegistry, type AgentResult, type AgentTool, type BasicLogger, type ITelemetryService, type Message, type MessageWithMetadata } from "@cline/shared";
+import { MessageBuilder } from "../../session/services/message-builder";
+/**
+ * Listener invoked for every legacy `AgentEvent` produced by the
+ * session runtime. Use `subscribeEvents(listener)` — it returns an
+ * `unsubscribe` function.
+ */
+export type SessionEventListener = (event: AgentEvent) => void;
+/** Subset of host-side deps needed by the session orchestrator. */
+export interface SessionRuntimeOrchestratorDeps {
+    readonly logger?: BasicLogger;
+    readonly telemetry?: ITelemetryService;
+    /**
+     * Test hook: override the `AgentRuntime` factory. Production
+     * callers leave this undefined and get the real `createAgentRuntime`.
+     */
+    readonly createAgentRuntimeImpl?: (config: Parameters<typeof createAgentRuntime>[0]) => AgentRuntime;
+}
+/** Connection overrides applied via `updateConnection`. */
+export interface ConnectionOverrides {
+    providerId?: string;
+    modelId?: string;
+    apiKey?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    providerConfig?: unknown;
+    reasoningEffort?: AgentConfig["reasoningEffort"];
+    thinking?: boolean;
+    thinkingBudgetTokens?: number;
+}
+/**
+ * Per-session orchestrator. Construct once per agent session; call
+ * `run` / `continue` repeatedly. The class matches the subset of
+ * runtime-facing session surface.
+ */
+export declare class SessionRuntime {
+    private config;
+    private readonly agentId;
+    private readonly parentAgentId?;
+    private readonly logger?;
+    readonly telemetry?: ITelemetryService;
+    private readonly conversation;
+    private readonly mistakeTracker;
+    private readonly loopTracker;
+    /**
+     * True when `execution.loopDetection === false` at construction
+     * time. Loop inspection is skipped entirely — the tracker still
+     * exists for API compatibility but is never fed.
+     */
+    private readonly loopDetectionDisabled;
+    readonly messageBuilder: MessageBuilder;
+    /**
+     * Contribution registry that hosts extension-provided tools,
+     * commands, message builders, and providers. Lazily initialized
+     * on first run (parity with legacy `Agent.ensureExtensionsInitialized`
+     * at `packages/agents/src/agent.ts:1122-1147`).
+     */
+    private readonly contributionRegistry;
+    private extensionsInitialized;
+    private readonly listeners;
+    private readonly createAgentRuntimeImpl;
+    /** Stable run id for the active run. */
+    private activeRunId;
+    /** True while a run is in flight. `canStartRun()` is the negation. */
+    private running;
+    /** True once `abort()` has been requested for the active run. */
+    private abortRequested;
+    /** Last abort reason requested for the active run. */
+    private abortReason;
+    /** Reference to the current run's `AgentRuntime` so `abort` can forward. */
+    private activeRuntime;
+    /** Promise returned from the current run so shutdown can await its drain. */
+    private activeRunPromise;
+    /** Per-run `Agent → AgentEvent` adapter; `reset()` each run. */
+    private readonly eventAdapter;
+    /** Session-shutdown gate — rejects late runs. */
+    private shutdownCalled;
+    /** Running tally of tool-call records for `AgentResult.toolCalls`. */
+    private currentRunToolCalls;
+    /** Aggregated usage across the current run. */
+    private currentRunUsage;
+    /** Tool-start timestamps for `ToolCallRecord.durationMs`. */
+    private toolStartedAt;
+    /** Tool-call input snapshot for `ToolCallRecord.input`. */
+    private toolInputs;
+    /**
+     * Per-turn tool outcome counters used by the MistakeTracker wiring.
+     * Reset on every `turn-started` event; consumed on `turn-finished`
+     * to feed `mistakeTracker.record` when every tool call erred and no
+     * successful call landed. Matches legacy `agent.ts` tool-failure
+     * mistake-feed path (§3.4.6 + pre-Step-9 oracle lines 972-997).
+     */
+    private currentTurnSuccessfulTools;
+    private currentTurnFailedTools;
+    private currentTurnFailureDetails;
+    /**
+     * Serial queue for `MistakeTracker.record(...)` + loop-detection
+     * side-effects fired from the sync `handleRuntimeEvent` stream. The
+     * tracker's `record()` is async but the runtime event stream is
+     * synchronous, so we chain tracker work onto a promise and await it
+     * in `executeRun` before returning the `AgentResult`.
+     */
+    private activeTrackerWork;
+    /** True when tracker logic has issued an abort for the active run. */
+    private trackerAbortInFlight;
+    constructor(config: AgentConfig, deps?: SessionRuntimeOrchestratorDeps);
+    getAgentId(): string;
+    getConversationId(): string;
+    getMessages(): MessageWithMetadata[];
+    /** True when no run is currently active and the session is not shut down. */
+    canStartRun(): boolean;
+    /**
+     * Snapshot of the contribution registry (tools, commands, and other
+     * extension contributions).
+     *
+     * Before the first run, the registry is in the `validate` phase:
+     * extensions are validated but their `setup()` callbacks have not
+     * run yet, so the snapshot only reflects eagerly-declared
+     * contributions. After the first `run()`/`continue()`, the
+     * registry is initialized (§`ensureExtensionsInitialized`), and
+     * the snapshot reflects everything extensions registered via
+     * `api.registerTool` / `registerCommand` / `registerMessageBuilder`
+     * / `registerProvider` / `registerAutomationEventType`.
+     */
+    getExtensionRegistry(): AgentExtensionRegistry<AgentTool, Message[]>;
+    /** Append additional tools to every subsequent turn's runtime config. */
+    addTools(tools: AgentTool[]): void;
+    /** Mutate provider / reasoning fields for subsequent runs. */
+    updateConnection(overrides: ConnectionOverrides): void;
+    clearHistory(): void;
+    restore(messages: readonly MessageWithMetadata[]): void;
+    private resetConversationBoundaryTrackers;
+    /**
+     * Subscribe to **legacy** `AgentEvent`s. The session runtime
+     * translates the new `AgentRuntimeEvent` stream via
+     * `RuntimeEventAdapter` before fanout, so consumers see the
+     * pre-swap shape.
+     */
+    subscribeEvents(listener: SessionEventListener): () => void;
+    abort(reason?: unknown): void;
+    /** Shut the session down after any active run drains. */
+    shutdown(_reason?: string, _timeoutMs?: number): Promise<void>;
+    run(userMessage: string, userImages?: string[], userFiles?: string[]): Promise<AgentResult>;
+    continue(userMessage?: string, userImages?: string[], userFiles?: string[]): Promise<AgentResult>;
+    private composeSystemPrompt;
+    private executeRun;
+    private executeRunInternal;
+    /**
+     * Initialize the contribution registry once per session. Runs
+     * extension `setup()` callbacks so they can `registerTool`,
+     * `registerCommand`, `registerMessageBuilder`, and
+     * `registerProvider`. Matches legacy `Agent.ensureExtensionsInitialized`
+     * at pre-Step-9 `agent.ts:1122-1147`:
+     *
+     *   - on `hookErrorMode === "throw"`, setup failures propagate;
+     *   - otherwise setup failures emit a recoverable `error` event
+     *     via the legacy event channel and leave the registry
+     *     partially initialized.
+     *
+     * Idempotent: subsequent calls are no-ops once the registry has
+     * been activated.
+     */
+    private ensureExtensionsInitialized;
+    private createRuntimeHooks;
+    private createRuntimePrepareTurn;
+    private prepareMessagesForModelRequest;
+    private prepareProviderMessagesForApi;
+    private handleRuntimeEvent;
+    private syncConversationFromRuntimeMessage;
+    private emitLegacyEvent;
+    /**
+     * Feed the `LoopDetectionTracker` with a tool-call and react to
+     * the returned verdict. Parity with pre-Step-9 agent.ts L917-954:
+     *
+     *   - `"soft"`  → append a recovery notice telling the model to
+     *                 change approach;
+     *   - `"hard"`  → feed `MistakeTracker.record` with
+     *                 `forceAtLimit:true`. When the tracker returns
+     *                 `action: "stop"`, append the stop notice and
+     *                 abort the active runtime.
+     */
+    private inspectLoopForToolCall;
+    /**
+     * Enqueue a mistake-record onto the serial tracker work chain. The
+     * runtime event stream is synchronous but `MistakeTracker.record`
+     * is async — chaining onto a shared promise preserves ordering
+     * (legacy parity) and lets `executeRun` await draining before
+     * returning the `AgentResult`.
+     *
+     * When the tracker returns `action: "stop"`, append the stop notice
+     * to the conversation and abort the active runtime so the run ends
+     * with `finishReason: "aborted"`.
+     */
+    private enqueueMistakeRecord;
+    private buildLegacyResult;
+}

package/dist/runtime/orchestration/session-runtime.d.ts

@@ -0,0 +1,58 @@
+import type { AgentConfig, AgentHooks, AgentResult, AgentTool, BasicLogger, ITelemetryService, RuntimeConfigExtensionKind } from "@cline/shared";
+import type { UserInstructionConfigService } from "../../extensions/config";
+import type { ToolExecutors } from "../../extensions/tools";
+import type { AgentTeamsRuntime, DelegatedAgentConfigProvider, TeamEvent } from "../../extensions/tools/team";
+import type { WorkspaceManager } from "../../services/workspace/workspace-manager";
+import type { CoreSessionConfig } from "../../types/config";
+/**
+ * Internal structural alias for the lead-agent handle that
+ * {@link BuiltRuntime.registerLeadAgent} hands off to
+ * `runtime-builder.ts`. Narrowed to only the `.addTools()` surface the
+ * callback exercises; avoids depending on `@cline/agents`' `Agent`
+ * class during the PLAN.md §3.6 Step 5 type-only migration. When
+ * SessionRuntime is rebuilt in Step 6, this field is expected to be
+ * dropped entirely per §3.5 row #2.
+ */
+type LeadAgentHandle = {
+    addTools(tools: AgentTool[]): unknown;
+};
+export interface BuiltRuntime {
+    tools: AgentTool[];
+    hooks?: AgentHooks;
+    logger?: BasicLogger;
+    telemetry?: ITelemetryService;
+    teamRuntime?: AgentTeamsRuntime;
+    teamRestoredFromPersistence?: boolean;
+    delegatedAgentConfigProvider?: DelegatedAgentConfigProvider;
+    extensions?: AgentConfig["extensions"];
+    completionPolicy?: AgentConfig["completionPolicy"];
+    registerLeadAgent?: (agent: LeadAgentHandle) => void;
+    shutdown: (reason: string) => Promise<void> | void;
+}
+export interface RuntimeBuilderInput {
+    config: CoreSessionConfig;
+    hooks?: AgentHooks;
+    extensions?: AgentConfig["extensions"];
+    onTeamEvent?: (event: TeamEvent) => void;
+    createSpawnTool?: () => AgentTool;
+    onTeamRestored?: () => void;
+    userInstructionService?: UserInstructionConfigService;
+    configExtensions?: RuntimeConfigExtensionKind[];
+    toolExecutors?: Partial<ToolExecutors>;
+    workspaceManager?: WorkspaceManager;
+    logger?: BasicLogger;
+    telemetry?: ITelemetryService;
+}
+export interface RuntimeBuilder {
+    build(input: RuntimeBuilderInput): Promise<BuiltRuntime> | BuiltRuntime;
+}
+export interface SessionRuntime {
+    start(config: CoreSessionConfig): Promise<{
+        sessionId: string;
+    }>;
+    send(sessionId: string, prompt: string): Promise<AgentResult | undefined>;
+    abort(sessionId: string, reason?: unknown): Promise<void>;
+    stop(sessionId: string): Promise<void>;
+    poll(): Promise<string[]>;
+}
+export {};

package/dist/runtime/orchestration/user-input-builder.d.ts

@@ -0,0 +1,15 @@
+/**
+ * User-input / first-turn content assembler.
+ *
+ * Opens the first user content array for a turn, loading user file contents via
+ * the injected `userFileContentLoader`.
+ */
+import type * as LlmsProviders from "@cline/llms";
+export declare function buildInitialUserContent(userMessage: string, userImages?: string[], userFiles?: string[], userFileContentLoader?: (path: string) => Promise<string>): Promise<string | LlmsProviders.ContentBlock[]>;
+/**
+ * Normalize a user message shape into a plain string when possible.
+ *
+ * Accepts either a string or a LlmsProviders.Message; returns the best-effort
+ * concatenated plain-text body. Non-text content is ignored.
+ */
+export declare function normalizeUserMessage(input: string | LlmsProviders.Message | undefined): string;

package/dist/runtime/safety/loop-detection.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Repeated tool-call loop detection.
+ *
+ * @see PLAN.md §3.1 — helpers moved from `packages/agents/src/context/loop-detection.ts`.
+ * @see PLAN.md §3.2.3 — public surface of `LoopDetectionTracker`.
+ *
+ * The pure helpers (`createLoopDetectionState`, `resetLoopDetectionState`,
+ * `toolCallSignature`, `checkRepeatedToolCall`) are ported verbatim. The
+ * `LoopDetectionTracker` class is a thin wrapper that owns a
+ * `LoopDetectionState` and exposes the `inspect()` / `reset()` surface that
+ * `SessionRuntime` installs as a `beforeTool` hook per §3.2.3.
+ */
+import type { LoopDetectionConfig } from "@cline/shared";
+export interface LoopDetectionState {
+    lastToolName: string;
+    lastToolSignature: string;
+    consecutiveIdenticalCount: number;
+}
+export declare function createLoopDetectionState(): LoopDetectionState;
+export declare function resetLoopDetectionState(state: LoopDetectionState): void;
+export declare function toolCallSignature(input: unknown): string;
+export interface LoopCheckResult {
+    softWarning: boolean;
+    hardEscalation: boolean;
+}
+export declare function checkRepeatedToolCall(state: LoopDetectionState, toolName: string, signature: string, config: LoopDetectionConfig): LoopCheckResult;
+/**
+ * Verdict returned by {@link LoopDetectionTracker.inspect}.
+ *
+ * - `"ok"`   — no repeated call detected.
+ * - `"soft"` — soft-warning threshold reached; SessionRuntime may surface a
+ *              recovery notice but should not block the call.
+ * - `"hard"` — hard-escalation threshold reached; SessionRuntime should
+ *              stop the run with the provided `message`.
+ */
+export interface LoopDetectionVerdict {
+    kind: "ok" | "soft" | "hard";
+    message?: string;
+}
+/** Minimal call shape the tracker needs; matches `AgentToolCallPart` subset. */
+export interface LoopDetectionCall {
+    name: string;
+    input: unknown;
+}
+/**
+ * Per-session repeated-tool-call detector.
+ *
+ * `SessionRuntime` owns the instance and installs a `beforeTool` hook
+ * (see `AgentRuntimeHooks.beforeTool`) that calls `inspect()` to decide
+ * whether to return `{ skip, stop, reason }`.
+ */
+export declare class LoopDetectionTracker {
+    private readonly config;
+    private readonly state;
+    constructor(config?: Partial<LoopDetectionConfig>);
+    inspect(call: LoopDetectionCall): LoopDetectionVerdict;
+    reset(): void;
+}

package/dist/runtime/safety/mistake-tracker.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Per-session consecutive-mistake tracker.
+ *
+ * @see PLAN.md §3.1 — wrapped around `recordMistake` moved from
+ *                    `packages/agents/src/api/error-handling.ts` lines 147–311.
+ * @see PLAN.md §3.2.3 — public surface of `MistakeTracker`.
+ *
+ * The pure procedural `recordMistake(input, deps)` becomes `record(input)`
+ * on the class; `consecutiveMistakes` is internal state. Other deps flow
+ * through the constructor instead.
+ *
+ * NOTE: the §3.2.3 constructor shape omits some fields (agentId,
+ * conversationId/runId getters, appendRecoveryNotice). They are retained
+ * here for log + notice parity per PLAN.md §3.4.3/§3.4.5. Step 8
+ * (`impl-runtime-porter`) may refactor once SessionRuntime is wired up.
+ */
+import type { AgentEvent, BasicLogMetadata, ConsecutiveMistakeLimitContext, ConsecutiveMistakeLimitDecision } from "@cline/shared";
+/**
+ * Legacy-agents-style leveled log function. The sdk-re `BasicLogger`
+ * does not carry a level argument (§shared/logging/logger.ts); callers
+ * are expected to bridge via `metadata.severity` or dispatch to
+ * `debug`/`log`/`error`. `MistakeTracker` accepts a leveled callable
+ * here so Step 8 can plug in whichever bridging shape `SessionRuntime`
+ * ends up using.
+ */
+export type LeveledLog = (level: "debug" | "info" | "warn" | "error", message: string, metadata?: BasicLogMetadata) => void;
+export type MistakeReason = "api_error" | "invalid_tool_call" | "tool_execution_failed";
+export interface RecordMistakeInput {
+    iteration: number;
+    reason: MistakeReason;
+    details?: string;
+    /** When true, jump straight to maxConsecutiveMistakes instead of incrementing by 1. */
+    forceAtLimit?: boolean;
+}
+export type MistakeOutcome = {
+    action: "continue";
+    guidance?: string;
+} | {
+    action: "stop";
+    message: string;
+    reason?: string;
+};
+export interface MistakeTrackerOptions {
+    readonly maxConsecutiveMistakes: number;
+    readonly onLimitReached?: (ctx: ConsecutiveMistakeLimitContext) => Promise<ConsecutiveMistakeLimitDecision> | ConsecutiveMistakeLimitDecision;
+    readonly emit: (event: AgentEvent) => void;
+    readonly log: LeveledLog;
+    readonly agentId: string;
+    readonly getConversationId: () => string;
+    readonly getActiveRunId: () => string;
+    readonly appendRecoveryNotice: (message: string, reason: MistakeReason) => void;
+}
+export declare class MistakeTracker {
+    private consecutiveMistakes;
+    private readonly options;
+    constructor(options: MistakeTrackerOptions);
+    record(input: RecordMistakeInput): Promise<MistakeOutcome>;
+    reset(): void;
+    get value(): number;
+}
+export declare function buildMistakeLimitStopMessage(input: {
+    iteration: number;
+    consecutiveMistakes: number;
+    maxConsecutiveMistakes: number;
+    reason: "api_error" | "invalid_tool_call" | "completion_without_submit" | "tool_execution_failed";
+    details?: string;
+    stopReason?: string;
+}): string;

package/dist/runtime/safety/rules.d.ts

@@ -0,0 +1,6 @@
+import type { RuleConfig, UserInstructionConfigWatcher } from "../../extensions/config/user-instruction-config-loader";
+export declare function isRuleEnabled(rule: RuleConfig): boolean;
+export declare function formatRulesForSystemPrompt(rules: ReadonlyArray<RuleConfig>): string;
+export declare function mergeRulesForSystemPrompt(primaryRules?: string, additionalRules?: string): string | undefined;
+export declare function listEnabledRulesFromWatcher(watcher: UserInstructionConfigWatcher): RuleConfig[];
+export declare function loadRulesForSystemPromptFromWatcher(watcher: UserInstructionConfigWatcher): string;

package/dist/runtime/tools/subprocess-sandbox.d.ts

@@ -0,0 +1,43 @@
+export interface SubprocessSandboxOptions {
+    /** Inline script to execute via `node -e`. Mutually exclusive with {@link bootstrapFile}. */
+    bootstrapScript?: string;
+    /** Path to a JavaScript file to execute via `node <file>`. Mutually exclusive with {@link bootstrapScript}. */
+    bootstrapFile?: string;
+    /** Runtime executable for internal JavaScript helpers. Defaults to node/bun instead of packaged CLI binaries. */
+    runtimeExecutable?: string;
+    name?: string;
+    onEvent?: (event: {
+        name: string;
+        payload?: unknown;
+    }) => void;
+}
+export interface SandboxCallOptions {
+    timeoutMs?: number;
+}
+export declare const CLINE_JS_RUNTIME_PATH_ENV = "CLINE_JS_RUNTIME_PATH";
+export declare function resolveSubprocessRuntimeExecutable(options?: {
+    env?: NodeJS.ProcessEnv;
+    execPath?: string;
+    runtimeExecutable?: string;
+}): string;
+export declare function buildSubprocessSandboxCommand(args: string[], options?: {
+    env?: NodeJS.ProcessEnv;
+    execArgv?: string[];
+    name?: string;
+    execPath?: string;
+    runtimeExecutable?: string;
+}): string[];
+export declare class SubprocessSandbox {
+    private readonly options;
+    private process;
+    private requestCounter;
+    private readonly pending;
+    constructor(options: SubprocessSandboxOptions);
+    private get processLabel();
+    private clearPendingRequest;
+    start(): void;
+    call<TResult = unknown>(method: string, args: unknown, options?: SandboxCallOptions): Promise<TResult>;
+    shutdown(): Promise<void>;
+    private onMessage;
+    private failPending;
+}

package/dist/runtime/tools/tool-approval.d.ts

@@ -0,0 +1,9 @@
+import type { ToolApprovalRequest, ToolApprovalResult } from "@cline/shared";
+export type DesktopToolApprovalOptions = {
+    approvalDir?: string;
+    sessionId?: string;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    nowIso?: () => string;
+};
+export declare function requestDesktopToolApproval(request: ToolApprovalRequest, options?: DesktopToolApprovalOptions): Promise<ToolApprovalResult>;

package/dist/runtime/turn-queue/pending-prompt-service.d.ts

@@ -0,0 +1,64 @@
+import type { CoreSessionEvent, SessionPendingPrompt } from "../../types/events";
+import type { ActiveSession } from "../../types/session";
+import type { PendingPromptMutationResult, PendingPromptsDeleteInput, PendingPromptsUpdateInput } from "../host/runtime-host";
+export type PendingPromptDelivery = "queue" | "steer";
+export interface PendingPromptEntry {
+    id: string;
+    prompt: string;
+    delivery: PendingPromptDelivery;
+    userImages?: string[];
+    userFiles?: string[];
+}
+export interface PendingPromptQueueState {
+    pendingPrompts: PendingPromptEntry[];
+}
+export interface PendingPromptsControllerDeps {
+    getSession(sessionId: string): ActiveSession | undefined;
+    emit(event: CoreSessionEvent): void;
+    send(input: {
+        sessionId: string;
+        prompt: string;
+        userImages?: string[];
+        userFiles?: string[];
+    }): Promise<unknown>;
+}
+export interface PendingPromptEnqueueInput {
+    prompt: string;
+    delivery: PendingPromptDelivery;
+    userImages?: string[];
+    userFiles?: string[];
+}
+export interface PendingPromptConsumeResult {
+    entry?: PendingPromptEntry;
+    prompts: SessionPendingPrompt[];
+}
+export declare class PendingPromptService {
+    list(state: PendingPromptQueueState | undefined): SessionPendingPrompt[];
+    update(state: PendingPromptQueueState | undefined, input: PendingPromptsUpdateInput): PendingPromptMutationResult;
+    delete(state: PendingPromptQueueState | undefined, input: PendingPromptsDeleteInput): PendingPromptMutationResult;
+    enqueue(state: PendingPromptQueueState, input: PendingPromptEnqueueInput): SessionPendingPrompt[];
+    consumeSteer(state: PendingPromptQueueState): PendingPromptConsumeResult;
+    shiftNext(state: PendingPromptQueueState): PendingPromptConsumeResult;
+    requeueFront(state: PendingPromptQueueState, entry: PendingPromptEntry): SessionPendingPrompt[];
+    clear(state: PendingPromptQueueState): SessionPendingPrompt[];
+}
+export declare class PendingPromptsController {
+    private readonly deps;
+    private readonly service;
+    constructor(deps: PendingPromptsControllerDeps);
+    list(sessionId: string): SessionPendingPrompt[];
+    update(input: PendingPromptsUpdateInput): PendingPromptMutationResult;
+    delete(input: PendingPromptsDeleteInput): PendingPromptMutationResult;
+    enqueue(sessionId: string, entry: {
+        prompt: string;
+        delivery: "queue" | "steer";
+        userImages?: string[];
+        userFiles?: string[];
+    }): void;
+    consumeSteer(sessionId: string): string | undefined;
+    clearAborted(session: ActiveSession): void;
+    emitPrompts(session: ActiveSession): void;
+    scheduleDrain(sessionId: string, session: ActiveSession): void;
+    drain(sessionId: string): Promise<void>;
+    private emitSubmitted;
+}

package/dist/services/agent-events.d.ts

@@ -0,0 +1,33 @@
+import type { AgentEvent } from "@cline/shared";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+import type { CoreSessionConfig } from "../types/config";
+import type { CoreSessionEvent } from "../types/events";
+import type { ActiveSession } from "../types/session";
+import { type TelemetryAgentIdentityProperties } from "./telemetry/core-events";
+export declare function extractSkillNameFromToolInput(input: unknown): string | undefined;
+export interface AgentEventContext {
+    sessionId: string;
+    config: CoreSessionConfig;
+    liveSession: ActiveSession | undefined;
+    usageBySession: Map<string, SessionAccumulatedUsage>;
+    persistMessages: (sessionId: string, messages: unknown[], systemPrompt?: string) => void;
+    emit: (event: CoreSessionEvent) => void;
+}
+export interface AgentTelemetryContextOverrides {
+    agentId?: string;
+    conversationId?: string;
+    parentAgentId?: string | null;
+    createdByAgentId?: string;
+    teamId?: string;
+    teamName?: string;
+    teamRole?: "lead" | "teammate";
+    teamAgentId?: string;
+    isPrimaryAgentEvent?: boolean;
+}
+export declare function extractAgentEventMetadata(event: AgentEvent): {
+    agentId?: string;
+    conversationId?: string;
+    parentAgentId?: string;
+};
+export declare function buildTelemetryAgentIdentity(context: AgentTelemetryContextOverrides): TelemetryAgentIdentityProperties | undefined;
+export declare function handleAgentEvent(ctx: AgentEventContext, event: AgentEvent, overrides?: AgentTelemetryContextOverrides): void;

package/dist/services/config.d.ts

@@ -0,0 +1,2 @@
+import type { CoreSessionConfig } from "../types/config";
+export declare function resolveWorkspacePath(config: CoreSessionConfig): string;

package/dist/services/global-settings.d.ts

@@ -0,0 +1,34 @@
+import type { AgentConfig, AgentTool, ITelemetryService } from "@cline/shared";
+import { z } from "zod";
+export declare const GlobalSettingsSchema: z.ZodPipe<z.ZodObject<{
+    telemetryOptOut: z.ZodCatch<z.ZodDefault<z.ZodBoolean>>;
+    disabledTools: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
+    disabledPlugins: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
+}, z.core.$strip>, z.ZodTransform<{
+    telemetryOptOut: boolean;
+    disabledTools?: string[];
+    disabledPlugins?: string[];
+}, {
+    telemetryOptOut: boolean;
+    disabledTools?: string[] | undefined;
+    disabledPlugins?: string[] | undefined;
+}>>;
+export type GlobalSettings = z.infer<typeof GlobalSettingsSchema>;
+export interface WriteGlobalSettingsOptions {
+    telemetry?: ITelemetryService;
+}
+export declare function readGlobalSettings(): GlobalSettings;
+export declare function writeGlobalSettings(settings: z.input<typeof GlobalSettingsSchema>, options?: WriteGlobalSettingsOptions): void;
+export declare function isTelemetryOptedOutGlobally(): boolean;
+export declare function setTelemetryOptOutGlobally(telemetryOptOut: boolean, options?: WriteGlobalSettingsOptions): void;
+export declare function resolveDisabledToolNames(disabledToolNames?: ReadonlyArray<string>): Set<string>;
+export declare function resolveDisabledPluginPaths(disabledPluginPaths?: ReadonlyArray<string>): Set<string>;
+export declare function isToolDisabledGlobally(toolName: string): boolean;
+export declare function toggleDisabledTool(toolName: string): boolean;
+export declare function setDisabledTools(toolNames: ReadonlyArray<string>, disabledValue: boolean): void;
+export declare function setToolDisabledGlobally(toolName: string, disabled: boolean): boolean;
+export declare function isPluginDisabledGlobally(pluginPath: string): boolean;
+export declare function setDisabledPlugin(pluginPath: string, disabledValue: boolean): void;
+export declare function filterDisabledPluginPaths(pluginPaths: ReadonlyArray<string>, disabledPluginPaths?: ReadonlyArray<string>): string[];
+export declare function filterDisabledTools<T extends Pick<AgentTool, "name">>(tools: ReadonlyArray<T>, disabledToolNames?: ReadonlyArray<string>): T[];
+export declare function filterExtensionToolRegistrations(extensions: AgentConfig["extensions"], disabledToolNames?: ReadonlyArray<string>): AgentConfig["extensions"];

package/dist/services/llms/cline-recommended-models.d.ts

@@ -0,0 +1,19 @@
+import { ProviderSettingsManager } from "../storage/provider-settings-manager";
+export interface ClineRecommendedModel {
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+}
+export interface ClineRecommendedModelsData {
+    recommended: ClineRecommendedModel[];
+    free: ClineRecommendedModel[];
+}
+export interface FetchClineRecommendedModelsOptions {
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+    providerSettingsManager?: Pick<ProviderSettingsManager, "getProviderSettings">;
+    timeoutMs?: number;
+}
+export declare const FALLBACK_CLINE_RECOMMENDED_MODELS: ClineRecommendedModelsData;
+export declare function fetchClineRecommendedModels(options?: FetchClineRecommendedModelsOptions): Promise<ClineRecommendedModelsData>;

package/dist/services/llms/configured-provider-registry.d.ts

@@ -0,0 +1,27 @@
+import type { ProviderConfig } from "./provider-settings";
+import type { BuiltInProviderSummary, CreateHandlerInput, ProviderConfigDefaults, ProviderSelectionConfig, RegisteredProviderSummary } from "./runtime-types";
+interface RegisterConfiguredProviderInput {
+    id: string;
+    models: readonly string[];
+    defaultModel?: string;
+    defaults?: ProviderConfigDefaults;
+}
+export declare function toBuiltInProviderSummary(input: {
+    collection: BuiltInProviderSummary["id"] extends string ? {
+        provider: Pick<import("@cline/llms").ProviderInfo, "id" | "name" | "description" | "protocol" | "baseUrl" | "capabilities" | "env" | "defaultModelId">;
+        models: Record<string, unknown>;
+    } : never;
+}): BuiltInProviderSummary;
+export declare class ConfiguredProviderRegistry {
+    private readonly providers;
+    register(input: RegisterConfiguredProviderInput): void;
+    registerSelectionConfig(provider: ProviderSelectionConfig): void;
+    registerModel(providerId: string, modelId: string): void;
+    createHandlerConfig(input: CreateHandlerInput): ProviderConfig;
+    list(): RegisteredProviderSummary[];
+    getModels(providerId: string): string[];
+    hasProvider(providerId: string): boolean;
+    hasModel(providerId: string, modelId: string): boolean;
+    private require;
+}
+export {};