@clinebot/core 0.0.35 → 0.0.37-nightly.1777939956

package/README.md

@@ -57,7 +57,8 @@ await cline.dispose();
 
 Use it when a host needs to prepare workspace-scoped runtime state before each
 session starts, then apply watcher/extensions/telemetry inputs through
-`localRuntime.configOverrides` without widening the shared host contract.
+explicit `localRuntime` bootstrap fields without widening the shared host
+contract.
 
 ## Main APIs
 
@@ -68,8 +69,17 @@ Use `@clinebot/core` for host-facing runtime assembly:
 - `ClineCore.create(...)`
 - `createRuntimeHost(...)`
 - `LocalRuntimeHost`
+- `HubRuntimeHost` and `RemoteRuntimeHost`
 - `DefaultRuntimeBuilder`
 
+`ClineCore` is the app-facing session API. The lower-level `RuntimeHost`
+boundary uses runtime-primitive names such as `startSession` and `runTurn` so
+transport adapters stay distinct from product methods like `start` and `send`.
+Service-style operations such as pending prompt edits, accumulated usage lookup,
+and active-session model switching are exposed through `ClineCore` when the
+selected transport supports them rather than being part of the minimal host
+primitive vocabulary.
+
 ### Default Tools
 
 `@clinebot/core` owns the built-in host tools and executors:
@@ -84,13 +94,12 @@ The package also exports storage and settings helpers such as:
 
 - `ProviderSettingsManager`
 - `SqliteTeamStore`
-- SQLite RPC session backend helpers from `@clinebot/core`
+- SQLite-backed local session stores and artifacts through `@clinebot/core`
 
 ## Related Packages
 
 - `@clinebot/agents`: stateless agent loop and tool primitives
 - `@clinebot/llms`: provider/model configuration and handlers
-- `@clinebot/rpc`: remote session and runtime transport
 
 ## More Examples
 

package/dist/ClineCore.d.ts

