@cline/core 0.0.38-nightly.1778113663

package/dist/runtime/capabilities/index.d.ts

@@ -0,0 +1,2 @@
+export { normalizeRuntimeCapabilities } from "./normalize-runtime-capabilities";
+export type { RuntimeCapabilities } from "./runtime-capabilities";

package/dist/runtime/capabilities/normalize-runtime-capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeCapabilities } from "./runtime-capabilities";
+export declare function normalizeRuntimeCapabilities(...sources: Array<RuntimeCapabilities | undefined>): RuntimeCapabilities | undefined;

package/dist/runtime/capabilities/runtime-capabilities.d.ts

@@ -0,0 +1,6 @@
+import type { ToolApprovalRequest, ToolApprovalResult } from "@cline/shared";
+import type { ToolExecutors } from "../../extensions/tools";
+export interface RuntimeCapabilities {
+    toolExecutors?: Partial<ToolExecutors>;
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
+}

package/dist/runtime/config/agent-message-codec.d.ts

@@ -0,0 +1,6 @@
+import type { AgentMessage, Message, MessageWithMetadata } from "@cline/shared";
+export declare function messageToAgentMessages(message: MessageWithMetadata): AgentMessage[];
+export declare function messagesToAgentMessages(messages: readonly MessageWithMetadata[]): AgentMessage[];
+export declare function agentMessageToMessageWithMetadata(message: AgentMessage): MessageWithMetadata;
+export declare function agentMessagesToMessagesWithMetadata(messages: readonly AgentMessage[]): MessageWithMetadata[];
+export declare function agentMessagesToMessages(messages: readonly AgentMessage[]): Message[];

package/dist/runtime/config/agent-runtime-config-builder.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Build an `AgentRuntimeConfig` from an `AgentConfig` plus session-owned
+ * supporting objects (model handler, tools, hooks, plugins, telemetry).
+ *
+ * The function is intentionally **pure**: it does not create handlers or tools
+ * itself; it receives them already resolved from the caller (`SessionRuntime`)
+ * and wires them into an `AgentRuntimeConfig`.
+ *
+ * Fields that do **not** round-trip into `AgentRuntimeConfig`
+ * (e.g. `execution.maxConsecutiveMistakes`, `execution.loopDetection`) are
+ * consumed by `SessionRuntime` / `MistakeTracker` /
+ * `LoopDetectionTracker` — not passed through here.
+ */
+import type { AgentConfig, AgentMessage, AgentModel, AgentRuntimeConfig, AgentRuntimeHooks, AgentRuntimePlugin, AgentRuntimePrepareTurnContext, AgentRuntimePrepareTurnResult, AgentTelemetry, AgentTool, BasicLogger } from "@cline/shared";
+/**
+ * Inputs required to assemble an `AgentRuntimeConfig`. Distinct from
+ * `AgentConfig` because some of these (the model adapter, the hook
+ * bridge's runtime-hooks bag, a resolved plugin list) can only be
+ * produced inside `SessionRuntime`.
+ */
+export interface CreateAgentRuntimeConfigInput {
+    readonly agentConfig: AgentConfig;
+    /**
+     * Core/hub runtime session identifier used for host lifecycle operations,
+     * event routing, persistence, and approval delivery.
+     */
+    readonly sessionId?: string;
+    readonly agentId: string;
+    /**
+     * Agent conversation/transcript identifier used by tools, hooks, telemetry,
+     * and model history correlation.
+     */
+    readonly conversationId?: string;
+    readonly parentAgentId?: string;
+    /** The role label for teammates (`AgentConfig.role` in sub-agent configs). */
+    readonly agentRole?: string;
+    /** Pre-built model adapter (produced by `apiHandlerToAgentModel`). */
+    readonly model: AgentModel;
+    readonly logger?: BasicLogger;
+    readonly telemetry?: AgentTelemetry;
+    /** Pre-built tool array (builtins + plugin-contributed + session extras). */
+    readonly tools?: readonly AgentTool<unknown, unknown>[];
+    readonly toolContextMetadata?: Record<string, unknown>;
+    /** Pre-resolved plugin list from the plugin loader. */
+    readonly plugins?: readonly AgentRuntimePlugin[];
+    /** Runtime hooks supplied by the session/runtime builder. */
+    readonly hooks?: Partial<AgentRuntimeHooks>;
+    /** Host-owned context pipeline invoked before runtime model hooks. */
+    readonly prepareTurn?: (context: AgentRuntimePrepareTurnContext) => Promise<AgentRuntimePrepareTurnResult | undefined> | AgentRuntimePrepareTurnResult | undefined;
+    /** Seed messages (usually `session.conversation.getMessages()`). */
+    readonly initialMessages?: readonly AgentMessage[];
+    /**
+     * Override for `AgentRuntimeConfig.systemPrompt` — useful when
+     * the caller has composed additional guidance (e.g. via
+     * `LocalRuntimeHost.composeSystemPrompt`). Defaults to
+     * `agentConfig.systemPrompt`.
+     */
+    readonly systemPrompt?: string;
+}
+/**
+ * Produce an `AgentRuntimeConfig` from session-owned runtime inputs.
+ */
+export declare function createAgentRuntimeConfig(input: CreateAgentRuntimeConfigInput): AgentRuntimeConfig;
+/**
+ * Collect the provider-/reasoning-related fields from `AgentConfig`
+ * into `AgentRuntimeConfig.modelOptions`. Kept undefined when every
+ * field is undefined so the runtime does not receive an empty object.
+ */
+export declare function buildModelOptions(config: AgentConfig): Record<string, unknown> | undefined;
+/**
+ * Compose `messageModelInfo` from the provider-related fields per
+ * §3.2.1: `{ id: modelId, provider: providerId, family:
+ * providerConfig?.family }`.
+ */
+export declare function buildMessageModelInfo(config: AgentConfig): AgentMessage["modelInfo"];
+/**
+ * `"parallel"` when `maxParallelToolCalls ≥ 2`, `"sequential"` when
+ * `1`, `undefined` when the caller did not specify.
+ */
+export declare function resolveToolExecution(maxParallelToolCalls: number | undefined): "sequential" | "parallel" | undefined;
+/**
+ * Adapt the full `ITelemetryService` to the minimal `AgentTelemetry`
+ * shape. The runtime only calls `capture(event, properties)`; the
+ * remaining methods are host concerns and stay on the
+ * `ITelemetryService` instance owned by `SessionRuntime`.
+ */
+export declare function mapTelemetry(telemetry: AgentConfig["telemetry"]): AgentTelemetry | undefined;

