@cline/core 0.0.81 → 0.0.82

package/dist/runtime/orchestration/session-runtime-orchestrator.d.ts

@@ -131,6 +131,7 @@ export declare class SessionRuntime {
     private activeTrackerWork;
     /** True when tracker logic has issued an abort for the active run. */
     private trackerAbortInFlight;
+    private readonly handleExternalAbort;
     constructor(config: AgentConfig, deps?: SessionRuntimeOrchestratorDeps);
     getAgentId(): string;
     getConversationId(): string;

package/dist/services/global-settings.d.ts

@@ -26,13 +26,13 @@ export declare const GlobalSettingsSchema: z.ZodPipe<z.ZodObject<{
     }>>>;
     toolAutoApprove: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
     tuiTheme: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    disabledTools: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
+    disabledTools: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>, unknown>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
     tools: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
         web_search: "web_search";
     }> & z.core.$partial, z.ZodObject<{
         enabled: z.ZodBoolean;
     }, z.core.$strip>>>;
-    disabledPlugins: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
+    disabledPlugins: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>, unknown>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
 }, z.core.$strip>, z.ZodTransform<{
     telemetryOptOut: boolean;
     autoUpdateEnabled: boolean;

package/dist/services/providers/local-provider-service.d.ts

@@ -1,7 +1,7 @@
 import * as LlmsModels from "@cline/llms";
 import type { AddProviderActionRequest, ITelemetryService, ProviderCapability, ProviderListItem, ProviderModel, SaveProviderSettingsActionRequest, VoiceInputSelection } from "@cline/shared";
 import { type ProviderOAuthCredentials } from "../../auth/provider-auth-registry";
-import type { ProviderClient, ProviderConfig, ProviderProtocol, ProviderSettings } from "../../services/llms/provider-settings";
+import { type ProviderClient, type ProviderConfig, type ProviderProtocol, type ProviderSettings } from "../../services/llms/provider-settings";
 import type { ProviderTokenSource } from "../../types/provider-settings";
 import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
 export { ensureCustomProvidersLoaded } from "./local-provider-registry";

package/dist/services/providers/provider-readiness.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderConfig, ProviderSettings } from "../llms/provider-settings";
+/**
+ * Whether persisted provider settings hold enough real credentials or
+ * endpoint configuration for a turn to plausibly succeed. Unlike the mere
+ * existence of a settings entry (which migrations and empty "connect" saves
+ * can create), this requires provider-appropriate evidence: an API key or
+ * OAuth token, cloud credentials (AWS/GCP/Azure/SAP), a local-auth CLI, or a
+ * resolvable endpoint + model for keyless local providers.
+ */
+export declare function isProviderSettingsUsable(providerId: string, settings: ProviderSettings | undefined, config?: Pick<ProviderConfig, "baseUrl" | "modelId">): boolean;

package/dist/services/session-import/claude-code.d.ts

@@ -0,0 +1,16 @@
+import { type ConvertedImportedSession, type ImportableSessionSummary, type SessionImportAdapter } from "./types";
+export interface ClaudeCodeAdapterOptions {
+    /** Defaults to ~/.claude/projects */
+    projectsDir?: string;
+}
+export declare class ClaudeCodeImportAdapter implements SessionImportAdapter {
+    readonly tool: "claude-code";
+    private readonly projectsDir;
+    constructor(options?: ClaudeCodeAdapterOptions);
+    isInstalled(): boolean;
+    private sessionFiles;
+    private findSessionFile;
+    discover(): ImportableSessionSummary[];
+    private summarizeFile;
+    convert(sourceId: string): ConvertedImportedSession;
+}

package/dist/services/session-import/codex.d.ts

