@cline/core 0.0.38-nightly.1778113663

package/README.md

@@ -0,0 +1,108 @@
+# [experimental] @cline/core
+
+`@cline/core` is the stateful orchestration layer of the Cline SDK. It
+connects the agent runtime, provider settings, storage, default tools, and
+session lifecycle into a host-ready runtime.
+
+## What You Get
+
+- session lifecycle and orchestration primitives
+- provider settings and account services
+- default runtime tools and MCP integration
+- storage-backed session and team state helpers
+- host-facing Node helpers through `@cline/core`
+
+## Installation
+
+```bash
+npm install @cline/core
+```
+
+## Entry Points
+
+- `@cline/core`: core contracts, shared utilities, and Node/server helpers for building hosts and runtimes
+
+## Typical Usage
+
+Most host apps should start with `@cline/core`.
+
+```ts
+import { ClineCore } from "@cline/core";
+
+const cline = await ClineCore.create({});
+
+const result = await cline.start({
+	config: {
+		providerId: "anthropic",
+		modelId: "claude-sonnet-4-6",
+		apiKey: process.env.ANTHROPIC_API_KEY ?? "",
+		cwd: process.cwd(),
+		mode: "act",
+		enableTools: true,
+		enableSpawnAgent: false,
+		enableAgentTeams: false,
+		systemPrompt: "You are a concise assistant.",
+	},
+	prompt: "Summarize this project.",
+	interactive: false,
+});
+
+console.log(result.result?.text);
+await cline.dispose();
+```
+
+## Session Bootstrap
+
+`ClineCore.create(...)` also accepts `prepare(input)`.
+
+Use it when a host needs to prepare workspace-scoped runtime state before each
+session starts, then apply watcher/extensions/telemetry inputs through
+explicit `localRuntime` bootstrap fields without widening the shared host
+contract.
+
+## Main APIs
+
+### Runtime and Sessions
+
+Use `@cline/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
+
+`@cline/core` owns the built-in host tools and executors:
+
+- `createBuiltinTools(...)`
+- `createDefaultTools(...)`
+- `createDefaultExecutors(...)`
+
+### Storage and Settings
+
+The package also exports storage and settings helpers such as:
+
+- `ProviderSettingsManager`
+- `SqliteTeamStore`
+- SQLite-backed local session stores and artifacts through `@cline/core`
+
+## Related Packages
+
+- `@cline/agents`: stateless agent loop and tool primitives
+- `@cline/llms`: provider/model configuration and handlers
+
+## More Examples
+
+- Repo examples: [apps/examples/cline-sdk](https://github.com/cline/cline/tree/main/apps/examples/cline-sdk)
+- Workspace overview: [README.md](https://github.com/cline/cline/blob/main/README.md)
+- API and architecture references: [DOC.md](https://github.com/cline/cline/blob/main/DOC.md), [ARCHITECTURE.md](https://github.com/cline/cline/blob/main/ARCHITECTURE.md)

package/dist/ClineCore.d.ts

@@ -0,0 +1,282 @@
+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 "@cline/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();
+    /**
+     * 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",
+     * });
+     * ```
+     */
+    static create(options?: ClineCoreOptions): Promise<ClineCore>;
+    private disposeSessionBootstrap;
+    /**
+     * 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);
+     * });
+     * ```
+     */
+    start(input: StartSessionInput): Promise<StartSessionResult>;
+    /**
+     * Starts a new Cline session with extended core-specific configuration.
+     * This overload allows specifying local runtime options and config overrides.
+     */
+    start(input: ClineCoreStartInput): Promise<StartSessionResult>;
+    /**
+     * 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",
+     * });
+     * ```
+     */
+    send: RuntimeHost["runTurn"];
+    /**
+     * 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}`);
+     * ```
+     */
+    getAccumulatedUsage: SessionUsageRuntimeService["getAccumulatedUsage"];
+    /**
+     * 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);
+     * ```
+     */
+    abort: RuntimeHost["abort"];
+    /**
+     * 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);
+     * ```
+     */
+    stop: RuntimeHost["stopSession"];
+    /**
+     * 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();
+     * ```
+     */
+    dispose: RuntimeHost["dispose"];
+    /**
+     * 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);
+     * ```
+     */
+    get: RuntimeHost["getSession"];
+    /**
+     * Lists recent sessions through the shared history-listing path.
+     */
+    listHistory: (options?: ClineCoreListHistoryOptions) => Promise<SessionHistoryRecord[]>;
+    /**
+     * 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}`);
+     * });
+     * ```
+     */
+    list: (limit?: number, options?: Omit<ClineCoreListHistoryOptions, "limit">) => Promise<SessionHistoryRecord[]>;
+    /**
+     * 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");
+     * }
+     * ```
+     */
+    delete: RuntimeHost["deleteSession"];
+    /**
+     * 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",
+     * });
+     * ```
+     */
+    update: RuntimeHost["updateSession"];
+    /**
+     * 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}`);
+     * });
+     * ```
+     */
+    readMessages: RuntimeHost["readSessionMessages"];
+    restore(input: RestoreInput): Promise<RestoreResult>;
+    /**
+     * 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
+     */
+    ingestHookEvent: RuntimeHost["dispatchHookEvent"];
+    /**
+     * Subscribes to session events.
+     *
+     * Registers a listener for all session events (messages, state changes, errors, etc.).
+     * Returns an unsubscribe function to stop listening.
+     *
+     * @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();
+     * ```
+     */
+    subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
+    /**
+     * 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");
+     * ```
+     */
+    updateSessionModel: SessionModelRuntimeService["updateSessionModel"];
+}

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