package/dist/runtime/host/history.d.ts

@@ -0,0 +1,18 @@
+import type { SessionManifest } from "../../session/models/session-manifest";
+import type { SessionHistoryRecord, SessionRecord } from "../../types/sessions";
+import type { SessionBackend } from "./host";
+import type { RuntimeHost } from "./runtime-host";
+export interface SessionHistoryListOptions {
+    limit?: number;
+    includeManifestFallback?: boolean;
+    hydrate?: boolean;
+}
+export declare function manifestToSessionRecord(manifest: SessionManifest): SessionRecord;
+export declare function hydrateSessionHistory(host: Pick<RuntimeHost, "readSessionMessages">, rows: SessionRecord[]): Promise<SessionHistoryRecord[]>;
+export declare function listSessionHistory(host: Pick<RuntimeHost, "listSessions" | "readSessionMessages">, options?: SessionHistoryListOptions): Promise<SessionHistoryRecord[]>;
+/**
+ * Lists history directly from the persistence backend without constructing a
+ * runtime host. This keeps read-only history commands from initializing runtime
+ * services such as plugins, MCP, or hub transport.
+ */
+export declare function listSessionHistoryFromBackend(backend: Pick<SessionBackend, "listSessions">, options?: SessionHistoryListOptions): Promise<SessionHistoryRecord[]>;

package/dist/runtime/host/host.d.ts

@@ -0,0 +1,7 @@
+import type { ClineCoreOptions } from "../../cline-core/types";
+import { FileSessionService } from "../../session/services/file-session-service";
+import { CoreSessionService } from "../../session/services/session-service";
+import type { RuntimeHost } from "./runtime-host";
+export type SessionBackend = CoreSessionService | FileSessionService;
+export declare function resolveSessionBackend(options: ClineCoreOptions): Promise<SessionBackend>;
+export declare function createRuntimeHost(options: ClineCoreOptions): Promise<RuntimeHost>;

