@cerebriline/core 4.100.240

package/dist/types/events.d.ts

@@ -0,0 +1,102 @@
+import type { CoreSessionSnapshot } from "../session/session-snapshot";
+export interface SessionChunkEvent {
+    sessionId: string;
+    stream: "stdout" | "stderr" | "agent";
+    chunk: string;
+    ts: number;
+}
+export interface SessionEndedEvent {
+    sessionId: string;
+    reason: string;
+    ts: number;
+}
+export interface SessionToolEvent {
+    sessionId: string;
+    hookEventName: "tool_call" | "tool_result" | "agent_end" | "agent_error" | "session_shutdown";
+    agentId?: string;
+    conversationId?: string;
+    parentAgentId?: string;
+    iteration?: number;
+    toolName?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    ts?: string;
+}
+export interface SessionTeamProgressEvent {
+    sessionId: string;
+    teamName: string;
+    lifecycle: import("@cerebriline/shared").TeamProgressLifecycleEvent;
+    summary: import("@cerebriline/shared").TeamProgressSummary;
+    /**
+     * Every teammate, with what it has done: tool calls and compactions over
+     * its life and on its current (or last) task. What a teammate's row draws.
+     */
+    teammates?: import("@cerebriline/shared").TeamMemberSnapshot[];
+}
+export interface SessionPendingPrompt {
+    id: string;
+    prompt: string;
+    delivery: "queue" | "steer";
+    attachmentCount: number;
+    userImages?: string[];
+    userFiles?: string[];
+    /** `harness` when the runtime queued it, not the user. */
+    origin?: "user" | "harness";
+}
+export interface SessionPendingPromptsEvent {
+    sessionId: string;
+    prompts: SessionPendingPrompt[];
+}
+export interface SessionPendingPromptSubmittedEvent {
+    sessionId: string;
+    id: string;
+    prompt: string;
+    delivery: "queue" | "steer";
+    attachmentCount: number;
+    userImages?: string[];
+    userFiles?: string[];
+    /** `harness` when the runtime queued it, not the user. */
+    origin?: "user" | "harness";
+}
+export interface SessionSnapshotEvent {
+    sessionId: string;
+    snapshot: CoreSessionSnapshot;
+}
+export type CoreSessionEvent = {
+    type: "chunk";
+    payload: SessionChunkEvent;
+} | {
+    type: "agent_event";
+    payload: {
+        sessionId: string;
+        event: import("@cerebriline/shared").AgentEvent;
+        /** Identifies the named agent within the team (e.g. "educator", "assessor", "coordinator") for both lead and teammate agents */
+        teamAgentId?: string;
+        /** Whether this is the lead agent or a teammate */
+        teamRole?: "lead" | "teammate";
+    };
+} | {
+    type: "team_progress";
+    payload: SessionTeamProgressEvent;
+} | {
+    type: "pending_prompts";
+    payload: SessionPendingPromptsEvent;
+} | {
+    type: "pending_prompt_submitted";
+    payload: SessionPendingPromptSubmittedEvent;
+} | {
+    type: "session_snapshot";
+    payload: SessionSnapshotEvent;
+} | {
+    type: "ended";
+    payload: SessionEndedEvent;
+} | {
+    type: "hook";
+    payload: SessionToolEvent;
+} | {
+    type: "status";
+    payload: {
+        sessionId: string;
+        status: string;
+    };
+};

package/dist/types/provider-settings.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { type ProviderClient, type ProviderConfig, type ProviderProtocol, type ProviderSettings, type ToProviderConfigOptions, toProviderConfig } from "../services/llms/provider-settings";
+export type { ProviderClient, ProviderConfig, ProviderProtocol, ProviderSettings, ToProviderConfigOptions, };
+export declare const ProviderSettingsSchemaTyped: z.ZodType<ProviderSettings>;
+export { toProviderConfig };
+export type ProviderTokenSource = "manual" | "oauth" | "migration";
+export declare const VoiceInputSettingsSchema: z.ZodObject<{
+    providerId: z.ZodString;
+    modelId: z.ZodString;
+}, z.core.$strip>;
+export type VoiceInputSettings = z.infer<typeof VoiceInputSettingsSchema>;
+export interface StoredProviderModes {
+    voiceInput?: VoiceInputSettings;
+}
+export interface StoredProviderSettingsEntry {
+    settings: ProviderSettings;
+    updatedAt: string;
+    tokenSource: ProviderTokenSource;
+}
+export interface StoredProviderSettings {
+    version: 1;
+    lastUsedProvider?: string;
+    modes: StoredProviderModes;
+    providers: Record<string, StoredProviderSettingsEntry>;
+}
+export declare const StoredProviderModesSchema: z.ZodType<StoredProviderModes>;
+export declare const StoredProviderSettingsEntrySchema: z.ZodType<StoredProviderSettingsEntry>;
+export declare const StoredProviderSettingsSchema: z.ZodType<StoredProviderSettings>;
+export declare function emptyStoredProviderSettings(): StoredProviderSettings;