@@ -0,0 +1,37 @@
+import type { ClineAccountBalance, ClineAccountOrganization, ClineAccountOrganizationBalance, ClineAccountOrganizationUsageTransaction, ClineAccountPaymentTransaction, ClineAccountUsageTransaction, ClineAccountUser, ClineOrganization, FeaturebaseTokenResponse, UserRemoteConfigResponse } from "./types";
+export interface ClineAccountServiceOptions {
+    apiBaseUrl: string;
+    getAuthToken: () => Promise<string | undefined | null>;
+    getCurrentUserId?: () => Promise<string | undefined | null> | string | undefined | null;
+    getOrganizationMemberId?: (organizationId: string) => Promise<string | undefined | null> | string | undefined | null;
+    getHeaders?: () => Promise<Record<string, string> | undefined> | Record<string, string> | undefined;
+    requestTimeoutMs?: number;
+    fetchImpl?: typeof fetch;
+}
+export declare class ClineAccountService {
+    private readonly apiBaseUrl;
+    private readonly getAuthTokenFn;
+    private readonly getCurrentUserIdFn;
+    private readonly getOrganizationMemberIdFn;
+    private readonly getHeadersFn;
+    private readonly requestTimeoutMs;
+    private readonly fetchImpl;
+    constructor(options: ClineAccountServiceOptions);
+    fetchMe(): Promise<ClineAccountUser>;
+    fetchRemoteConfig(): Promise<UserRemoteConfigResponse | null>;
+    fetchFeaturebaseToken(): Promise<FeaturebaseTokenResponse | undefined>;
+    fetchBalance(userId?: string): Promise<ClineAccountBalance>;
+    fetchUsageTransactions(userId?: string): Promise<ClineAccountUsageTransaction[]>;
+    fetchPaymentTransactions(userId?: string): Promise<ClineAccountPaymentTransaction[]>;
+    fetchUserOrganizations(): Promise<ClineAccountOrganization[]>;
+    fetchOrganization(organizationId: string): Promise<ClineOrganization>;
+    fetchOrganizationBalance(organizationId: string): Promise<ClineAccountOrganizationBalance>;
+    fetchOrganizationUsageTransactions(input: {
+        organizationId: string;
+        memberId?: string;
+    }): Promise<ClineAccountOrganizationUsageTransaction[]>;
+    switchAccount(organizationId?: string | null): Promise<void>;
+    private resolveUserId;
+    private resolveOrganizationMemberId;
+    private request;
+}

package/dist/account/index.d.ts

@@ -0,0 +1,3 @@
+export { ClineAccountService, type ClineAccountServiceOptions, } from "./cline-account-service";
+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";

package/dist/account/rpc.d.ts