package/dist/runtime/host/local/agent-event-bridge.d.ts

@@ -0,0 +1,29 @@
+import type { AgentEvent, BasicLogger } from "@cline/shared";
+import type { TeamEvent } from "../../../extensions/tools/team";
+import { type AgentEventContext } from "../../../services/agent-events";
+import type { CoreSessionConfig } from "../../../types/config";
+import type { CoreSessionEvent } from "../../../types/events";
+import type { ActiveSession } from "../../../types/session";
+import type { SessionAccumulatedUsage } from "../runtime-host";
+export interface AgentEventBridgeDeps {
+    getSession(sessionId: string): ActiveSession | undefined;
+    usageBySession: Map<string, SessionAccumulatedUsage>;
+    emit(event: CoreSessionEvent): void;
+    persistMessages: AgentEventContext["persistMessages"];
+    enqueuePendingPrompt(sessionId: string, entry: {
+        prompt: string;
+        delivery: "queue" | "steer";
+    }): void;
+    invokeBackendOptional(method: string, ...args: unknown[]): Promise<void>;
+}
+export declare class AgentEventBridge {
+    private readonly deps;
+    constructor(deps: AgentEventBridgeDeps);
+    dispatchAgentEvent(sessionId: string, config: CoreSessionConfig, event: AgentEvent): void;
+    handleTeamEvent(rootSessionId: string, event: TeamEvent): Promise<void>;
+    handlePluginEvent(rootSessionId: string, event: {
+        name: string;
+        payload?: unknown;
+    }, fallbackAutomation?: NonNullable<CoreSessionConfig["extensionContext"]>["automation"]): Promise<void>;
+    handlePluginLog(rootSessionId: string, payload: unknown, fallbackLogger?: BasicLogger): void;
+}

package/dist/runtime/host/local/session-record.d.ts

@@ -0,0 +1,6 @@
+import type { FileSessionService } from "../../../session/services/file-session-service";
+import type { CoreSessionService } from "../../../session/services/session-service";
+import type { ActiveSession } from "../../../types/session";
+import type { SessionRecord } from "../../../types/sessions";
+export type SessionBackend = CoreSessionService | FileSessionService;
+export declare function toActiveSessionRecord(session: ActiveSession): SessionRecord;

package/dist/runtime/host/local/session-service-invoker.d.ts

@@ -0,0 +1,4 @@
+import type { SessionBackend } from "./session-record";
+export declare function invokeBackend<T>(backend: SessionBackend, method: string, ...args: unknown[]): Promise<T>;
+export declare function invokeBackendOptional(backend: SessionBackend, method: string, ...args: unknown[]): Promise<void>;
+export declare function invokeBackendOptionalValue<T = unknown>(backend: SessionBackend, method: string, ...args: unknown[]): Promise<T | undefined>;

package/dist/runtime/host/local/spawn-tool.d.ts

@@ -0,0 +1,15 @@
+import type { AgentEvent, AgentTool } from "@cline/shared";
+import { type ToolExecutors } from "../../../extensions/tools";
+import type { CoreSessionConfig } from "../../../types/config";
+import type { ActiveSession } from "../../../types/session";
+export type SubAgentStartTracker = Map<string, {
+    startedAt: number;
+    rootSessionId: string;
+}>;
+export interface SpawnToolDeps {
+    getSession(sessionId: string): ActiveSession | undefined;
+    subAgentStarts: SubAgentStartTracker;
+    onAgentEvent(rootSessionId: string, config: CoreSessionConfig, event: AgentEvent): void;
+    invokeBackendOptional(method: string, ...args: unknown[]): Promise<void>;
+}
+export declare function createSessionSpawnTool(deps: SpawnToolDeps, config: CoreSessionConfig, rootSessionId: string, toolExecutors?: Partial<ToolExecutors>): AgentTool;

package/dist/runtime/host/local/user-files.d.ts

@@ -0,0 +1 @@
+export declare function loadUserFileContent(path: string): Promise<string>;

package/dist/runtime/host/local-runtime-host.d.ts