@@ -0,0 +1,34 @@
+import { type ConvertedImportedSession, type ImportableSessionSummary, type SessionImportAdapter } from "./types";
+export interface CodexAdapterOptions {
+    /** Defaults to $CODEX_HOME or ~/.codex */
+    codexHome?: string;
+}
+export declare class CodexImportAdapter implements SessionImportAdapter {
+    readonly tool: "codex";
+    private readonly codexHome;
+    constructor(options?: CodexAdapterOptions);
+    private get sessionsDir();
+    isInstalled(): boolean;
+    /** thread_name by session id, from Codex's own index. */
+    private readTitleIndex;
+    private sessionFiles;
+    /**
+     * Resuming a Codex thread writes a new rollout file that re-embeds the
+     * original session_meta id, so one logical session can span several files.
+     * Prefer the file with the most conversation (the resumed rollout replays
+     * history), tie-breaking on the most recent activity.
+     */
+    private static pickRicherFile;
+    /**
+     * Session id → richest rollout file. Building it means reading every
+     * rollout once (resumed rollouts only carry the original id inside
+     * session_meta, not in their filename), so it is cached for the batch:
+     * without the cache, importing N sessions re-read the whole store N times.
+     */
+    private index?;
+    private buildIndex;
+    dispose(): void;
+    private findSessionFile;
+    discover(): ImportableSessionSummary[];
+    convert(sourceId: string): ConvertedImportedSession;
+}

package/dist/services/session-import/index.d.ts

@@ -0,0 +1,6 @@
+export { type ClaudeCodeAdapterOptions, ClaudeCodeImportAdapter, } from "./claude-code";
+export { type CodexAdapterOptions, CodexImportAdapter } from "./codex";
+export { type OpencodeAdapterOptions, OpencodeImportAdapter, } from "./opencode";
+export { IMPORT_MISSING_TOOL_RESULT_TEXT, sanitizeImportedMessages, } from "./sanitize";
+export { type ImportedFromMetadata, readImportedFromMetadata, SessionImportService, } from "./service";
+export { type ConvertedImportedSession, type ImportableSessionSummary, SESSION_IMPORT_TOOL_LABELS, SESSION_IMPORT_TOOLS, type SessionImportAdapter, type SessionImportOptions, type SessionImportRequest, type SessionImportResult, type SessionImportTool, } from "./types";

package/dist/services/session-import/opencode.d.ts

@@ -0,0 +1,25 @@
+import { type ConvertedImportedSession, type ImportableSessionSummary, type SessionImportAdapter } from "./types";
+export interface OpencodeAdapterOptions {
+    /** Defaults to $XDG_DATA_HOME/opencode or ~/.local/share/opencode */
+    dataDir?: string;
+}
+export declare class OpencodeImportAdapter implements SessionImportAdapter {
+    readonly tool: "opencode";
+    private readonly dbPath;
+    constructor(options?: OpencodeAdapterOptions);
+    isInstalled(): boolean;
+    /**
+     * opencode keeps its database open in WAL mode while the app runs.
+     * Snapshot the db (+ WAL/SHM) into a temp dir and read the copy so we
+     * never contend with — or corrupt — the live store. The snapshot is kept
+     * for the batch (a large db copied once per imported session was the
+     * dominant cost) and released by dispose().
+     */
+    private snapshot?;
+    private openSnapshot;
+    dispose(): void;
+    private withDbCopy;
+    discover(): ImportableSessionSummary[];
+    private firstUserText;
+    convert(sourceId: string): ConvertedImportedSession;
+}

package/dist/services/session-import/sanitize.d.ts

@@ -0,0 +1,16 @@
+import type * as LlmsProviders from "@cline/llms";
+type Message = LlmsProviders.MessageWithMetadata;
+export declare const IMPORT_MISSING_TOOL_RESULT_TEXT = "[import] Tool result was not captured in the source session history.";
+/**
+ * Prepares foreign conversation history for persistence and eventual replay
+ * to a provider:
+ * - cleans blocks (see cleanBlocks) and drops messages left empty,
+ * - guarantees every assistant tool_use has a matching tool_result in the
+ *   user messages that follow (synthesizing placeholders for orphans),
+ * - drops tool_result blocks whose tool_use no longer exists.
+ *
+ * Providers hard-reject histories that violate tool pairing, so this must
+ * run on every imported session regardless of source quality.
+ */
+export declare function sanitizeImportedMessages(messages: Message[]): Message[];
+export {};

package/dist/services/session-import/service.d.ts

