@cerebriline/core 4.100.240

package/dist/ClineCore.d.ts

@@ -0,0 +1,365 @@
+import type { ClineCoreAutomationApi, ClineCoreListHistoryOptions, ClineCoreOptions, ClineCoreSettingsApi, ClineCoreStartInput, CompareCheckpointInput, CompareCheckpointResult, RestoreInput, RestoreResult } from "./cline-core/types";
+import type { PendingPromptsServiceApi, RuntimeHost, RuntimeHostSubscribeOptions, SessionConnectionRuntimeService, SessionModelRuntimeService, SessionUsageRuntimeService, StartSessionInput, StartSessionResult } from "./runtime/host/runtime-host";
+import { FeatureFlagsService } from "./services/feature-flags";
+import { type SessionDisplayMessage } from "./session/display-messages";
+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, CompareCheckpointInput, CompareCheckpointResult, HubOptions, RemoteOptions, RestoreInput, RestoreOptions, RestoreResult, RuntimeHostMode, StartSessionBootstrap, } from "./cline-core/types";
+import type { BackgroundDelegationView } from "./extensions/tools/team/background-delegations";
+import type { ConfiguredAgentDelegationResult, ConfiguredAgentSummary } from "./extensions/tools/team/delegate-to-agent";
+/**
+ * The primary entry point for the Cline Core SDK.
+ *
+ * @example
+ * ```ts
+ * import { ClineCore } from "@cerebriline/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 featureFlags: FeatureFlagsService;
+    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. The `usage` field is
+     * root/lead-agent usage; `aggregateUsage` includes teammates and subagents.
+     *
+     * @example
+     * ```ts
+     * const usageSummary = await cline.getAccumulatedUsage(sessionId);
+     * console.log(`Total cost: $${usageSummary?.aggregateUsage?.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"];
+    /**
+     * The configured agents this session loaded, for a host offering a picker.
+     */
+    listConfiguredAgents: (sessionId: string) => Promise<ConfiguredAgentSummary[]>;
+    /**
+     * Runs one configured agent on a task, on the user's say-so rather than the
+     * model's. The agent's report is appended to the conversation.
+     */
+    delegateToConfiguredAgent: (input: {
+        sessionId: string;
+        agentName: string;
+        prompt: string;
+        signal?: AbortSignal;
+    }) => Promise<ConfiguredAgentDelegationResult>;
+    /**
+     * Stand the change protocol down for a session, because the user said so.
+     *
+     * Resolving does not mean it has happened: the runtime picks the moment,
+     * because judging the open transaction can put files back and that write
+     * must not land while a tool call is still open.
+     *
+     * @returns whether there was a protocol running to stand down.
+     */
+    disengageAtomicProtocol: (sessionId: string) => Promise<boolean>;
+    /**
+     * Starts a configured agent beside the current turn rather than in place of
+     * it. Returns as soon as the run exists; the report arrives in the
+     * conversation whenever the agent is done.
+     */
+    startBackgroundDelegation: (input: {
+        sessionId: string;
+        agentName: string;
+        prompt: string;
+    }) => Promise<BackgroundDelegationView>;
+    /** The background delegations of one session, for a host drawing them. */
+    listBackgroundDelegations: (sessionId: string) => Promise<BackgroundDelegationView[]>;
+    /** Pause, resume or stop one. False when no run was in a state to take it. */
+    controlBackgroundDelegation: (input: {
+        sessionId: string;
+        id: string;
+        action: "pause" | "resume" | "stop";
+    }) => Promise<boolean>;
+    /**
+     * Stores the compacted working-context state for an existing session.
+     */
+    updateSessionCompactionState: RuntimeHost["updateSessionCompactionState"];
+    /**
+     * Reads the compacted working-context sidecar for a session, if one exists.
+     */
+    readSessionCompactionState: RuntimeHost["readSessionCompactionState"];
+    /**
+     * Reads the canonical message history for a session.
+     *
+     * This is the model/replay representation used by resume, fork, and
+     * compaction. Provider-owned model-tool activity remains observational
+     * metadata here. Use {@link readDisplayMessages} for a UI transcript with
+     * that activity projected into ordinary tool blocks.
+     *
+     * @example
+     * ```ts
+     * const messages = await cline.readMessages(sessionId);
+     * messages.forEach((msg) => {
+     *   console.log(`${msg.role}: ${msg.content}`);
+     * });
+     * ```
+     */
+    readMessages: RuntimeHost["readSessionMessages"];
+    /**
+     * Reads a transcript projected for presentation. Observational model-tool
+     * activity is represented with the same tool blocks as ordinary local tools.
+     *
+     * Use {@link readMessages} for resume, fork, compaction, or model replay.
+     */
+    readDisplayMessages(sessionId: string): Promise<SessionDisplayMessage[]>;
+    /**
+     * Reads message history for a session, preferring the live in-memory
+     * conversation when the session is still resident in this host.
+     *
+     * The persisted transcript only catches up at assistant-message/turn
+     * boundaries, so `readMessages` can miss an in-flight (or just-aborted)
+     * turn. Use this when the current conversation matters — e.g. seeding a
+     * replacement session during a plan/act mode switch. Falls back to the
+     * persisted transcript when the session is not resident or the host does
+     * not track live sessions.
+     */
+    readLiveMessages: RuntimeHost["readSessionMessages"];
+    restore(input: RestoreInput): Promise<RestoreResult>;
+    compareCheckpoint(input: CompareCheckpointInput): Promise<CompareCheckpointResult>;
+    /**
+     * 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"];
+    /**
+     * Updates provider/model/reasoning connection options for subsequent turns in
+     * an active session.
+     */
+    updateSessionConnection: SessionConnectionRuntimeService["updateSessionConnection"];
+}

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

@@ -0,0 +1,41 @@
+import type { ClineAccountBalance, ClineAccountOrganization, ClineAccountOrganizationBalance, ClineAccountOrganizationUsageTransaction, ClineAccountPaymentTransaction, ClineAccountUsageTransaction, ClineAccountUser, ClineOrganization, ClineSubscriptionPlan, FeaturebaseTokenResponse, UserCurrentPlan, 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[]>;
+    fetchAvailableSubscriptionPlans(input?: {
+        type?: "individual" | "teams";
+    }): Promise<ClineSubscriptionPlan[]>;
+    fetchCurrentUserPlan(): Promise<UserCurrentPlan | undefined>;
+    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, ClineSubscriptionPlan, FeaturebaseTokenResponse, UserCurrentPlan, UserRemoteConfigOrganization, UserRemoteConfigResponse, } from "./types";

package/dist/account/rpc.d.ts

@@ -0,0 +1,40 @@
+import type { ClineAccountActionRequest, ProviderActionRequest } from "@cerebriline/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,122 @@
+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 ClineSubscriptionPlan {
+    displayName?: string;
+    features?: {
+        included?: string[];
+        [key: string]: unknown;
+    };
+    id?: string;
+    interval?: string;
+    name?: string;
+    pricePerSeatCents?: number;
+    type?: string;
+    [key: string]: unknown;
+}
+export interface UserCurrentPlan {
+    cancelAt?: string;
+    canceledAt?: string;
+    currentPeriodEnd?: string;
+    currentPeriodStart?: string;
+    plan?: ClineSubscriptionPlan | null;
+    planHistoryId?: string;
+    subscriptionId?: string;
+    userId?: string;
+    [key: string]: unknown;
+}
+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;