package/dist/types/session.d.ts

@@ -0,0 +1,187 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { AgentFinishReason } from "@cerebriline/shared";
+import type { RevisionLog } from "../runtime/atomic/file-revisions";
+import type { AtomicProtocolSession } from "../runtime/atomic/session-protocol";
+import type { EscalationSession } from "../runtime/escalation/escalation-session";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+import type { BuiltRuntime } from "../runtime/orchestration/session-runtime";
+import type { SessionRuntime } from "../runtime/orchestration/session-runtime-orchestrator";
+import type { SessionCompactionState } from "../session/models/session-compaction";
+import type { SessionRow } from "../session/models/session-row";
+import type { RootSessionArtifacts } from "../session/services/session-service";
+import type { SessionSource, SessionStatus } from "./common";
+import type { CoreAgentMode, CoreSessionConfig } from "./config";
+export type ActiveSession = {
+    sessionId: string;
+    config: CoreSessionConfig;
+    sessionMetadata?: Record<string, unknown>;
+    artifacts?: RootSessionArtifacts;
+    source: SessionSource;
+    startedAt: string;
+    updatedAt: string;
+    status: SessionStatus;
+    endedAt?: string | null;
+    exitCode?: number | null;
+    pendingPrompt?: string;
+    runtime: BuiltRuntime;
+    /**
+     * The session's own file-revision log, exposed so a delegated agent's changes
+     * can be handed back into it as new revisions (`#N`) the lead can inspect and
+     * adopt. The same log the change protocol and compaction share; held here
+     * because the hand-back happens from the spawn tool's lifecycle callback,
+     * which reaches the session only through `getSession`.
+     */
+    revisionLog?: RevisionLog;
+    agent: SessionRuntime;
+    started: boolean;
+    aborting: boolean;
+    interactive: boolean;
+    persistedMessages?: LlmsProviders.MessageWithMetadata[];
+    compactionState?: SessionCompactionState;
+    compactionStateWriteQueue?: Promise<void>;
+    activeTeamRunIds: Set<string>;
+    pendingTeamRunUpdates: TeamRunUpdate[];
+    teamRunWaiters: Array<() => void>;
+    pendingPrompts: PendingPrompt[];
+    /**
+     * The change protocol this session is running under, when it is armed.
+     *
+     * Held on the session because the rules go out with the user's own message:
+     * the turn that delivers them is prepared long after the session was built.
+     */
+    atomicProtocol?: AtomicProtocolSession;
+    /**
+     * The escalation path, when an expert is configured.
+     *
+     * Held here for the same reason the protocol is: it outlives the turn that
+     * built it. A held expert conversation has to be released when the task
+     * ends, whatever the hold setting says, or a local server keeps a slot
+     * booked for a session nothing can reach.
+     */
+    escalation?: EscalationSession;
+    /**
+     * Whether the protocol engaged, waiting for a turn to be said on.
+     *
+     * Not said when it is decided, which is inside `startSession`. A host that
+     * routes events to the session it currently has open has no such session at
+     * that moment: the VS Code extension compares the event's id against its
+     * active session, finds none, and drops it as stale one line before it
+     * would have become a chat row. Measured that way on first live use — the
+     * protocol was running, the rules were in the prompt, and the chat said
+     * nothing at all. So the message waits for the first turn, where every
+     * other event of the session is delivered, and goes out once.
+     */
+    pendingAtomicStatus?: {
+        armed: boolean;
+        message: string;
+    };
+    drainingPendingPrompts: boolean;
+    pluginSandboxShutdown?: () => Promise<void>;
+    /** Hand back and dispose every delegated agent's workspace still open. */
+    delegatedSandboxesShutdown?: () => Promise<void>;
+    turnUsageBaseline?: SessionAccumulatedUsage;
+    turnAggregateUsageBaseline?: SessionAccumulatedUsage;
+    turnPrimaryUsage?: SessionAccumulatedUsage;
+    turnUsageByAgent?: Map<string, SessionAccumulatedUsage>;
+    lastInteractiveTurnFinishReason?: AgentFinishReason;
+    /**
+     * Set to `true` once the assistant successfully invoked the canonical
+     * completion tool (`submit_and_exit`) for this session. Used to:
+     *
+     * 1. Emit `task.completed` exactly once at the moment the assistant
+     *    declares completion (parity with original Cline's
+     *    `attempt_completion`).
+     * 2. Suppress the fallback `task.completed` emission from
+     *    `emitTaskCompletedOnTeardown(...)` so the same logical completion
+     *    is not reported twice.
+     *
+     * Non-interactive sessions that finish without ever calling the
+     * completion tool still receive a `task.completed` from the teardown
+     * fallback.
+     */
+    submitAndExitObserved: boolean;
+    /**
+     * Set to `true` the moment `task.completed` is emitted for this session,
+     * whether by the `submit_and_exit` observer or by the teardown fallback
+     * (`emitTaskCompletedOnTeardown`). Enforces the invariant of exactly one
+     * `task.completed` per session regardless of which teardown path runs.
+     */
+    taskCompletedEmitted: boolean;
+};
+export type PendingPrompt = {
+    id: string;
+    prompt: string;
+    mode?: CoreAgentMode;
+    delivery: "queue" | "steer";
+    userImages?: string[];
+    userFiles?: string[];
+};
+export type TeamRunUpdate = {
+    runId: string;
+    agentId: string;
+    taskId?: string;
+    status: "completed" | "failed" | "cancelled" | "interrupted";
+    error?: string;
+    iterations?: number;
+};
+export type StoredMessageWithMetadata = LlmsProviders.MessageWithMetadata;
+export type PreparedTurnInput = {
+    prompt: string;
+    userImages?: string[];
+    userFiles?: string[];
+};
+export interface PersistedSessionUpdateInput {
+    sessionId: string;
+    expectedStatusLock?: number;
+    status?: SessionStatus;
+    /**
+     * The process that owns the session from now on.
+     *
+     * Set when a session becomes live again in a process other than the one that
+     * created it (a resumed task after the host restarted). The stale-session
+     * reconciler decides a session is dead by testing this pid, so a row that
+     * keeps a dead pid is declared failed on every scan no matter how alive it
+     * is.
+     */
+    pid?: number;
+    endedAt?: string | null;
+    exitCode?: number | null;
+    prompt?: string | null;
+    metadata?: Record<string, unknown> | null;
+    title?: string | null;
+    parentSessionId?: string | null;
+    parentAgentId?: string | null;
+    agentId?: string | null;
+    conversationId?: string | null;
+    setRunning?: boolean;
+}
+export interface SessionPersistenceAdapter {
+    ensureSessionsDir(): string;
+    upsertSession(row: SessionRow): Promise<void>;
+    getSession(sessionId: string): Promise<SessionRow | undefined>;
+    listSessions(options: {
+        limit: number;
+        parentSessionId?: string;
+        status?: string;
+    }): Promise<SessionRow[]>;
+    updateSession(input: PersistedSessionUpdateInput): Promise<{
+        updated: boolean;
+        statusLock: number;
+    }>;
+    deleteSession(sessionId: string, cascade: boolean): Promise<boolean>;
+    enqueueSpawnRequest(input: {
+        rootSessionId: string;
+        parentAgentId: string;
+        task?: string;
+        systemPrompt?: string;
+    }): Promise<void>;
+    claimSpawnRequest(rootSessionId: string, parentAgentId: string): Promise<string | undefined>;
+}
+export interface SessionMessagesArtifactUploader {
+    uploadMessagesFile(input: {
+        sessionId: string;
+        path: string;
+        contents: string;
+        row?: SessionRow;
+    }): Promise<void>;
+}