@@ -0,0 +1,31 @@
+import type { UnifiedSessionPersistenceService } from "../../session/services/persistence-service";
+import type { ImportableSessionSummary, SessionImportAdapter, SessionImportOptions, SessionImportRequest, SessionImportResult, SessionImportTool } from "./types";
+export interface ImportedFromMetadata {
+    tool: SessionImportTool;
+    sourceSessionId: string;
+    sourcePath: string;
+    importedAt: string;
+    /** Provider/model the source tool ran the session on. */
+    sourceProvider?: string;
+    sourceModel?: string;
+}
+export declare function readImportedFromMetadata(metadata: Record<string, unknown> | null | undefined): ImportedFromMetadata | undefined;
+export declare class SessionImportService {
+    private readonly sessions;
+    private readonly adapters;
+    constructor(sessions: UnifiedSessionPersistenceService, adapters?: SessionImportAdapter[]);
+    installedTools(): SessionImportTool[];
+    /**
+     * `tool:sourceId` → existing Cline session id, from prior imports. Reads
+     * every row's metadata (not the 2000-row listSessions window) so a marker
+     * on an old session still prevents a duplicate.
+     */
+    private existingImports;
+    private disposeAdapters;
+    discover(): Promise<ImportableSessionSummary[]>;
+    importOne(request: SessionImportRequest, options?: SessionImportOptions): Promise<SessionImportResult>;
+    private importOneUnmanaged;
+    private importFresh;
+    importMany(requests: SessionImportRequest[], onProgress?: (result: SessionImportResult, index: number) => void, options?: SessionImportOptions): Promise<SessionImportResult[]>;
+    private persistConverted;
+}

package/dist/services/session-import/types.d.ts

@@ -0,0 +1,87 @@
+import type * as LlmsProviders from "@cline/llms";
+/** External tools whose session history Cline can import. */
+export declare const SESSION_IMPORT_TOOLS: readonly ["claude-code", "codex", "opencode"];
+export type SessionImportTool = (typeof SESSION_IMPORT_TOOLS)[number];
+export declare const SESSION_IMPORT_TOOL_LABELS: Record<SessionImportTool, string>;
+/**
+ * A session found in an external tool's on-disk store, described with just
+ * enough metadata to render an import picker. Discovery must stay cheap; the
+ * full conversation is only parsed when the session is actually imported.
+ */
+export interface ImportableSessionSummary {
+    tool: SessionImportTool;
+    /** Stable identifier within the source tool's store. */
+    sourceId: string;
+    /** File (or database) the session was discovered in. */
+    sourcePath: string;
+    title: string;
+    /** Original working directory, when the source recorded one. */
+    cwd: string;
+    startedAtMs: number;
+    updatedAtMs: number;
+    /** Conversational user/assistant events (not raw store lines). */
+    messageCount: number;
+    /** First real user prompt, trimmed for display. */
+    preview?: string;
+    /** Set when a prior import of this source session already exists. */
+    alreadyImportedSessionId?: string;
+}
+/** A source session fully translated to Cline's native message format. */
+export interface ConvertedImportedSession {
+    tool: SessionImportTool;
+    sourceId: string;
+    sourcePath: string;
+    title: string;
+    /** First real user prompt (used for the session's prompt field). */
+    prompt?: string;
+    provider: string;
+    model: string;
+    cwd: string;
+    gitBranch?: string;
+    startedAtMs: number;
+    endedAtMs: number;
+    messages: LlmsProviders.MessageWithMetadata[];
+}
+export interface SessionImportAdapter {
+    readonly tool: SessionImportTool;
+    /** Whether the tool's session store exists on this machine. */
+    isInstalled(): boolean;
+    discover(): ImportableSessionSummary[];
+    /** Throws if the source session cannot be found or parsed. */
+    convert(sourceId: string): ConvertedImportedSession;
+    /**
+     * Releases per-batch caches (file indexes, database snapshots). Called by
+     * the service after each discover/import batch; adapters stay usable after.
+     */
+    dispose?(): void;
+}
+export interface SessionImportRequest {
+    tool: SessionImportTool;
+    sourceId: string;
+}
+export interface SessionImportOptions {
+    /**
+     * Cline provider/model the imported sessions should resume with. Opening a
+     * history session adopts the row's provider/model, so without this the
+     * session would try to run on the source tool's provider (openai-native,
+     * or an opencode provider id Cline doesn't know) which the user may never
+     * have configured. Both must be set to take effect; the source tool's own
+     * provider/model are always preserved in metadata.importedFrom and in
+     * per-message modelInfo.
+     */
+    provider?: string;
+    model?: string;
+}
+export interface SessionImportResult {
+    tool: SessionImportTool;
+    sourceId: string;
+    ok: boolean;
+    /** Cline session id created for this import (on success). */
+    sessionId?: string;
+    title?: string;
+    error?: string;
+    /** Set when the source session had already been imported; sessionId is
+     * the existing Cline session and nothing new was written. */
+    alreadyImported?: boolean;
+}
+export declare function truncateForDisplay(value: string | undefined, max?: number): string | undefined;