@@ -0,0 +1,40 @@
+import type { ClineAccountActionRequest, ProviderActionRequest } from "@cline/shared";
+import type { ClineAccountBalance, ClineAccountOrganization, ClineAccountOrganizationBalance, ClineAccountOrganizationUsageTransaction, ClineAccountPaymentTransaction, ClineAccountUsageTransaction, ClineAccountUser, FeaturebaseTokenResponse } from "./types";
+export interface ClineAccountOperations {
+    fetchMe(): Promise<ClineAccountUser>;
+    fetchBalance(userId?: string): Promise<ClineAccountBalance>;
+    fetchUsageTransactions(userId?: string): Promise<ClineAccountUsageTransaction[]>;
+    fetchPaymentTransactions(userId?: string): Promise<ClineAccountPaymentTransaction[]>;
+    fetchUserOrganizations(): Promise<ClineAccountOrganization[]>;
+    fetchOrganizationBalance(organizationId: string): Promise<ClineAccountOrganizationBalance>;
+    fetchOrganizationUsageTransactions(input: {
+        organizationId: string;
+        memberId?: string;
+    }): Promise<ClineAccountOrganizationUsageTransaction[]>;
+    switchAccount(organizationId?: string | null): Promise<void>;
+    fetchFeaturebaseToken?(): Promise<FeaturebaseTokenResponse | undefined>;
+}
+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: ProviderActionExecutor);
+    fetchMe(): Promise<ClineAccountUser>;
+    fetchBalance(userId?: string): Promise<ClineAccountBalance>;
+    fetchUsageTransactions(userId?: string): Promise<ClineAccountUsageTransaction[]>;
+    fetchPaymentTransactions(userId?: string): Promise<ClineAccountPaymentTransaction[]>;
+    fetchUserOrganizations(): Promise<ClineAccountOrganization[]>;
+    fetchOrganizationBalance(organizationId: string): Promise<ClineAccountOrganizationBalance>;
+    fetchOrganizationUsageTransactions(input: {
+        organizationId: string;
+        memberId?: string;
+    }): Promise<ClineAccountOrganizationUsageTransaction[]>;
+    switchAccount(organizationId?: string | null): Promise<void>;
+    fetchFeaturebaseToken(): Promise<FeaturebaseTokenResponse | undefined>;
+    private request;
+}

package/dist/account/types.d.ts