@@ -0,0 +1,119 @@
+import type * as LlmsProviders from "@cline/llms";
+import { type AgentConfig, type AgentResult, type ITelemetryService } from "@cline/shared";
+import type { HookEventPayload } from "../../hooks";
+import { ProviderSettingsManager } from "../../services/storage/provider-settings-manager";
+import type { CoreSessionConfig } from "../../types/config";
+import type { CoreSessionEvent } from "../../types/events";
+import type { SessionRecord } from "../../types/sessions";
+import type { RuntimeCapabilities } from "../capabilities";
+import { RuntimeOAuthTokenManager } from "../orchestration/runtime-oauth-token-manager";
+import type { RuntimeBuilder } from "../orchestration/session-runtime";
+import { SessionRuntime } from "../orchestration/session-runtime-orchestrator";
+import { type SessionBackend } from "./local/session-record";
+import type { PendingPromptsServiceApi, RestoreSessionInput, RestoreSessionResult, RuntimeHost, RuntimeHostSubscribeOptions, SendSessionInput, SessionAccumulatedUsage, StartSessionInput, StartSessionResult } from "./runtime-host";
+export interface LocalRuntimeHostOptions {
+    distinctId?: string;
+    sessionService: SessionBackend;
+    runtimeBuilder?: RuntimeBuilder;
+    createAgent?: (config: AgentConfig) => SessionRuntime;
+    capabilities?: RuntimeCapabilities;
+    toolPolicies?: AgentConfig["toolPolicies"];
+    providerSettingsManager?: ProviderSettingsManager;
+    oauthTokenManager?: RuntimeOAuthTokenManager;
+    telemetry?: ITelemetryService;
+    /**
+     * Default custom `fetch` implementation threaded into every
+     * `ProviderConfig.fetch` built during local session bootstrap. Used by
+     * the AI gateway providers when issuing HTTP requests.
+     */
+    fetch?: typeof fetch;
+}
+export declare class LocalRuntimeHost implements RuntimeHost {
+    readonly runtimeAddress: undefined;
+    readonly pendingPrompts: PendingPromptsServiceApi;
+    private readonly sessionService;
+    private readonly runtimeBuilder;
+    private readonly createAgentInstance;
+    private readonly toolExecutors?;
+    private readonly defaultCapabilities?;
+    private readonly defaultToolPolicies?;
+    private readonly providerSettingsManager;
+    private readonly oauthTokenManager;
+    private readonly defaultTelemetry?;
+    private readonly defaultFetch?;
+    private readonly events;
+    private readonly sessions;
+    private readonly usageBySession;
+    private readonly subAgentStarts;
+    private readonly pendingPromptsController;
+    private readonly eventBridge;
+    private readonly sessionVersioning;
+    constructor(options: LocalRuntimeHostOptions);
+    startSession(input: StartSessionInput): Promise<StartSessionResult>;
+    restoreSession(input: RestoreSessionInput): Promise<RestoreSessionResult>;
+    runTurn(input: SendSessionInput): Promise<AgentResult | undefined>;
+    getAccumulatedUsage(sessionId: string): Promise<SessionAccumulatedUsage | undefined>;
+    abort(sessionId: string, reason?: unknown): Promise<void>;
+    stopSession(sessionId: string): Promise<void>;
+    dispose(reason?: string): Promise<void>;
+    getSession(sessionId: string): Promise<SessionRecord | undefined>;
+    listSessions(limit?: number): Promise<SessionRecord[]>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    updateSession(sessionId: string, updates: {
+        prompt?: string | null;
+        metadata?: Record<string, unknown> | null;
+        title?: string | null;
+    }): Promise<{
+        updated: boolean;
+    }>;
+    readSessionMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+    dispatchHookEvent(payload: HookEventPayload): Promise<void>;
+    subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
+    updateSessionModel(sessionId: string, modelId: string): Promise<void>;
+    handlePluginEvent(rootSessionId: string, event: {
+        name: string;
+        payload?: unknown;
+    }, fallbackAutomation?: NonNullable<CoreSessionConfig["extensionContext"]>["automation"]): Promise<void>;
+    private executeTurn;
+    private completeInteractiveTurn;
+    private completeAbortedInteractiveTurn;
+    private executeAgentTurn;
+    /**
+     * Anchor `task.completed` telemetry to the assistant's explicit
+     * completion declaration. We emit at most once per session, the moment
+     * a successful `submit_and_exit` tool call is observed in the run
+     * result. This is the SDK analog of original Cline's
+     * `attempt_completion`-driven emission and works for both interactive
+     * and non-interactive sessions.
+     *
+     * `shutdownSession(...)` retains a fallback emission for completed
+     * sessions that finish without an explicit completion-tool observation
+     * (e.g., non-interactive runs not using the yolo preset). This helper
+     * sets `submitAndExitObserved` so the shutdown fallback can suppress a
+     * duplicate emission for the same logical completion.
+     */
+    private observeTaskCompletionTool;
+    private prepareTurnInput;
+    private ensureSessionPersisted;
+    private markTurnRunning;
+    private persistSessionMetadata;
+    private finalizeSingleRun;
+    private failSession;
+    private shutdownSession;
+    private releaseSessionRuntime;
+    private updateStatus;
+    private runWithAuthRetry;
+    private syncOAuthCredentials;
+    private getSessionOrThrow;
+    private resolveAbsoluteFilePaths;
+    private getSessionAgentTelemetryIdentity;
+    private emitStatus;
+    private emitSessionSnapshot;
+    private emit;
+    private listRows;
+    private getRow;
+    private readManifest;
+    private invoke;
+    private invokeOptional;
+    private invokeOptionalValue;
+}