package/dist/services/workspace/agent-schedules-workspace.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ensure the home workspace for agent-created schedules exists and return its
+ * path. Agent-created schedules are user-level routines: they anchor (and
+ * their unattended sessions run) in `~/.cline/schedules/` instead of
+ * inheriting whichever chat workspace happened to create them, so they
+ * survive chat cleanup and stay in one predictable scope.
+ */
+export declare function ensureAgentSchedulesWorkspace(): Promise<string>;

package/dist/services/workspace/index.d.ts

@@ -1,3 +1,4 @@
+export { ensureAgentSchedulesWorkspace } from "./agent-schedules-workspace";
 export { ensureChatWorkspace } from "./chat-workspace";
 export type { FastFileIndexOptions } from "./file-indexer";
 export { getFileIndex, prewarmFileIndex } from "./file-indexer";

package/dist/session/models/session-manifest.d.ts

@@ -12,8 +12,8 @@ export declare const SessionManifestSchema: z.ZodObject<{
         completed: "completed";
         idle: "idle";
         running: "running";
-        pending: "pending";
         cancelled: "cancelled";
+        pending: "pending";
     }>;
     interactive: z.ZodBoolean;
     provider: z.ZodString;

package/dist/session/models/session-row.d.ts

@@ -69,6 +69,16 @@ export interface CreateRootSessionWithArtifactsInput {
     prompt?: string;
     metadata?: Record<string, unknown>;
     startedAt?: string;
+    /**
+     * Create the session already in a terminal state (defaults to "running").
+     * Sessions that are pure history from birth — imports — use this so they
+     * never pass through a transient running/pid-0 state that the
+     * stale-session reconciler (in any process sharing the DB) could flip to
+     * failed before the creator finishes writing.
+     */
+    status?: SessionStatus;
+    endedAt?: string;
+    exitCode?: number;
 }
 export interface RootSessionArtifacts {
     manifestPath: string;

package/dist/session/search/index.d.ts

@@ -0,0 +1 @@
+export * from "./session-history-search";

package/dist/session/search/session-history-search.d.ts

@@ -0,0 +1,51 @@
+import type { RuntimeHost } from "../../runtime/host/runtime-host";
+export interface SessionSearchInput {
+    query: string;
+    limit?: number;
+    workspaceRoot?: string;
+}
+export interface SessionSearchHit {
+    sessionId: string;
+    documentId: string;
+    ordinal: number;
+    role: string;
+    startedAt: string;
+    workspaceRoot: string;
+    title: string;
+    snippet: string;
+    score: number;
+}
+export interface SessionHistorySearchOptions {
+    dbPath?: string;
+    reconcileIntervalMs?: number;
+}
+export declare class SessionHistorySearchService {
+    private readonly host;
+    private readonly db;
+    private readonly initializationError;
+    private readonly intervalMs;
+    private readonly removedDuringRefresh;
+    private readonly failedEvictionSessionIds;
+    private timer;
+    private refreshPromise;
+    private readyPromise;
+    constructor(host: Pick<RuntimeHost, "listSessions" | "readSessionMessages">, options?: SessionHistorySearchOptions);
+    start(): void;
+    dispose(): Promise<void>;
+    refreshNow(): Promise<void>;
+    /**
+     * Removes one session from the derived index without scanning canonical
+     * history. The temporary tombstone prevents an in-flight reconciliation
+     * that captured the session before deletion from writing it back.
+     */
+    removeSession(sessionId: string): void;
+    waitUntilReady(): Promise<void>;
+    isAvailable(): boolean;
+    getInitializationError(): unknown | undefined;
+    search(input: SessionSearchInput): SessionSearchHit[];
+    private isSessionSuppressed;
+    private reconcile;
+    private sourceRevision;
+    private indexSession;
+    private deleteIndexedSession;
+}

package/dist/session/services/persistence-service.d.ts

@@ -56,6 +56,16 @@ export declare class UnifiedSessionPersistenceService {
     private isPidAlive;
     private reconcileDeadRunningSession;
     listSessions(limit?: number): Promise<SessionRow[]>;
+    /**
+     * Lightweight, effectively unbounded listing of session ids + metadata
+     * (no manifest reads, no dead-session reconciliation). listSessions caps
+     * its scan at 2000 rows; callers that must see every row — e.g. import
+     * dedup markers — use this instead.
+     */
+    listSessionMetadata(limit?: number): Promise<Array<{
+        sessionId: string;
+        metadata?: Record<string, unknown>;
+    }>>;
     reconcileDeadSessions(limit?: number): Promise<number>;
     deleteSession(sessionId: string): Promise<{
         deleted: boolean;

package/dist/tasks/agenda-task-tool.d.ts

@@ -48,8 +48,8 @@ export declare const TodoTaskInputSchema: z.ZodObject<{
     statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         failed: "failed";
         completed: "completed";
-        in_progress: "in_progress";
         cancelled: "cancelled";
+        in_progress: "in_progress";
         approved: "approved";
         pending_approval: "pending_approval";
         expired: "expired";

package/dist/tasks/task-tool.d.ts

@@ -3,9 +3,9 @@ import { z } from "zod";
 import { type ScheduledTaskResult, type ScheduleTaskOperationOptions } from "../cron/service/schedule-tool";
 import { type TodoTaskOperationOptions, type TodoTaskResult } from "./agenda-task-tool";
 export declare const TASKS_TOOL_NAME = "tasks";
-export declare const TASKS_SYSTEM_PROMPT_RULE = "# Tasks\n\nUse the `tasks` tool to manage durable Todo items and explicitly requested scheduled agent work.\n\n- Use `kind: \"todo\"` for meaningful follow-ups, handoffs, ideas, reminders, and other work that should remain visible after this session. This includes useful work you identify and suggest proactively. Agent-created Todos require user approval; Todos created directly by the user are approved immediately. Todo `available_at` controls availability in the list; it never schedules execution.\n- Use `kind: \"scheduled\"` only when the user explicitly asks Cline to execute work once at a future time or on a recurrence. One-time schedules require an exact future ISO 8601 `run_at` with an offset or Z. Recurring schedules require a five-field `cron_pattern` and may include an IANA `timezone`.\n- \"Remind me\" is ambiguous: ask whether the user wants a reviewed Todo note or an agent to execute work at that time when intent is unclear.\n- Never create both kinds for the same request unless the user explicitly requests both. Check existing items before creating a likely duplicate.\n- Todo instructions and scheduled prompts must be self-contained. Include the goal, constraints, relevant project context, and expected output.\n- Never approve or start a Todo yourself. Only mutate schedules from an interactive user session, and only update, pause, resume, delete, or run one immediately when the user asks.";
+export declare const TASKS_SYSTEM_PROMPT_RULE = "# Tasks\n\nUse the `tasks` tool to manage durable Todo items and explicitly requested scheduled agent work.\n\n- Use `kind: \"todo\"` for meaningful follow-ups, handoffs, ideas, reminders, and other work that should remain visible after this session. This includes useful work you identify and suggest proactively. Agent-created Todos require user approval; Todos created directly by the user are approved immediately. Todo `available_at` controls availability in the list; it never schedules execution.\n- Use `kind: \"scheduled\"` only when the user explicitly asks Cline to execute work once at a future time or on a recurrence. One-time schedules require an exact future ISO 8601 `run_at` with an offset or Z. Recurring schedules require a five-field `cron_pattern` and may include an IANA `timezone`.\n- \"Remind me\" is ambiguous: ask whether the user wants a reviewed Todo note or an agent to execute work at that time when intent is unclear.\n- Never create both kinds for the same request unless the user explicitly requests both. Check existing items before creating a likely duplicate.\n- Todo instructions and scheduled prompts must be self-contained. Include the goal, constraints, relevant project context, and expected output.\n- Scheduled sessions run in the user's schedules home workspace, not this conversation's folder. Include absolute paths in the scheduled `prompt` for any project files or repositories the work must touch.\n- Never approve or start a Todo yourself. Only mutate schedules from an interactive user session, and only update, pause, resume, delete, or run one immediately when the user asks.";
 /** Guidance used while the Todo kind is disabled and only schedules remain. */
-export declare const SCHEDULED_TASKS_SYSTEM_PROMPT_RULE = "# Tasks\n\nUse the `tasks` tool only when the user explicitly asks Cline to execute work once at a future time or on a recurrence. Always pass `kind: \"scheduled\"`.\n\n- One-time schedules require an exact future ISO 8601 `run_at` with an offset or Z. Recurring schedules require a five-field `cron_pattern` and may include an IANA `timezone`.\n- Never create a schedule proactively. Check existing schedules before creating a likely duplicate.\n- Make the scheduled `prompt` self-contained because it runs in a new unattended session. Include the goal, constraints, relevant project context, and expected output.\n- Only update, pause, resume, delete, or run a schedule immediately when the user asks for that action.";
+export declare const SCHEDULED_TASKS_SYSTEM_PROMPT_RULE = "# Tasks\n\nUse the `tasks` tool only when the user explicitly asks Cline to execute work once at a future time or on a recurrence. Always pass `kind: \"scheduled\"`.\n\n- One-time schedules require an exact future ISO 8601 `run_at` with an offset or Z. Recurring schedules require a five-field `cron_pattern` and may include an IANA `timezone`.\n- Never create a schedule proactively. Check existing schedules before creating a likely duplicate.\n- Make the scheduled `prompt` self-contained because it runs in a new unattended session in the user's schedules home workspace, not this conversation's folder. Include the goal, constraints, expected output, and absolute paths for any project files or repositories the work must touch.\n- Only update, pause, resume, delete, or run a schedule immediately when the user asks for that action.";
 export declare const TasksToolInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     operation: z.ZodEnum<{
         update: "update";
@@ -53,8 +53,8 @@ export declare const TasksToolInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         failed: "failed";
         completed: "completed";
-        in_progress: "in_progress";
         cancelled: "cancelled";
+        in_progress: "in_progress";
         approved: "approved";
         pending_approval: "pending_approval";
         expired: "expired";

package/dist/types/chat-schema.d.ts

@@ -25,8 +25,8 @@ export declare const ChatSessionStatusSchema: z.ZodEnum<{
     completed: "completed";
     idle: "idle";
     running: "running";
-    pending: "pending";
     cancelled: "cancelled";
+    pending: "pending";
     starting: "starting";
     stopping: "stopping";
 }>;
@@ -107,8 +107,8 @@ export declare const ChatViewStateSchema: z.ZodObject<{
         completed: "completed";
         idle: "idle";
         running: "running";
-        pending: "pending";
         cancelled: "cancelled";
+        pending: "pending";
         starting: "starting";
         stopping: "stopping";
     }>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cline/core",
 	"description": "Cline Core SDK for Node Runtime",
-	"version": "0.0.81",
+	"version": "0.0.82",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/cline/cline",
@@ -49,9 +49,9 @@
 		"test:watch": "vitest --config vitest.config.ts"
 	},
 	"dependencies": {
-		"@cline/agents": "0.0.81",
-		"@cline/shared": "0.0.81",
-		"@cline/llms": "0.0.81",
+		"@cline/agents": "0.0.82",
+		"@cline/shared": "0.0.82",
+		"@cline/llms": "0.0.82",
 		"@modelcontextprotocol/sdk": "^1.29.0",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/api-logs": "^0.214.0",