package/dist/types/sessions.d.ts

@@ -0,0 +1,42 @@
+import type { SessionLineage, SessionRuntimeRecordShape } from "@cerebriline/shared";
+import type { SessionSource, SessionStatus } from "./common";
+export interface SessionUsageMetadata {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    totalCost: number;
+}
+export interface SessionRef extends SessionLineage {
+    sessionId: string;
+}
+export interface SessionRecord extends SessionRef, Omit<SessionRuntimeRecordShape, "source" | "status"> {
+    source: SessionSource;
+    status: SessionStatus;
+}
+export interface SessionHistoryMetadata extends Record<string, unknown> {
+    title?: string;
+    git?: {
+        url?: string;
+        branch?: string;
+    };
+    totalCost?: number;
+    aggregatedAgentsCost?: number;
+    usage?: SessionUsageMetadata;
+    aggregateUsage?: SessionUsageMetadata;
+    checkpoint?: {
+        latest?: {
+            ref?: string;
+            createdAt?: number;
+            runCount?: number;
+        };
+        history?: Array<{
+            ref?: string;
+            createdAt?: number;
+            runCount?: number;
+        }>;
+    };
+}
+export interface SessionHistoryRecord extends Omit<SessionRecord, "metadata"> {
+    metadata?: SessionHistoryMetadata;
+}