package/dist/runtime/host/runtime-host-support.d.ts

@@ -0,0 +1,20 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { HookEventPayload } from "../../hooks";
+import type { CoreSessionEvent } from "../../types/events";
+import type { RuntimeHostSubscribeOptions, SessionAccumulatedUsage } from "./runtime-host";
+export declare class RuntimeHostEventBus {
+    private readonly listeners;
+    subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
+    emit(event: CoreSessionEvent): void;
+    get size(): number;
+}
+export declare function readPersistedMessagesFile(messagesPath?: string | null): Promise<LlmsProviders.Message[]>;
+export declare function cloneAccumulatedUsage(usage: SessionAccumulatedUsage | undefined): SessionAccumulatedUsage | undefined;
+type HookAuditBackend = {
+    queueSpawnRequest(payload: HookEventPayload): Promise<void>;
+    upsertSubagentSessionFromHook(payload: HookEventPayload): Promise<string | undefined>;
+    appendSubagentHookAudit(sessionId: string, payload: HookEventPayload): Promise<void>;
+    applySubagentStatus(sessionId: string, payload: HookEventPayload): Promise<void>;
+};
+export declare function replaySubagentHookEvent(payload: HookEventPayload, backend: HookAuditBackend): Promise<void>;
+export {};

package/dist/runtime/host/runtime-host.d.ts