@@ -0,0 +1,98 @@
+export interface ClineAccountOrganization {
+    active: boolean;
+    memberId: string;
+    name: string;
+    organizationId: string;
+    roles: Array<"admin" | "member" | "owner">;
+}
+export interface ClineAccountUser {
+    id: string;
+    email: string;
+    displayName: string;
+    photoUrl: string;
+    createdAt: string;
+    updatedAt: string;
+    organizations: ClineAccountOrganization[];
+}
+export interface UserRemoteConfigOrganization {
+    organizationId: string;
+    name: string;
+}
+export interface UserRemoteConfigResponse {
+    organizationId: string;
+    value: string;
+    enabled: boolean;
+    organizations?: UserRemoteConfigOrganization[];
+}
+export interface ClineAccountBalance {
+    balance: number;
+    userId: string;
+}
+export interface ClineAccountUsageTransaction {
+    aiInferenceProviderName: string;
+    aiModelName: string;
+    aiModelTypeName: string;
+    completionTokens: number;
+    costUsd: number;
+    createdAt: string;
+    creditsUsed: number;
+    generationId: string;
+    id: string;
+    metadata: {
+        additionalProp1: string;
+        additionalProp2: string;
+        additionalProp3: string;
+    };
+    operation?: string;
+    organizationId: string;
+    promptTokens: number;
+    totalTokens: number;
+    userId: string;
+}
+export interface ClineAccountPaymentTransaction {
+    paidAt: string;
+    creatorId: string;
+    amountCents: number;
+    credits: number;
+}
+export interface ClineOrganization {
+    createdAt: string;
+    defaultRemoteConfig?: string;
+    deletedAt?: string;
+    externalOrganizationId?: string;
+    id: string;
+    memberCount?: number;
+    name: string;
+    remoteConfigEnabled: boolean;
+    updatedAt: string;
+}
+export interface ClineAccountOrganizationBalance {
+    balance: number;
+    organizationId: string;
+}
+export interface FeaturebaseTokenResponse {
+    featurebaseJwt: string;
+}
+export interface ClineAccountOrganizationUsageTransaction {
+    aiInferenceProviderName: string;
+    aiModelName: string;
+    aiModelTypeName: string;
+    completionTokens: number;
+    costUsd: number;
+    createdAt: string;
+    creditsUsed: number;
+    generationId: string;
+    id: string;
+    memberDisplayName: string;
+    memberEmail: string;
+    metadata: {
+        additionalProp1: string;
+        additionalProp2: string;
+        additionalProp3: string;
+    };
+    operation?: string;
+    organizationId: string;
+    promptTokens: number;
+    totalTokens: number;
+    userId: string;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Small process-local string cache with TTL expiry and a hard entry cap.
+ * Used where unbounded Maps would grow without bound in long-running processes.
+ */
+export declare class BoundedTtlCache {
+    private readonly ttlMs;
+    private readonly maxEntries;
+    private readonly entries;
+    constructor(ttlMs: number, maxEntries: number);
+    get(key: string, now?: number): string | undefined;
+    set(key: string, value: string, now?: number, ttlMsOverride?: number): void;
+    private pruneExpired;
+}

package/dist/auth/client.d.ts

@@ -0,0 +1,30 @@
+import type { OAuthServerCloseInfo, OAuthServerListeningInfo } from "./server";
+import type { OAuthLoginCallbacks, OAuthPrompt } from "./types";
+export interface OAuthClientCallbacksOptions {
+    onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+    onOutput?: (message: string) => void;
+    openUrl?: (url: string) => void | Promise<void>;
+    onOpenUrlError?: (context: {
+        url: string;
+        error: unknown;
+    }) => void;
+    /**
+     * Called when the local OAuth redirect server successfully binds to a port
+     * and is ready to receive the browser callback.
+     *
+     * Forwarded directly from `OAuthLoginCallbacks.onServerListening`.
+     * Use this to show a "waiting for OAuth callback on :::1 port N" status
+     * message or, in remote-development environments (e.g. JetBrains Gateway),
+     * to set up a port-forward from the remote machine to the local one.
+     */
+    onServerListening?: (info: OAuthServerListeningInfo) => void | Promise<void>;
+    /**
+     * Called when the local OAuth redirect server closes.
+     *
+     * Forwarded directly from `OAuthLoginCallbacks.onServerClose`.
+     * Use this to tear down port-forwards and clear any status UI set up in
+     * `onServerListening`.
+     */
+    onServerClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
+}
+export declare function createOAuthClientCallbacks(options: OAuthClientCallbacksOptions): OAuthLoginCallbacks;

package/dist/auth/cline.d.ts

@@ -0,0 +1,64 @@
+import type { ITelemetryService } from "@cline/shared";
+import type { OAuthCredentials, OAuthLoginCallbacks, OAuthProviderInterface } from "./types";
+export type ClineTokenResolution = {
+    forceRefresh?: boolean;
+    refreshBufferMs?: number;
+    retryableTokenGraceMs?: number;
+};
+interface ClineAuthApiUser {
+    subject: string | null;
+    email: string;
+    name: string;
+    clineUserId: string | null;
+    accounts: string[] | null;
+}
+type HeaderMap = Record<string, string>;
+type HeaderInput = HeaderMap | (() => Promise<HeaderMap> | HeaderMap);
+export interface ClineOAuthProviderOptions {
+    apiBaseUrl: string;
+    headers?: HeaderInput;
+    requestTimeoutMs?: number;
+    telemetry?: ITelemetryService;
+    useWorkOSDeviceAuth?: boolean;
+    callbackPath?: string;
+    callbackPorts?: number[];
+    /**
+     * Optional identity provider name for token exchange.
+     */
+    provider?: string;
+}
+export interface ClineOAuthCredentials extends OAuthCredentials {
+    metadata?: {
+        provider?: string;
+        tokenType?: string;
+        userInfo?: ClineAuthApiUser;
+        [key: string]: unknown;
+    };
+}
+export declare function loginClineOAuth(options: ClineOAuthProviderOptions & {
+    callbacks: OAuthLoginCallbacks;
+}): Promise<ClineOAuthCredentials>;
+export declare function startClineDeviceAuth(options?: {
+    requestTimeoutMs?: number;
+}): Promise<{
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete?: string;
+    expiresInSeconds: number;
+    pollIntervalSeconds: number;
+}>;
+export declare function completeClineDeviceAuth(options: {
+    deviceCode: string;
+    expiresInSeconds: number;
+    pollIntervalSeconds: number;
+    apiBaseUrl: string;
+    provider?: string;
+    headers?: HeaderInput;
+    requestTimeoutMs?: number;
+    telemetry?: ITelemetryService;
+}): Promise<ClineOAuthCredentials>;
+export declare function refreshClineToken(current: ClineOAuthCredentials, options: ClineOAuthProviderOptions): Promise<ClineOAuthCredentials>;
+export declare function getValidClineCredentials(currentCredentials: ClineOAuthCredentials | null, providerOptions: ClineOAuthProviderOptions, options?: ClineTokenResolution): Promise<ClineOAuthCredentials | null>;
+export declare function createClineOAuthProvider(options: ClineOAuthProviderOptions): OAuthProviderInterface;
+export {};