package/dist/types/storage.d.ts

@@ -0,0 +1,36 @@
+import type { TeamRuntimeState, TeamTeammateSpec } from "@cerebriline/shared";
+import type { TeamEvent } from "../extensions/tools/team";
+import type { SessionStatus } from "./common";
+import type { SessionRecord } from "./sessions";
+export interface SessionStore {
+    init(): Promise<void> | void;
+    create(record: SessionRecord): Promise<void> | void;
+    updateStatus(sessionId: string, status: SessionStatus, exitCode?: number | null): Promise<void> | void;
+    update(record: Partial<SessionRecord> & {
+        sessionId: string;
+    }): Promise<void> | void;
+    get(sessionId: string): Promise<SessionRecord | undefined> | SessionRecord | undefined;
+    list(limit?: number): Promise<SessionRecord[]> | SessionRecord[];
+    delete(sessionId: string, cascade?: boolean): Promise<boolean> | boolean;
+}
+export interface TeamStore {
+    listTeamNames(): Promise<string[]> | string[];
+    readState(teamName: string): Promise<TeamRuntimeState | undefined> | TeamRuntimeState | undefined;
+    readHistory(teamName: string, limit?: number): Promise<unknown[]> | unknown[];
+    loadRuntime(teamName: string): Promise<{
+        state?: TeamRuntimeState;
+        teammates: TeamTeammateSpec[];
+        interruptedRunIds: string[];
+    }> | {
+        state?: TeamRuntimeState;
+        teammates: TeamTeammateSpec[];
+        interruptedRunIds: string[];
+    };
+    handleTeamEvent(teamName: string, event: TeamEvent): Promise<void> | void;
+    persistRuntime(teamName: string, state: TeamRuntimeState, teammates: TeamTeammateSpec[]): Promise<void> | void;
+    markInProgressRunsInterrupted(teamName: string, reason: string): Promise<string[]> | string[];
+}
+export interface ArtifactStore {
+    appendHook(sessionId: string, payload: unknown): Promise<void> | void;
+    writeMessages(sessionId: string, messages: unknown[]): Promise<void> | void;
+}

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+export type { AgentRunResult, AgentRunStatus, FeatureFlag, FeatureFlagPayload, FeatureFlagsAndPayloads, FeatureFlagsContext, FeatureFlagsSettings, IFeatureFlagsProvider, WorkspaceInfo, WorkspaceManifest, } from "@cerebriline/shared";
+export { FEATURE_FLAGS, FeatureFlagDefaultValue, } from "@cerebriline/shared";
+export { ClineCore } from "./ClineCore";
+export type { ClineCoreListHistoryOptions, ClineCoreOptions, ClineCoreStartInput, HubOptions, RemoteOptions, } from "./cline-core/types";
+export type { AgentPluginPackageDiagnostic, AgentPluginPackageDiagnosticScope, AgentPluginPackageLoadReport, AgentPluginPackageManifest, AgentPluginPackageMcpServer, AgentPluginPackageSkill, AgentSkillMetadata, LoadAgentPluginFromPathOptions, LoadAgentPluginPackagesOptions, LoadedAgentPluginPackage, ParsedAgentSkill, ResolveAgentPluginPathsOptions, } from "./extensions";
+export { AGENT_PLUGINS_V1_MANIFEST_SCHEMA, AGENT_PLUGINS_V1_MCP_SCHEMA, discoverPluginModulePaths, loadAgentPluginFromPath, loadAgentPluginPackages, loadAgentPluginsFromPaths, parseAgentSkillMarkdown, resolveAgentPluginPaths, resolveAndLoadAgentPlugins, resolvePluginConfigSearchPaths, resolvePluginSkillDirectoriesFromPaths, } from "./extensions";
+export type { CreateInstructionWatcherOptions, CreateRulesConfigDefinitionOptions, CreateSkillsConfigDefinitionOptions, CreateUserInstructionConfigServiceOptions, CreateWorkflowsConfigDefinitionOptions, ParseMarkdownFrontmatterResult, RuleConfig, SkillConfig, UnifiedConfigDefinition, UnifiedConfigFileCandidate, UnifiedConfigFileContext, UnifiedConfigRecord, UnifiedConfigWatcherEvent, UnifiedConfigWatcherOptions, UserInstructionConfig, UserInstructionConfigRecord, UserInstructionConfigService, UserInstructionConfigType, WorkflowConfig, } from "./extensions/config";
+export { combineUserInstructionConfigServices, createRulesConfigDefinition, createSkillsConfigDefinition, createUserInstructionConfigService, createWorkflowsConfigDefinition, parseRuleConfigFromMarkdown, parseSkillConfigFromMarkdown, parseWorkflowConfigFromMarkdown, RULES_CONFIG_DIRECTORY_NAME, resolveRulesConfigSearchPaths, resolveSkillsConfigSearchPaths, resolveWorkflowsConfigSearchPaths, SKILLS_CONFIG_DIRECTORY_NAME, UnifiedConfigFileWatcher, WORKFLOWS_CONFIG_DIRECTORY_NAME, } from "./extensions/config";
+export type { BuiltinToolAvailabilityContext, ToolCatalogEntry, ToolClientType, } from "./extensions/tools";
+export { getCoreAcpToolNames, getCoreBuiltinToolCatalog, getCoreDefaultEnabledToolIds, getCoreHeadlessToolNames, resolveCoreSelectedToolIds, TEAM_TOOL_NAMES, } from "./extensions/tools";
+export type { RuntimeCapabilities } from "./runtime/capabilities";
+export type { SessionBackend } from "./runtime/host/host";
+export type { PendingPromptMutationResult, PendingPromptsDeleteInput, PendingPromptsListInput, PendingPromptsRuntimeService, PendingPromptsServiceApi, PendingPromptsUpdateInput, RuntimeHost, RuntimeHost as SessionHost, RuntimeHostMode, SendSessionInput, SessionAccumulatedUsage, SessionUsageSummary, StartSessionInput, StartSessionResult, } from "./runtime/host/runtime-host";
+export type { BuiltRuntime as RuntimeEnvironment, RuntimeBuilder, RuntimeBuilderInput, SessionRuntime, } from "./runtime/orchestration/session-runtime";
+export type { SandboxCallOptions, SubprocessSandboxOptions, } from "./runtime/tools/subprocess-sandbox";
+export { SubprocessSandbox } from "./runtime/tools/subprocess-sandbox";
+export { FeatureFlagsService, type FeatureFlagsServiceOptions, NoOpFeatureFlagsProvider, } from "./services/feature-flags";
+export type { GlobalCompactionMode, GlobalCompactionStrategy, GlobalPlanActMode, GlobalSettings, } from "./services/global-settings";
+export { filterDisabledPluginPaths, filterDisabledTools, filterExtensionToolRegistrations, GlobalSettingsSchema, isAgentPluginDisabledGlobally, isAutoUpdateEnabledGlobally, isModelToolEnabledGlobally, isPluginDisabledGlobally, isTelemetryOptedOutGlobally, isToolDisabledGlobally, readCompactionModeGlobally, readCompactionStrategyGlobally, readGlobalSettings, readPlanActModeGlobally, readToolAutoApproveGlobally, resolveDisabledAgentPluginNames, resolveDisabledPluginPaths, resolveDisabledToolNames, resolveModelToolSettings, setAutoUpdateEnabledGlobally, setCompactionModeGlobally, setCompactionStrategyGlobally, setDisabledAgentPlugin, setDisabledPlugin, setDisabledTools, setModelToolEnabledGlobally, setPlanActModeGlobally, setTelemetryOptOutGlobally, setToolAutoApproveGlobally, toggleDisabledTool, writeGlobalSettings, } from "./services/global-settings";
+export type { ListPluginToolsResult, PluginToolSummary, } from "./services/plugin-tools";
+export { listPluginTools, listPluginToolsWithDiagnostics, } from "./services/plugin-tools";
+export type { WorkspaceManager, WorkspaceManagerEvent, } from "./services/workspace/workspace-manager";
+export type { SessionManifest } from "./session/models/session-manifest";
+export type { SessionRow } from "./session/models/session-row";
+export type { CreateRootSessionWithArtifactsInput, RootSessionArtifacts, } from "./session/services/session-service";
+export type { CoreSessionCheckpointSnapshot, CoreSessionSnapshot, } from "./session/session-snapshot";
+export type { SessionCheckpointRestoreContext, SessionCheckpointRestoreResult, SessionVersioningErrorCode, } from "./session/session-versioning-service";
+export type { ChatMessage, ChatSessionConfig, ChatSessionStatus, ChatSummary, ChatViewState, } from "./types/chat-schema";
+export type { SessionSource, SessionStatus } from "./types/common";
+export type { CoreAgentMode, CoreModelConfig, CoreRuntimeFeatures, CoreSessionConfig, } from "./types/config";
+export type { CoreSessionEvent, SessionChunkEvent, SessionEndedEvent, SessionPendingPrompt, SessionPendingPromptSubmittedEvent, SessionPendingPromptsEvent, SessionTeamProgressEvent, SessionToolEvent, } from "./types/events";
+export type { SessionMessagesArtifactUploader } from "./types/session";
+export type { SessionHistoryMetadata, SessionHistoryRecord, SessionRecord, SessionRef, } from "./types/sessions";
+export type { ArtifactStore, SessionStore, TeamStore } from "./types/storage";

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const CORE_BUILD_VERSION: string;