@@ -0,0 +1,163 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { AgentResult, RuntimeConfigExtensionKind } from "@cline/shared";
+import type { HookEventPayload } from "../../hooks";
+import type { CheckpointEntry } from "../../hooks/checkpoint-hooks";
+import type { ProviderSettings } from "../../services/llms/provider-settings";
+import type { SessionManifest } from "../../session/models/session-manifest";
+import type { SessionSource } from "../../types/common";
+import type { CoreSessionConfig } from "../../types/config";
+import type { CoreSessionEvent, SessionPendingPrompt } from "../../types/events";
+import type { SessionRecord } from "../../types/sessions";
+import type { RuntimeCapabilities } from "../capabilities";
+type LocalOnlyCoreSessionConfigKeys = "hooks" | "logger" | "telemetry" | "extensionContext" | "extraTools" | "extensions" | "onTeamEvent" | "onConsecutiveMistakeLimitReached";
+export type RuntimeSessionConfig = Omit<CoreSessionConfig, LocalOnlyCoreSessionConfigKeys | "checkpoint" | "compaction"> & {
+    checkpoint?: Omit<NonNullable<CoreSessionConfig["checkpoint"]>, "createCheckpoint">;
+    compaction?: Omit<NonNullable<CoreSessionConfig["compaction"]>, "compact">;
+};
+export type LocalRuntimeBootstrapConfig = Pick<CoreSessionConfig, LocalOnlyCoreSessionConfigKeys> & {
+    checkpoint?: Pick<NonNullable<CoreSessionConfig["checkpoint"]>, "createCheckpoint"> & Partial<NonNullable<CoreSessionConfig["checkpoint"]>>;
+    compaction?: Pick<NonNullable<CoreSessionConfig["compaction"]>, "compact"> & Partial<NonNullable<CoreSessionConfig["compaction"]>>;
+};
+export interface LocalRuntimeStartOptions {
+    hooks?: LocalRuntimeBootstrapConfig["hooks"];
+    logger?: LocalRuntimeBootstrapConfig["logger"];
+    telemetry?: LocalRuntimeBootstrapConfig["telemetry"];
+    extensionContext?: LocalRuntimeBootstrapConfig["extensionContext"];
+    extraTools?: LocalRuntimeBootstrapConfig["extraTools"];
+    extensions?: LocalRuntimeBootstrapConfig["extensions"];
+    onTeamEvent?: LocalRuntimeBootstrapConfig["onTeamEvent"];
+    onConsecutiveMistakeLimitReached?: LocalRuntimeBootstrapConfig["onConsecutiveMistakeLimitReached"];
+    checkpoint?: LocalRuntimeBootstrapConfig["checkpoint"];
+    compaction?: LocalRuntimeBootstrapConfig["compaction"];
+    modelCatalogDefaults?: Partial<NonNullable<ProviderSettings["modelCatalog"]>>;
+    userInstructionService?: import("../../extensions/config").UserInstructionConfigService;
+    configExtensions?: RuntimeConfigExtensionKind[];
+    onTeamRestored?: () => void;
+}
+export interface StartSessionInput {
+    config: RuntimeSessionConfig;
+    source?: SessionSource;
+    prompt?: string;
+    interactive?: boolean;
+    sessionMetadata?: Record<string, unknown>;
+    initialMessages?: LlmsProviders.Message[];
+    userImages?: string[];
+    userFiles?: string[];
+    /**
+     * Host-local bootstrap options. These are intentionally isolated from the
+     * transport-neutral runtime session config so all runtime hosts share the
+     * same execution contract while still allowing host-specific preparation.
+     */
+    localRuntime?: LocalRuntimeStartOptions;
+    capabilities?: RuntimeCapabilities;
+    toolPolicies?: import("@cline/shared").AgentConfig["toolPolicies"];
+}
+export declare function splitCoreSessionConfig(config: CoreSessionConfig): {
+    config: RuntimeSessionConfig;
+    localRuntime?: LocalRuntimeStartOptions;
+};
+export interface StartSessionResult {
+    sessionId: string;
+    manifest: SessionManifest;
+    manifestPath: string;
+    messagesPath: string;
+    result?: AgentResult;
+}
+export interface SendSessionInput {
+    sessionId: string;
+    prompt: string;
+    userImages?: string[];
+    userFiles?: string[];
+    delivery?: "queue" | "steer";
+    timeoutMs?: number;
+}
+export interface SessionAccumulatedUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    totalCost: number;
+}
+export interface PendingPromptMutationResult {
+    sessionId: string;
+    prompts: SessionPendingPrompt[];
+    prompt?: SessionPendingPrompt;
+    updated?: boolean;
+    removed?: boolean;
+}
+export interface PendingPromptsListInput {
+    sessionId: string;
+}
+export interface PendingPromptsUpdateInput {
+    sessionId: string;
+    promptId: string;
+    prompt?: string;
+    delivery?: "queue" | "steer";
+}
+export interface PendingPromptsDeleteInput {
+    sessionId: string;
+    promptId: string;
+}
+export interface PendingPromptsServiceApi {
+    list(input: PendingPromptsListInput): Promise<SessionPendingPrompt[]>;
+    update(input: PendingPromptsUpdateInput): Promise<PendingPromptMutationResult>;
+    delete(input: PendingPromptsDeleteInput): Promise<PendingPromptMutationResult>;
+}
+export interface PendingPromptsRuntimeService {
+    readonly pendingPrompts: PendingPromptsServiceApi;
+}
+export interface SessionUsageRuntimeService {
+    getAccumulatedUsage(sessionId: string): Promise<SessionAccumulatedUsage | undefined>;
+}
+export interface SessionModelRuntimeService {
+    updateSessionModel(sessionId: string, modelId: string): Promise<void>;
+}
+export interface RuntimeHostSubscribeOptions {
+    sessionId?: string;
+}
+export interface RestoreSessionInput {
+    sessionId: string;
+    checkpointRunCount: number;
+    cwd?: string;
+    restore?: {
+        messages?: boolean;
+        workspace?: boolean;
+        omitCheckpointMessageFromSession?: boolean;
+    };
+    start?: StartSessionInput;
+}
+export interface RestoreSessionResult {
+    sessionId?: string;
+    startResult?: StartSessionResult;
+    messages?: LlmsProviders.Message[];
+    checkpoint: CheckpointEntry;
+}
+/**
+ * RuntimeHost is the transport/runtime boundary for core session execution.
+ * Callers must normalize broad local config into `RuntimeSessionConfig`
+ * plus optional named `localRuntime` bootstrap fields before invoking a host.
+ */
+export interface RuntimeHost {
+    readonly runtimeAddress?: string;
+    startSession(input: StartSessionInput): Promise<StartSessionResult>;
+    runTurn(input: SendSessionInput): Promise<AgentResult | undefined>;
+    restoreSession(input: RestoreSessionInput): Promise<RestoreSessionResult>;
+    abort(sessionId: string, reason?: unknown): Promise<void>;
+    stopSession(sessionId: string): Promise<void>;
+    dispose(reason?: string): Promise<void>;
+    getSession(sessionId: string): Promise<SessionRecord | undefined>;
+    listSessions(limit?: number): Promise<SessionRecord[]>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    updateSession(sessionId: string, updates: {
+        prompt?: string | null;
+        metadata?: Record<string, unknown> | null;
+        title?: string | null;
+    }): Promise<{
+        updated: boolean;
+    }>;
+    readSessionMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+    dispatchHookEvent(payload: HookEventPayload): Promise<void>;
+    subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
+}
+export type RuntimeHostMode = "auto" | "local" | "hub" | "remote";
+export {};

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

