@cline/core 0.0.73 → 0.0.74-nightly.1786676845

package/dist/ClineCore.d.ts

@@ -1,6 +1,7 @@
 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";
@@ -229,10 +230,12 @@ export declare class ClineCore {
      */
     readSessionCompactionState: RuntimeHost["readSessionCompactionState"];
     /**
-     * Reads message history for a session.
+     * Reads the canonical message history for a session.
      *
-     * Retrieves the full message transcript for a specific session, including all
-     * user messages, agent responses, and tool interactions.
+     * 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
@@ -243,6 +246,13 @@ export declare class ClineCore {
      * ```
      */
     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.

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

@@ -1,4 +1,4 @@
-import type { Message } from "@cline/llms";
+import type { MessageWithMetadata } from "@cline/llms";
 import type { AgentConfig, AutomationEventEnvelope, BasicLogger, ITelemetryService } from "@cline/shared";
 import type { CronEventSuppression } from "../cron/events/cron-event-ingress";
 import type { CronEventLogRecord, CronRunRecord, CronSpecRecord } from "../cron/store/sqlite-cron-store";
@@ -119,7 +119,7 @@ export interface RestoreInput {
 export interface RestoreResult {
     sessionId?: string;
     startResult?: StartSessionResult;
-    messages?: Message[];
+    messages?: MessageWithMetadata[];
     checkpoint: CheckpointEntry;
 }
 export interface CompareCheckpointInput {

package/dist/extensions/tools/runtime.d.ts

@@ -12,6 +12,7 @@ export interface BuiltinToolAvailabilityContext {
     enableSpawnAgent?: boolean;
     enableAgentTeams?: boolean;
     disabledToolIds?: ReadonlySet<string>;
+    enabledModelToolIds?: ReadonlySet<string>;
 }
 export declare function getCoreBuiltinToolCatalog(context?: BuiltinToolAvailabilityContext): ToolCatalogEntry[];
 export declare function getCoreDefaultEnabledToolIds(context?: BuiltinToolAvailabilityContext): string[];

package/dist/hub/client/index.d.ts

@@ -80,6 +80,21 @@ export declare class NodeHubClient {
 }
 export declare function normalizeHubWebSocketUrl(url: string): string;
 export declare function verifyHubConnection(url: string, options?: Pick<HubClientOptions, "workspaceRoot" | "cwd" | "authToken">): Promise<boolean>;
+/**
+ * Whether any client is attached to a session on the hub - the one signal
+ * that cannot go stale, because participants are live socket subscriptions
+ * the hub drops the moment a client's connection closes.
+ *
+ * Deliberately NOT based on session status: a client that dies without
+ * stopping its session leaves the hub-side runtime behind in a non-terminal
+ * status forever, and counting those "ghost" sessions as busy pins an
+ * outdated hub as "serving sessions" until the machine reboots. The cost of
+ * ignoring status is that a participant-less background run executing at the
+ * exact moment of a hub swap dies with the old hub - rare, and its next
+ * scheduled tick runs normally on the replacement.
+ */
+export declare function hasActiveHubSessions(payload: unknown): boolean;
+export declare function localHubHasNoActiveSessions(url: string, authToken?: string, options?: Pick<HubClientOptions, "workspaceRoot" | "cwd">): Promise<boolean>;
 export declare function resolveCompatibleLocalHubUrl(options?: LocalHubResolutionOptions): Promise<string | undefined>;
 export declare function ensureCompatibleLocalHubUrl(options?: LocalHubResolutionOptions): Promise<string | undefined>;
 export declare function requestHubShutdown(url: string, authToken?: string): Promise<boolean>;

package/dist/hub/client/managed-hub-build-watcher.d.ts

@@ -0,0 +1,54 @@
+export interface ManagedHubBuildMismatchEvent {
+    /** WebSocket URL of the live managed Hub that does not match this build. */
+    url: string;
+    /**
+     * Why client and Hub disagree:
+     * - `build_mismatch`: the running Hub is a newer build this client stays
+     *   attached to, and updating this client resolves it.
+     * - `unsupported_protocol`: this client cannot speak the Hub's protocol.
+     * - `outdated_hub`: this client is the newer build, but the running Hub was
+     *   left in place because it is still serving sessions. Nothing to install;
+     *   the Hub is replaced once those sessions end.
+     */
+    reason: "unsupported_protocol" | "build_mismatch" | "outdated_hub";
+    /** Build identity reported by the running Hub, when it reports one. */
+    hubBuildId?: string;
+    /** Core package version reported by the running Hub. */
+    hubCoreVersion?: string;
+    /** Build identity this client expects a managed Hub to match. */
+    expectedBuildId: string;
+}
+/**
+ * Probe the managed local Hub once and report whether a live Hub is running
+ * a build this client cannot manage. Returns `undefined` when there is no
+ * discovery record, the recorded Hub is unreachable, a Hub startup
+ * transaction is in flight (another client may be mid-replacement), or the
+ * running Hub matches this build.
+ *
+ * A mismatch means another Cline installation replaced the shared Hub with a
+ * different build (for example, the CLI was updated while the desktop app
+ * kept running). This client can keep talking to it over the compatible wire
+ * protocol, but it should prompt the user to update and restart so client
+ * and Hub run the same code again.
+ */
+export declare function checkManagedHubBuildMismatch(): Promise<ManagedHubBuildMismatchEvent | undefined>;
+export interface WatchManagedHubBuildOptions {
+    onMismatch: (event: ManagedHubBuildMismatchEvent) => void;
+    intervalMs?: number;
+}
+/**
+ * Periodically watch the managed local Hub for a build-identity mismatch and
+ * invoke `onMismatch` when another Cline installation has replaced the Hub
+ * with a different build. Fires once per observed Hub build (it will fire
+ * again only if the Hub changes to yet another mismatched build after a
+ * compatible one was seen, or a different mismatch reason appears).
+ *
+ * Start this only for managed Hub usage. Hosts configured with an explicit
+ * Hub endpoint keep protocol-only compatibility and must not show update
+ * prompts, so the watcher refuses to start when `CLINE_HUB_PORT` is set.
+ * The first check runs after one interval so app startup (which may itself
+ * be replacing a stale Hub) has settled.
+ *
+ * Returns a stop function.
+ */
+export declare function watchManagedHubBuildMismatch(options: WatchManagedHubBuildOptions): () => void;

package/dist/hub/client/session-client.d.ts

@@ -44,7 +44,7 @@ export interface HubRestoreResponse {
         manifestPath: string;
         messagesPath: string;
     };
-    messages?: LlmsProviders.Message[];
+    messages?: LlmsProviders.MessageWithMetadata[];
     checkpoint: CheckpointEntry;
 }
 export interface HubEventStreamHandlers {
@@ -83,7 +83,7 @@ export declare class HubSessionClient {
         updated: boolean;
     }>;
     getSession(sessionId: string): Promise<HubSessionRow | undefined>;
-    readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+    readMessages(sessionId: string): Promise<LlmsProviders.MessageWithMetadata[]>;
     restore(input: HubRestoreRequest): Promise<HubRestoreResponse>;
     listSessions(input?: {
         limit?: number;