package/package.json

@@ -0,0 +1,98 @@
+{
+	"name": "@cerebriline/core",
+	"description": "Cerebriline Core SDK for Node Runtime",
+	"version": "4.100.240",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/mann1x/cline.git",
+		"directory": "sdk/packages/core"
+	},
+	"type": "module",
+	"types": "./dist/index.d.ts",
+	"main": "./dist/index.js",
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./hub": {
+			"types": "./dist/hub/index.d.ts",
+			"import": "./dist/hub/index.js"
+		},
+		"./hub/daemon-entry": {
+			"types": "./dist/hub/daemon/entry.d.ts",
+			"import": "./dist/hub/daemon/entry.js"
+		},
+		"./telemetry": {
+			"types": "./dist/services/telemetry/index.d.ts",
+			"import": "./dist/services/telemetry/index.js"
+		},
+		"./services/feature-flags/posthog": {
+			"types": "./dist/services/feature-flags/posthog.d.ts",
+			"import": "./dist/services/feature-flags/posthog.js"
+		}
+	},
+	"dependencies": {
+		"@joplin/turndown-plugin-gfm": "1.0.68",
+		"@lingo-reader/epub-parser": "0.4.6",
+		"@lingo-reader/fb2-parser": "0.4.6",
+		"@lingo-reader/mobi-parser": "0.4.6",
+		"@modelcontextprotocol/sdk": "^1.29.0",
+		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/api-logs": "^0.214.0",
+		"@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
+		"@opentelemetry/exporter-metrics-otlp-http": "^0.214.0",
+		"@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
+		"@opentelemetry/resources": "^2.6.1",
+		"@opentelemetry/sdk-logs": "^0.214.0",
+		"@opentelemetry/sdk-metrics": "^2.6.1",
+		"@opentelemetry/sdk-trace-base": "^2.6.1",
+		"@opentelemetry/sdk-trace-node": "^2.6.1",
+		"@opentelemetry/semantic-conventions": "^1.40.0",
+		"@tesseract.js-data/eng": "1.0.0",
+		"cfb": "1.2.2",
+		"fast-png": "8.0.0",
+		"jiti": "^2.7.0",
+		"nanoid": "^5.1.7",
+		"node-machine-id": "^1.1.12",
+		"officeparser": "8.0.0",
+		"pdfjs-dist": "6.2.108",
+		"simple-git": "3.36.0",
+		"tesseract.js": "7.0.0",
+		"tree-sitter-wasms": "^0.1.12",
+		"turndown": "7.2.0",
+		"web-tree-sitter": "^0.25.0",
+		"ws": "^8.20.0",
+		"yaml": "^2.8.2",
+		"zod": "^4.3.6",
+		"@cerebriline/agents": "4.100.240",
+		"@cerebriline/llms": "4.100.240",
+		"@cerebriline/shared": "4.100.240"
+	},
+	"peerDependencies": {
+		"posthog-node": "^5.8.0"
+	},
+	"peerDependenciesMeta": {
+		"posthog-node": {
+			"optional": true
+		}
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"files": [
+		"assets",
+		"dist",
+		"scripts/document-reader-assets.mjs",
+		"!dist/**/*.d.ts.map"
+	],
+	"license": "Apache-2.0",
+	"homepage": "https://github.com/mann1x/cline/tree/main/sdk",
+	"bugs": {
+		"url": "https://github.com/mann1x/cline/issues"
+	}
+}