@@ -0,0 +1,6 @@
+import type { RuntimeBuilder, RuntimeBuilderInput, BuiltRuntime as RuntimeEnvironment } from "./session-runtime";
+export declare function createTeamName(): string;
+export declare class DefaultRuntimeBuilder implements RuntimeBuilder {
+    private readonly teamRuntimeEntries;
+    build(input: RuntimeBuilderInput): Promise<RuntimeEnvironment>;
+}

package/dist/runtime/orchestration/runtime-event-adapter.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Adapter from the new `AgentRuntimeEvent` union (13 variants, defined
+ * in `@cline/shared/src/agent.ts`) to the legacy `AgentEvent` union
+ * (9 top-level types, defined in
+ * `@cline/shared/src/agents/types.ts`) consumed by today's
+ * `Agent.subscribeEvents` callback.
+ *
+ * @see PLAN.md §3.1  — new file introduced alongside the core runtime port.
+ * @see PLAN.md §3.3.2 — variant-by-variant OLD → NEW mapping.
+ * @see PLAN.md §3.2.4 — called from `Agent.subscribeEvents` inside the
+ *                       legacy-agent facade.
+ *
+ * --- IMPLEMENTATION NOTE — PLAN §3.3.2 text/reasoning-delta rows ----------
+ *
+ * PLAN.md §3.3.2 describes `assistant-text-delta` as "first delta →
+ * content_start, subsequent → content_update". The **actual** legacy
+ * shape forbids this: `AgentContentUpdateEvent.contentType` is
+ * hard-typed as `"tool"` in
+ * `packages/shared/src/agents/types.ts:87`, and the legacy
+ * turn-processor
+ * (`packages/agents/src/runtime/turn-processor.ts:82-87,113-118`)
+ * emits a `content_start` event for **every** text delta and for
+ * **every** reasoning delta — not just the first. This adapter
+ * preserves that observable behavior (what every legacy consumer
+ * relies on today) over the description in §3.3.2.
+ *
+ *   text deltas      → content_start { contentType:"text", text,
+ *                        accumulated } (per delta)
+ *   reasoning deltas → content_start { contentType:"reasoning",
+ *                        reasoning, redacted } (per delta)
+ *   assistant-message → one content_end { contentType:"text", text }
+ *                        if any text parts; one
+ *                        content_end { contentType:"reasoning", reasoning }
+ *                        if any reasoning parts
+ *                        (turn-processor.ts:157-170).
+ *
+ * --- STATEFUL BOOK-KEEPING ------------------------------------------------
+ *
+ *  1. Rolling usage totals. `usage-updated` carries the already-
+ *     accumulated snapshot (agent-runtime.ts:668-683). Legacy
+ *     `AgentUsageEvent` wants both per-turn delta and accumulated
+ *     totals; the adapter subtracts the previous accumulated value
+ *     from the incoming one to produce the delta.
+ *  2. Tool timing. `tool-finished` does not carry `durationMs`. The
+ *     adapter records `Date.now()` on `tool-started` (keyed by
+ *     `toolCallId`) and computes `durationMs` at `tool-finished`.
+ *     Matches `tool-orchestrator.ts:112-131`.
+ *
+ * Both are scoped to a single adapter instance and cleared by
+ * `reset()`.
+ */
+import type { AgentEvent, AgentMessage, AgentRuntimeEvent } from "@cline/shared";
+declare function textFromMessage(message: AgentMessage | undefined): string;
+/**
+ * Per-subscriber adapter instance. Constructed once per
+ * `Agent.subscribeEvents` registration (or per `SessionRuntime`),
+ * used for the lifetime of that subscription, and `reset()` at the
+ * start of every new run.
+ *
+ * `translate(event)` returns zero, one, or two `AgentEvent`s. An
+ * array is needed because a single `assistant-message` may yield both
+ * a text `content_end` and a reasoning `content_end`. Empty array
+ * means the event is intentionally suppressed (§3.3.2 rows
+ * `run-started`, `message-added`).
+ */
+export declare class RuntimeEventAdapter {
+    private lastUsage;
+    private toolStartedAt;
+    translate(event: AgentRuntimeEvent): AgentEvent[];
+    reset(): void;
+    private translateAssistantMessage;
+    private translateToolStarted;
+    private translateToolFinished;
+    private translateUsage;
+    private translateRunFinished;
+}
+/**
+ * Stateless translator. Works correctly for every variant except
+ * those that require bookkeeping:
+ *
+ *  - `usage-updated` — deltas cannot be computed without a prior
+ *    snapshot; this function treats the prior snapshot as zero (so
+ *    delta == accumulated). Adequate for a single event, incorrect
+ *    across multiple.
+ *  - `tool-finished` — `durationMs` is reported as `undefined`
+ *    because the corresponding `tool-started` was never observed by
+ *    this one-shot adapter.
+ *
+ * Production code must use `RuntimeEventAdapter` for multi-event
+ * runs; this function exists for ad-hoc unit tests and one-shot
+ * translations where bookkeeping does not matter.
+ *
+ * Returns `undefined` when the event maps to zero legacy events
+ * (`run-started`, `message-added`, or an `assistant-message` that
+ * carries no text/reasoning parts). When an event produces multiple
+ * legacy events (e.g. `assistant-message` with both text and
+ * reasoning parts), only the first is returned; callers needing the
+ * full array must use `RuntimeEventAdapter.translate()`.
+ */
+export declare function toLegacyAgentEvent(event: AgentRuntimeEvent): AgentEvent | undefined;
+export { textFromMessage };