@@ -1,155 +1,282 @@
-import type { AgentConfig, BasicLogger, ITelemetryService, ToolApprovalRequest, ToolApprovalResult } from "@clinebot/shared";
-import type { ToolExecutors } from "./extensions/tools";
-import type { SessionBackend } from "./runtime/host";
-import type { LocalRuntimeStartOptions, RuntimeHost, RuntimeHostMode, StartSessionInput, StartSessionResult } from "./runtime/runtime-host";
-import type { TeamToolsFactory } from "./runtime/session-runtime";
-import type { CoreSessionConfig } from "./types/config";
-import type { SessionMessagesArtifactUploader } from "./types/session";
-/** Advanced options for connecting to or spawning the Cline RPC server. */
-export interface RpcOptions {
+import type { ClineCoreAutomationApi, ClineCoreListHistoryOptions, ClineCoreOptions, ClineCoreSettingsApi, ClineCoreStartInput, RestoreInput, RestoreResult } from "./cline-core/types";
+import type { PendingPromptsServiceApi, RuntimeHost, RuntimeHostSubscribeOptions, SessionModelRuntimeService, SessionUsageRuntimeService, StartSessionInput, StartSessionResult } from "./runtime/host/runtime-host";
+import type { CoreSessionEvent } from "./types/events";
+import type { SessionHistoryRecord } from "./types/sessions";
+export type { ClineAutomationEventIngressResult, ClineAutomationEventLog, ClineAutomationEventSuppression, ClineAutomationListEventsOptions, ClineAutomationListRunsOptions, ClineAutomationListSpecsOptions, ClineAutomationRun, ClineAutomationRunStatus, ClineAutomationSpec, ClineCoreAutomationApi, ClineCoreAutomationOptions, ClineCoreListHistoryOptions, ClineCoreOptions, ClineCoreSettingsApi, ClineCoreStartInput, HubOptions, RemoteOptions, RestoreInput, RestoreOptions, RestoreResult, RuntimeHostMode, StartSessionBootstrap, } from "./cline-core/types";
+/**
+ * The primary entry point for the Cline Core SDK.
+ *
+ * @example
+ * ```ts
+ * import { ClineCore } from "@clinebot/core";
+ *
+ * const cline = await ClineCore.create({ clientName: "my-app" });
+ * const session = await cline.start({ ... });
+ * ```
+ */
+export declare class ClineCore {
+    readonly clientName: string | undefined;
+    readonly runtimeAddress: string | undefined;
+    readonly automation: ClineCoreAutomationApi;
+    readonly settings: ClineCoreSettingsApi;
+    readonly pendingPrompts: PendingPromptsServiceApi;
+    private readonly host;
+    private readonly prepare;
+    private readonly capabilities;
+    private readonly logger;
+    private readonly telemetry;
+    private readonly distinctId;
+    private readonly automationService;
+    private readonly activeSessionBootstraps;
+    private readonly unsubscribeBootstrapCleanup;
+    private constructor();
     /**
-     * The address of the Cline RPC server to connect to.
-     * Defaults to the `CLINE_RPC_ADDRESS` env var, or the SDK default address if unset.
+     * Creates a new ClineCore instance.
+     *
+     * This is the primary factory method for initializing the SDK. It sets up the runtime
+     * host (local, hub, or remote) based on the provided options and prepares the SDK for
+     * starting sessions.
+     *
+     * @param options Configuration options for the SDK instance
+     * @returns A promise that resolves to a new ClineCore instance
+     *
+     * @example
+     * ```ts
+     * const cline = await ClineCore.create({
+     *   clientName: "my-app",
+     *   backendMode: "local",
+     * });
+     * ```
      */
-    address?: string;
+    static create(options?: ClineCoreOptions): Promise<ClineCore>;
+    private disposeSessionBootstrap;
     /**
-     * When `true` (default), automatically spawns a background RPC server process if one is
-     * not already running.
+     * Starts a new Cline session with the provided configuration.
+     *
+     * This method initializes and begins a new agent session. It handles session setup,
+     * runs any preparation hooks, and returns session metadata along with event streams.
+     * The session continues to run until explicitly stopped or aborted.
+     *
+     * @param input The session configuration and startup parameters
+     * @returns A promise that resolves to session metadata and event stream
+     *
+     * @example
+     * ```ts
+     * const result = await cline.start({
+     *   config: {
+     *     providerId: "anthropic",
+     *     modelId: "claude-opus-4-1",
+     *   },
+     * });
+     *
+     * // Subscribe to session events
+     * result.subscribe((event) => {
+     *   console.log("Session event:", event);
+     * });
+     * ```
      */
-    autoStart?: boolean;
+    start(input: StartSessionInput): Promise<StartSessionResult>;
     /**
-     * Number of connection attempts made to the RPC server after it is spawned.
-     * Defaults to `5`.
+     * Starts a new Cline session with extended core-specific configuration.
+     * This overload allows specifying local runtime options and config overrides.
      */
-    connectAttempts?: number;
+    start(input: ClineCoreStartInput): Promise<StartSessionResult>;
     /**
-     * Milliseconds to wait between RPC connection attempts. Defaults to `100`.
+     * Sends a message or command to an active session.
+     *
+     * This method communicates with a running session, allowing you to send user messages,
+     * tool responses, or other session input while the session is in progress.
+     *
+     * @example
+     * ```ts
+     * await cline.send(sessionId, {
+     *   type: "user_message",
+     *   text: "Please implement the login feature",
+     * });
+     * ```
      */
-    connectDelayMs?: number;
-}
-export type { RuntimeHostMode };
-export interface ClineCoreStartInput extends Omit<StartSessionInput, "config" | "localRuntime"> {
-    config: CoreSessionConfig;
-    localRuntime?: LocalRuntimeStartOptions;
-}
-export interface ClineCoreOptions {
+    send: RuntimeHost["runTurn"];
     /**
-     * A human-readable name for this SDK client (e.g. `"my-app"`, `"acme-bot"`).
-     * Used to identify the consumer in telemetry and logs.
+     * Retrieves accumulated token and cost usage for a session.
+     *
+     * Returns metrics about the session's resource consumption, including tokens used
+     * across different API providers and associated costs. Useful for monitoring and billing.
+     *
+     * @example
+     * ```ts
+     * const usage = await cline.getAccumulatedUsage(sessionId);
+     * console.log(`Total cost: $${usage.totalCost}`);
+     * ```
      */
-    clientName?: string;
+    getAccumulatedUsage: SessionUsageRuntimeService["getAccumulatedUsage"];
     /**
-     * A stable identifier for this machine or user, used for telemetry attribution.
-     * Defaults to the system machine ID, falling back to a generated `cl-<nanoid>` persisted
-     * at `~/.cline/data/machine-id`.
+     * Aborts an in-flight tool execution without stopping the session.
+     *
+     * Interrupts the current tool operation (e.g., file read, shell command) while keeping
+     * the session alive. The session can continue processing after the abort. Use this for
+     * cancelling long-running operations.
+     *
+     * @example
+     * ```ts
+     * // Stop the current operation but keep the session running
+     * await cline.abort(sessionId);
+     * ```
      */
-    distinctId?: string;
+    abort: RuntimeHost["abort"];
     /**
-     * Controls how the runtime host is selected:
-     * - `"auto"` (default) — connects to a running RPC server if available, starts one in the
-     *   background if `rpc.autoStart` is true, and falls back to local in-process execution.
-     * - `"rpc"` — requires an RPC runtime server; throws if one is not reachable.
-     * - `"local"` — always uses local in-process execution and local SQLite/file storage.
+     * Stops an active session gracefully.
+     *
+     * Terminates the session and cleans up associated resources. Unlike abort, this
+     * completely ends the session. The session cannot be resumed after stopping.
+     *
+     * @example
+     * ```ts
+     * // Cleanly shutdown the session
+     * await cline.stop(sessionId);
+     * ```
      */
-    backendMode?: RuntimeHostMode;
+    stop: RuntimeHost["stopSession"];
     /**
-     * RPC server connection options. Only relevant when `backendMode` is `"auto"` or `"rpc"`.
+     * Disposes the ClineCore instance and all associated resources.
+     *
+     * Shuts down the runtime host, closes connections, and cleans up all active sessions
+     * and bootstraps. Call this when you're done using the SDK instance, typically at
+     * application shutdown. After calling dispose, the instance cannot be reused.
+     *
+     * @example
+     * ```ts
+     * // Clean up when done
+     * await cline.dispose();
+     * ```
      */
-    rpc?: RpcOptions;
+    dispose: RuntimeHost["dispose"];
     /**
-     * Override one or more default tool executors (e.g. file I/O, shell, browser).
-     * Partial — only the keys you supply are replaced; the rest use built-in implementations.
+     * Retrieves information about a specific session by ID.
+     *
+     * Fetches the current metadata and state of a session, including configuration,
+     * status, and other session details.
+     *
+     * @example
+     * ```ts
+     * const session = await cline.get(sessionId);
+     * console.log("Session status:", session?.status);
+     * ```
      */
-    defaultToolExecutors?: Partial<ToolExecutors>;
+    get: RuntimeHost["getSession"];
     /**
-     * Telemetry service instance to use for capturing events and usage.
-     * If omitted, telemetry is a no-op.
+     * Lists recent sessions through the shared history-listing path.
      */
-    telemetry?: ITelemetryService;
+    listHistory: (options?: ClineCoreListHistoryOptions) => Promise<SessionHistoryRecord[]>;
     /**
-     * Optional structured logger for core-side operational diagnostics such as
-     * RPC backend startup, reuse, and fallback decisions.
+     * Lists recent sessions with inferred history display metadata.
+     *
+     * Retrieves a paginated list of recent sessions, optionally limited by the
+     * provided count.
+     *
+     * @param limit Maximum number of sessions to return (defaults to 200)
+     * @returns A promise resolving to an array of session history records
+     *
+     * @example
+     * ```ts
+     * const sessions = await cline.list(50);
+     * sessions.forEach((session) => {
+     *   console.log(`Session ${session.sessionId}: ${session.metadata?.title}`);
+     * });
+     * ```
      */
-    logger?: BasicLogger;
+    list: (limit?: number, options?: Omit<ClineCoreListHistoryOptions, "limit">) => Promise<SessionHistoryRecord[]>;
     /**
-     * Per-tool approval policies that control whether a tool runs automatically,
-     * requires user confirmation, or is blocked entirely.
+     * Permanently deletes a session and all its associated data.
+     *
+     * Removes the session from storage and cleans up any related resources. This is
+     * a destructive operation that cannot be undone.
+     *
+     * @param sessionId The ID of the session to delete
+     * @returns A promise that resolves to true if the session was deleted, false if not found
+     *
+     * @example
+     * ```ts
+     * const deleted = await cline.delete(sessionId);
+     * if (deleted) {
+     *   console.log("Session deleted successfully");
+     * }
+     * ```
      */
-    toolPolicies?: AgentConfig["toolPolicies"];
+    delete: RuntimeHost["deleteSession"];
     /**
-     * Called before any tool is executed that requires explicit user approval.
-     * Return `{ approved: true }` to allow or `{ approved: false }` to deny.
-     * If omitted, all approval-required tools are auto-denied.
+     * Updates an existing session's metadata.
+     *
+     * Modifies session properties like title or other mutable metadata while preserving
+     * message history and other session data.
+     *
+     * @example
+     * ```ts
+     * await cline.update(sessionId, {
+     *   title: "Updated session title",
+     * });
+     * ```
      */
-    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult>;
+    update: RuntimeHost["updateSession"];
     /**
-     * Optional hook invoked after `messages.json` is persisted to disk.
-     * Consumers can use this to mirror session transcripts into remote storage.
+     * Reads message history for a session.
+     *
+     * Retrieves the full message transcript for a specific session, including all
+     * user messages, agent responses, and tool interactions.
+     *
+     * @example
+     * ```ts
+     * const messages = await cline.readMessages(sessionId);
+     * messages.forEach((msg) => {
+     *   console.log(`${msg.role}: ${msg.content}`);
+     * });
+     * ```
      */
-    messagesArtifactUploader?: SessionMessagesArtifactUploader;
+    readMessages: RuntimeHost["readSessionMessages"];
+    restore(input: RestoreInput): Promise<RestoreResult>;
     /**
-     * An already-constructed session backend to use instead of resolving one automatically.
-     * Intended for testing or embedding a custom persistence layer.
+     * Handles hook events from the runtime environment.
+     *
+     * Processes system or environment events (e.g., workspace changes, external signals)
+     * that may affect the current session. This is typically called by the host environment
+     * rather than directly by consumer code.
+     *
      * @internal
      */
-    sessionService?: SessionBackend;
+    ingestHookEvent: RuntimeHost["dispatchHookEvent"];
     /**
-     * Factory that creates team management tools for the multi-agent team system.
-     * When provided, team tools are registered whenever `enableAgentTeams` is `true`
-     * on a session config.
+     * Subscribes to session events.
+     *
+     * Registers a listener for all session events (messages, state changes, errors, etc.).
+     * Returns an unsubscribe function to stop listening.
      *
-     * Consumers that depend on `@clinebot/enterprise` can pass
-     * `bootstrapAgentTeams` here directly.
+     * @param listener Callback function invoked for each event
+     * @param options Optional configuration for the subscription
+     * @returns An unsubscribe function
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = cline.subscribe((event) => {
+     *   if (event.type === "message") {
+     *     console.log("New message:", event.payload.message);
+     *   }
+     * });
+     *
+     * // Later, stop listening
+     * unsubscribe();
+     * ```
      */
-    teamToolsFactory?: TeamToolsFactory;
+    subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
     /**
-     * Optional hook invoked before each session starts.
-     * Use this to prepare workspace-scoped runtime state and then return an
-     * adapter that mutates the shared session input before core starts the run.
+     * Updates the AI model used by an active session.
+     *
+     * Switches the session to use a different AI model while maintaining the session state
+     * and message history. This allows you to continue a conversation with a different model.
+     *
+     * @example
+     * ```ts
+     * // Switch to a different model mid-session
+     * await cline.updateSessionModel(sessionId, "claude-opus-4-1");
+     * ```
      */
-    prepare?: (input: ClineCoreStartInput) => Promise<StartSessionBootstrap | undefined> | StartSessionBootstrap | undefined;
-}
-export interface StartSessionBootstrap {
-    applyToStartSessionInput(input: ClineCoreStartInput): Promise<ClineCoreStartInput> | ClineCoreStartInput;
-    dispose?(): Promise<void> | void;
-}
-/**
- * The primary entry point for the Cline Core SDK.
- *
- * @example
- * ```ts
- * import { ClineCore } from "@clinebot/core";
- *
- * const cline = await ClineCore.create({ clientName: "my-app" });
- * const session = await cline.start({ ... });
- * ```
- */
-export declare class ClineCore implements RuntimeHost {
-    readonly clientName: string | undefined;
-    readonly runtimeAddress: string | undefined;
-    private readonly host;
-    private readonly prepare;
-    private readonly activeSessionBootstraps;
-    private readonly unsubscribeBootstrapCleanup;
-    private constructor();
-    static create(options?: ClineCoreOptions): Promise<ClineCore>;
-    private disposeSessionBootstrap;
-    private toClineCoreStartInput;
-    private normalizeStartInput;
-    start(input: StartSessionInput): Promise<StartSessionResult>;
-    start(input: ClineCoreStartInput): Promise<StartSessionResult>;
-    send: RuntimeHost["send"];
-    getAccumulatedUsage: RuntimeHost["getAccumulatedUsage"];
-    abort: RuntimeHost["abort"];
-    stop: RuntimeHost["stop"];
-    dispose: RuntimeHost["dispose"];
-    get: RuntimeHost["get"];
-    list: RuntimeHost["list"];
-    delete: RuntimeHost["delete"];
-    update: RuntimeHost["update"];
-    readMessages: RuntimeHost["readMessages"];
-    handleHookEvent: RuntimeHost["handleHookEvent"];
-    subscribe: RuntimeHost["subscribe"];
-    updateSessionModel: RuntimeHost["updateSessionModel"];
+    updateSessionModel: SessionModelRuntimeService["updateSessionModel"];
 }
-//# sourceMappingURL=ClineCore.d.ts.map

package/dist/account/cline-account-service.d.ts

@@ -35,4 +35,3 @@ export declare class ClineAccountService {
     private resolveOrganizationMemberId;
     private request;
 }
-//# sourceMappingURL=cline-account-service.d.ts.map

package/dist/account/index.d.ts

@@ -1,4 +1,3 @@
 export { ClineAccountService, type ClineAccountServiceOptions, } from "./cline-account-service";
-export { type ClineAccountOperations, executeRpcClineAccountAction, isRpcClineAccountActionRequest, RpcClineAccountService, type RpcProviderActionExecutor, } from "./rpc";
+export { type ClineAccountOperations, executeClineAccountAction, isClineAccountActionRequest, type ProviderActionExecutor, RpcClineAccountService, } from "./rpc";
 export type { ClineAccountBalance, ClineAccountOrganization, ClineAccountOrganizationBalance, ClineAccountOrganizationUsageTransaction, ClineAccountPaymentTransaction, ClineAccountUsageTransaction, ClineAccountUser, ClineOrganization, FeaturebaseTokenResponse, UserRemoteConfigOrganization, UserRemoteConfigResponse, } from "./types";
-//# sourceMappingURL=index.d.ts.map

package/dist/account/rpc.d.ts

@@ -1,4 +1,4 @@
-import type { RpcClineAccountActionRequest, RpcProviderActionRequest } from "@clinebot/shared";
+import type { ClineAccountActionRequest, ProviderActionRequest } from "@clinebot/shared";
 import type { ClineAccountBalance, ClineAccountOrganization, ClineAccountOrganizationBalance, ClineAccountOrganizationUsageTransaction, ClineAccountPaymentTransaction, ClineAccountUsageTransaction, ClineAccountUser, FeaturebaseTokenResponse } from "./types";
 export interface ClineAccountOperations {
     fetchMe(): Promise<ClineAccountUser>;
@@ -14,16 +14,16 @@ export interface ClineAccountOperations {
     switchAccount(organizationId?: string | null): Promise<void>;
     fetchFeaturebaseToken?(): Promise<FeaturebaseTokenResponse | undefined>;
 }
-export declare function isRpcClineAccountActionRequest(request: RpcProviderActionRequest): request is RpcClineAccountActionRequest;
-export declare function executeRpcClineAccountAction(request: RpcClineAccountActionRequest, service: ClineAccountOperations): Promise<unknown>;
-export interface RpcProviderActionExecutor {
-    runProviderAction(request: RpcProviderActionRequest): Promise<{
+export declare function isClineAccountActionRequest(request: ProviderActionRequest): request is ClineAccountActionRequest;
+export declare function executeClineAccountAction(request: ClineAccountActionRequest, service: ClineAccountOperations): Promise<unknown>;
+export interface ProviderActionExecutor {
+    runProviderAction(request: ProviderActionRequest): Promise<{
         result: unknown;
     }>;
 }
 export declare class RpcClineAccountService implements ClineAccountOperations {
     private readonly executor;
-    constructor(executor: RpcProviderActionExecutor);
+    constructor(executor: ProviderActionExecutor);
     fetchMe(): Promise<ClineAccountUser>;
     fetchBalance(userId?: string): Promise<ClineAccountBalance>;
     fetchUsageTransactions(userId?: string): Promise<ClineAccountUsageTransaction[]>;
@@ -38,4 +38,3 @@ export declare class RpcClineAccountService implements ClineAccountOperations {
     fetchFeaturebaseToken(): Promise<FeaturebaseTokenResponse | undefined>;
     private request;
 }
-//# sourceMappingURL=rpc.d.ts.map

package/dist/account/types.d.ts

@@ -96,4 +96,3 @@ export interface ClineAccountOrganizationUsageTransaction {
     totalTokens: number;
     userId: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/auth/bounded-ttl-cache.d.ts

@@ -11,4 +11,3 @@ export declare class BoundedTtlCache {
     set(key: string, value: string, now?: number, ttlMsOverride?: number): void;
     private pruneExpired;
 }
-//# sourceMappingURL=bounded-ttl-cache.d.ts.map

package/dist/auth/client.d.ts

@@ -28,4 +28,3 @@ export interface OAuthClientCallbacksOptions {
     onServerClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
 }
 export declare function createOAuthClientCallbacks(options: OAuthClientCallbacksOptions): OAuthLoginCallbacks;
-//# sourceMappingURL=client.d.ts.map

package/dist/auth/cline.d.ts

@@ -66,4 +66,3 @@ export declare function refreshClineToken(current: ClineOAuthCredentials, option
 export declare function getValidClineCredentials(currentCredentials: ClineOAuthCredentials | null, providerOptions: ClineOAuthProviderOptions, options?: ClineTokenResolution): Promise<ClineOAuthCredentials | null>;
 export declare function createClineOAuthProvider(options: ClineOAuthProviderOptions): OAuthProviderInterface;
 export {};
-//# sourceMappingURL=cline.d.ts.map

package/dist/auth/codex.d.ts

@@ -41,4 +41,3 @@ export declare function getValidOpenAICodexCredentials(currentCredentials: OAuth
 export declare function isOpenAICodexTokenExpired(credentials: OAuthCredentials, refreshBufferMs?: number): boolean;
 export declare function normalizeOpenAICodexCredentials(credentials: OAuthCredentials): OAuthCredentials;
 export declare const openaiCodexOAuthProvider: OAuthProviderInterface;
-//# sourceMappingURL=codex.d.ts.map

package/dist/auth/oca.d.ts

@@ -26,4 +26,3 @@ export declare function createOcaRequestHeaders(input: {
     taskId: string;
     metadata?: OcaClientMetadata;
 }): Promise<Record<string, string>>;
-//# sourceMappingURL=oca.d.ts.map

package/dist/auth/server.d.ts

@@ -52,4 +52,3 @@ export interface LocalOAuthServer {
     close: () => void;
 }
 export declare function startLocalOAuthServer(options: LocalOAuthServerOptions): Promise<LocalOAuthServer>;
-//# sourceMappingURL=server.d.ts.map

package/dist/auth/types.d.ts

@@ -101,4 +101,3 @@ export interface OcaTokenResolution {
     refreshBufferMs?: number;
     retryableTokenGraceMs?: number;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/auth/utils.d.ts

@@ -30,4 +30,3 @@ export declare function resolveAuthorizationCodeInput(input: {
 }): Promise<ParsedAuthorizationInput & {
     error?: string;
 }>;
-//# sourceMappingURL=utils.d.ts.map

package/dist/cline-core/automation.d.ts

@@ -0,0 +1,34 @@
+import type { AutomationEventEnvelope, BasicLogger, ExtensionContext, ITelemetryService } from "@clinebot/shared";
+import type { CronService } from "../cron/service/cron-service";
+import type { HubScheduleRuntimeHandlers } from "../cron/service/schedule-service";
+import type { RuntimeHost } from "../runtime/host/runtime-host";
+import type { ClineAutomationEventIngressResult, ClineAutomationEventLog, ClineAutomationListEventsOptions, ClineAutomationListRunsOptions, ClineAutomationListSpecsOptions, ClineAutomationRun, ClineAutomationSpec, ClineCoreAutomationApi, ClineCoreAutomationOptions } from "./types";
+export declare function normalizeAutomationOptions(options: ClineCoreAutomationOptions | boolean | undefined): ClineCoreAutomationOptions | undefined;
+export declare function normalizeAutomationCronScope(scope: ClineCoreAutomationOptions["cronScope"]): "global" | "workspace" | undefined;
+export declare class ClineCoreAutomationController implements ClineCoreAutomationApi {
+    private readonly getService;
+    constructor(getService: () => CronService);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reconcileNow(): Promise<void>;
+    ingestEvent(event: AutomationEventEnvelope): ClineAutomationEventIngressResult;
+    listEvents(options?: ClineAutomationListEventsOptions): ClineAutomationEventLog[];
+    getEvent(eventId: string): ClineAutomationEventLog | undefined;
+    listSpecs(options?: ClineAutomationListSpecsOptions): ClineAutomationSpec[];
+    listRuns(options?: ClineAutomationListRunsOptions): ClineAutomationRun[];
+}
+export interface ClineCoreAutomationRuntimeHandlersInput {
+    host: RuntimeHost;
+    getExtensionContext(): ExtensionContext | undefined;
+}
+export declare function createClineCoreAutomationRuntimeHandlers(input: ClineCoreAutomationRuntimeHandlersInput): HubScheduleRuntimeHandlers;
+export interface ClineCoreAutomationExtensionContextInput {
+    automationService?: CronService;
+    automation: ClineCoreAutomationApi;
+    context?: ExtensionContext;
+    clientName?: string;
+    distinctId?: string;
+    logger?: BasicLogger;
+    telemetry?: ITelemetryService;
+}
+export declare function createClineCoreAutomationExtensionContext(input: ClineCoreAutomationExtensionContextInput): ExtensionContext | undefined;

package/dist/cline-core/runtime-services.d.ts

@@ -0,0 +1,5 @@
+import type { PendingPromptsRuntimeService, PendingPromptsServiceApi, RuntimeHost, SessionModelRuntimeService, SessionUsageRuntimeService } from "../runtime/host/runtime-host";
+import { type ClineCoreSettingsApi } from "../settings";
+export type RuntimeHostServiceExtensions = RuntimeHost & Partial<PendingPromptsRuntimeService & SessionUsageRuntimeService & SessionModelRuntimeService>;
+export declare function createClineCoreSettingsApi(host: RuntimeHost): ClineCoreSettingsApi;
+export declare function createClineCorePendingPromptsApi(host: RuntimeHost): PendingPromptsServiceApi;

package/dist/cline-core/start-input.d.ts

@@ -0,0 +1,10 @@
+import type { ExtensionContext } from "@clinebot/shared";
+import type { RuntimeCapabilities } from "../runtime/capabilities";
+import type { StartSessionInput } from "../runtime/host/runtime-host";
+import type { ClineCoreStartInput } from "./types";
+export declare function toClineCoreStartInput(input: StartSessionInput | ClineCoreStartInput): ClineCoreStartInput;
+export interface NormalizeClineCoreStartInputOptions {
+    defaultCapabilities?: RuntimeCapabilities;
+    withExtensionContext?: (context?: ExtensionContext) => ExtensionContext | undefined;
+}
+export declare function normalizeClineCoreStartInput(input: ClineCoreStartInput, options?: NormalizeClineCoreStartInputOptions): StartSessionInput;

package/dist/cline-core/telemetry.d.ts

@@ -0,0 +1,10 @@
+import type { ITelemetryService } from "@clinebot/shared";
+import type { ClineCoreStartInput } from "./types";
+export interface EmitSessionStartedTelemetryInput {
+    input: ClineCoreStartInput;
+    sessionId: string;
+    telemetry?: ITelemetryService;
+    clientName?: string;
+    runtimeAddress?: string;
+}
+export declare function emitSessionStartedTelemetry(input: EmitSessionStartedTelemetryInput): void;