package/dist/runtime/orchestration/runtime-oauth-token-manager.d.ts

@@ -0,0 +1,30 @@
+import { type ITelemetryService, type OAuthProviderId } from "@cline/shared";
+import { ProviderSettingsManager } from "../../services/storage/provider-settings-manager";
+type ManagedOAuthProviderId = OAuthProviderId;
+export declare class OAuthReauthRequiredError extends Error {
+    readonly providerId: ManagedOAuthProviderId;
+    constructor(providerId: ManagedOAuthProviderId);
+}
+export type RuntimeOAuthResolution = {
+    providerId: ManagedOAuthProviderId;
+    apiKey: string;
+    accountId?: string;
+    refreshed: boolean;
+};
+export declare class RuntimeOAuthTokenManager {
+    private readonly providerSettingsManager;
+    private readonly telemetry?;
+    private readonly refreshInFlight;
+    constructor(options?: {
+        providerSettingsManager?: ProviderSettingsManager;
+        telemetry?: ITelemetryService;
+    });
+    resolveProviderApiKey(input: {
+        providerId: string;
+        forceRefresh?: boolean;
+    }): Promise<RuntimeOAuthResolution | null>;
+    private resolveWithSingleFlight;
+    private resolveProviderApiKeyInternal;
+    private resolveCredentials;
+}
+export {};