@clinebot/core 0.0.0 → 0.0.3

package/src/session/default-session-manager.ts

@@ -30,7 +30,7 @@ import {
 	mergeAgentHooks,
 } from "../runtime/hook-file-hooks";
 import { DefaultRuntimeBuilder } from "../runtime/runtime-builder";
-import type { BuiltRuntime, RuntimeBuilder } from "../runtime/session-runtime";
+import type { RuntimeBuilder } from "../runtime/session-runtime";
 import { ProviderSettingsManager } from "../storage/provider-settings-manager";
 import {
 	buildTeamProgressSummary,
@@ -53,6 +53,7 @@ import {
 import { nowIso } from "./session-artifacts";
 import type {
 	SendSessionInput,
+	SessionAccumulatedUsage,
 	SessionManager,
 	StartSessionInput,
 	StartSessionResult,
@@ -63,47 +64,26 @@ import type {
 	RootSessionArtifacts,
 	SessionRowShape,
 } from "./session-service";
+import {
+	extractWorkspaceMetadataFromSystemPrompt,
+	hasRuntimeHooks,
+	mergeAgentExtensions,
+	serializeAgentEvent,
+	toSessionRecord,
+	withLatestAssistantTurnMetadata,
+} from "./utils/helpers";
+import type {
+	ActiveSession,
+	PreparedTurnInput,
+	TeamRunUpdate,
+} from "./utils/types";
+import {
+	accumulateUsageTotals,
+	createInitialAccumulatedUsage,
+} from "./utils/usage";
 
 type SessionBackend = CoreSessionService | RpcCoreSessionService;
 
-type ActiveSession = {
-	sessionId: string;
-	config: CoreSessionConfig;
-	artifacts?: RootSessionArtifacts;
-	source: SessionSource;
-	startedAt: string;
-	pendingPrompt?: string;
-	runtime: BuiltRuntime;
-	agent: Agent;
-	started: boolean;
-	aborting: boolean;
-	interactive: boolean;
-	activeTeamRunIds: Set<string>;
-	pendingTeamRunUpdates: TeamRunUpdate[];
-	teamRunWaiters: Array<() => void>;
-	pluginSandboxShutdown?: () => Promise<void>;
-};
-
-type TeamRunUpdate = {
-	runId: string;
-	agentId: string;
-	taskId?: string;
-	status: "completed" | "failed" | "cancelled" | "interrupted";
-	error?: string;
-	iterations?: number;
-};
-
-type StoredMessageWithMetadata = LlmsProviders.MessageWithMetadata & {
-	providerId?: string;
-	modelId?: string;
-};
-
-type PreparedTurnInput = {
-	prompt: string;
-	userImages?: string[];
-	userFiles?: string[];
-};
-
 export interface DefaultSessionManagerOptions {
 	distinctId: string;
 	sessionService: SessionBackend;
@@ -136,134 +116,6 @@ async function loadUserFileContent(path: string): Promise<string> {
 	return content;
 }
 
-function hasRuntimeHooks(hooks: AgentConfig["hooks"]): boolean {
-	if (!hooks) {
-		return false;
-	}
-	return Object.values(hooks).some((value) => typeof value === "function");
-}
-
-function mergeAgentExtensions(
-	explicitExtensions: AgentConfig["extensions"] | undefined,
-	loadedExtensions: AgentConfig["extensions"] | undefined,
-): AgentConfig["extensions"] {
-	const merged = [...(explicitExtensions ?? []), ...(loadedExtensions ?? [])];
-	if (merged.length === 0) {
-		return undefined;
-	}
-	const deduped: NonNullable<AgentConfig["extensions"]> = [];
-	const seenNames = new Set<string>();
-	for (const extension of merged) {
-		if (seenNames.has(extension.name)) {
-			continue;
-		}
-		seenNames.add(extension.name);
-		deduped.push(extension);
-	}
-	return deduped;
-}
-
-function serializeAgentEvent(event: AgentEvent): string {
-	return JSON.stringify(event, (_key, value) => {
-		if (value instanceof Error) {
-			return {
-				name: value.name,
-				message: value.message,
-				stack: value.stack,
-			};
-		}
-		return value;
-	});
-}
-
-function withLatestAssistantTurnMetadata(
-	messages: LlmsProviders.Message[],
-	result: AgentResult,
-): StoredMessageWithMetadata[] {
-	const next = messages.map((message) => ({
-		...message,
-	})) as StoredMessageWithMetadata[];
-	const assistantIndex = [...next]
-		.reverse()
-		.findIndex((message) => message.role === "assistant");
-	if (assistantIndex === -1) {
-		return next;
-	}
-
-	const targetIndex = next.length - 1 - assistantIndex;
-	const target = next[targetIndex];
-	const usage = result.usage;
-	next[targetIndex] = {
-		...target,
-		providerId: target.providerId ?? result.model.provider,
-		modelId: target.modelId ?? result.model.id,
-		modelInfo: target.modelInfo ?? {
-			id: result.model.id,
-			provider: result.model.provider,
-		},
-		metrics: {
-			...(target.metrics ?? {}),
-			inputTokens: usage.inputTokens,
-			outputTokens: usage.outputTokens,
-			cacheReadTokens: usage.cacheReadTokens,
-			cacheWriteTokens: usage.cacheWriteTokens,
-			cost: usage.totalCost,
-		},
-		ts: target.ts ?? result.endedAt.getTime(),
-	};
-	return next;
-}
-
-function toSessionRecord(row: SessionRowShape): SessionRecord {
-	const metadata =
-		typeof row.metadata_json === "string" && row.metadata_json.trim().length > 0
-			? (() => {
-					try {
-						const parsed = JSON.parse(row.metadata_json) as unknown;
-						if (
-							parsed &&
-							typeof parsed === "object" &&
-							!Array.isArray(parsed)
-						) {
-							return parsed as Record<string, unknown>;
-						}
-					} catch {
-						// Ignore malformed metadata payloads.
-					}
-					return undefined;
-				})()
-			: undefined;
-	return {
-		sessionId: row.session_id,
-		source: row.source as SessionSource,
-		pid: row.pid,
-		startedAt: row.started_at,
-		endedAt: row.ended_at ?? null,
-		exitCode: row.exit_code ?? null,
-		status: row.status,
-		interactive: row.interactive === 1,
-		provider: row.provider,
-		model: row.model,
-		cwd: row.cwd,
-		workspaceRoot: row.workspace_root,
-		teamName: row.team_name ?? undefined,
-		enableTools: row.enable_tools === 1,
-		enableSpawn: row.enable_spawn === 1,
-		enableTeams: row.enable_teams === 1,
-		parentSessionId: row.parent_session_id ?? undefined,
-		parentAgentId: row.parent_agent_id ?? undefined,
-		agentId: row.agent_id ?? undefined,
-		conversationId: row.conversation_id ?? undefined,
-		isSubagent: row.is_subagent === 1,
-		prompt: row.prompt ?? undefined,
-		metadata,
-		transcriptPath: row.transcript_path,
-		hookPath: row.hook_path,
-		messagesPath: row.messages_path ?? undefined,
-		updatedAt: row.updated_at ?? nowIso(),
-	};
-}
-
 export class DefaultSessionManager implements SessionManager {
 	private readonly sessionService: SessionBackend;
 	private readonly runtimeBuilder: RuntimeBuilder;
@@ -277,6 +129,7 @@ export class DefaultSessionManager implements SessionManager {
 	) => Promise<ToolApprovalResult>;
 	private readonly listeners = new Set<(event: CoreSessionEvent) => void>();
 	private readonly sessions = new Map<string, ActiveSession>();
+	private readonly usageBySession = new Map<string, SessionAccumulatedUsage>();
 
 	constructor(options: DefaultSessionManagerOptions) {
 		const homeDir = homedir();
@@ -319,10 +172,16 @@ export class DefaultSessionManager implements SessionManager {
 			baseUrl: config.baseUrl ?? settings.baseUrl,
 			headers: config.headers ?? settings.headers,
 			reasoning:
-				typeof config.thinking === "boolean"
+				typeof config.thinking === "boolean" ||
+				typeof config.reasoningEffort === "string"
 					? {
 							...(settings.reasoning ?? {}),
-							enabled: config.thinking,
+							...(typeof config.thinking === "boolean"
+								? { enabled: config.thinking }
+								: {}),
+							...(typeof config.reasoningEffort === "string"
+								? { effort: config.reasoningEffort }
+								: {}),
 						}
 					: settings.reasoning,
 		};
@@ -341,6 +200,7 @@ export class DefaultSessionManager implements SessionManager {
 			requestedSessionId.length > 0
 				? requestedSessionId
 				: `${Date.now()}_${nanoid(5)}`;
+		this.usageBySession.set(sessionId, createInitialAccumulatedUsage());
 		const sessionsDir =
 			((await this.invokeOptionalValue("ensureSessionsDir")) as
 				| string
@@ -440,8 +300,11 @@ export class DefaultSessionManager implements SessionManager {
 			knownModels: providerConfig.knownModels,
 			providerConfig,
 			thinking: effectiveConfig.thinking,
+			reasoningEffort:
+				effectiveConfig.reasoningEffort ?? providerConfig.reasoningEffort,
 			systemPrompt: effectiveConfig.systemPrompt,
 			maxIterations: effectiveConfig.maxIterations,
+			maxConsecutiveMistakes: effectiveConfig.maxConsecutiveMistakes,
 			tools,
 			hooks: effectiveHooks,
 			extensions: effectiveExtensions,
@@ -451,9 +314,22 @@ export class DefaultSessionManager implements SessionManager {
 			toolPolicies: input.toolPolicies ?? this.defaultToolPolicies,
 			requestToolApproval:
 				input.requestToolApproval ?? this.defaultRequestToolApproval,
+			onConsecutiveMistakeLimitReached:
+				effectiveConfig.onConsecutiveMistakeLimitReached,
 			completionGuard: runtime.completionGuard,
 			logger: runtime.logger ?? effectiveConfig.logger,
 			onEvent: (event: AgentEvent) => {
+				const liveSession = this.sessions.get(sessionId);
+				if (event.type === "usage" && liveSession?.turnUsageBaseline) {
+					this.usageBySession.set(
+						sessionId,
+						accumulateUsageTotals(liveSession.turnUsageBaseline, {
+							inputTokens: event.totalInputTokens,
+							outputTokens: event.totalOutputTokens,
+							totalCost: event.totalCost,
+						}),
+					);
+				}
 				this.emit({
 					type: "agent_event",
 					payload: {
@@ -541,6 +417,16 @@ export class DefaultSessionManager implements SessionManager {
 		}
 	}
 
+	async getAccumulatedUsage(
+		sessionId: string,
+	): Promise<SessionAccumulatedUsage | undefined> {
+		const usage = this.usageBySession.get(sessionId);
+		if (!usage) {
+			return undefined;
+		}
+		return { ...usage };
+	}
+
 	async abort(sessionId: string): Promise<void> {
 		const session = this.sessions.get(sessionId);
 		if (!session) {
@@ -578,6 +464,7 @@ export class DefaultSessionManager implements SessionManager {
 				});
 			}),
 		);
+		this.usageBySession.clear();
 	}
 
 	async get(sessionId: string): Promise<SessionRecord | undefined> {
@@ -598,6 +485,9 @@ export class DefaultSessionManager implements SessionManager {
 			"deleteSession",
 			sessionId,
 		);
+		if (result.deleted) {
+			this.usageBySession.delete(sessionId);
+		}
 		return result.deleted;
 	}
 
@@ -709,28 +599,50 @@ export class DefaultSessionManager implements SessionManager {
 		const shouldContinue =
 			session.started || session.agent.getMessages().length > 0;
 		const baselineMessages = session.agent.getMessages();
-		const result = shouldContinue
-			? await this.runWithAuthRetry(
-					session,
-					() => session.agent.continue(prompt, userImages, userFiles),
-					baselineMessages,
-				)
-			: await this.runWithAuthRetry(
-					session,
-					() => session.agent.run(prompt, userImages, userFiles),
-					baselineMessages,
-				);
-		session.started = true;
-		const persistedMessages = withLatestAssistantTurnMetadata(
-			result.messages,
-			result,
-		);
-		await this.invoke<void>(
-			"persistSessionMessages",
-			session.sessionId,
-			persistedMessages,
-		);
-		return result;
+		const usageBaseline =
+			this.usageBySession.get(session.sessionId) ??
+			createInitialAccumulatedUsage();
+		session.turnUsageBaseline = usageBaseline;
+		try {
+			const result = shouldContinue
+				? await this.runWithAuthRetry(
+						session,
+						() => session.agent.continue(prompt, userImages, userFiles),
+						baselineMessages,
+					)
+				: await this.runWithAuthRetry(
+						session,
+						() => session.agent.run(prompt, userImages, userFiles),
+						baselineMessages,
+					);
+			session.started = true;
+			const persistedMessages = withLatestAssistantTurnMetadata(
+				result.messages,
+				result,
+			);
+			this.usageBySession.set(
+				session.sessionId,
+				accumulateUsageTotals(usageBaseline, result.usage),
+			);
+			await this.invoke<void>(
+				"persistSessionMessages",
+				session.sessionId,
+				persistedMessages,
+				session.config.systemPrompt,
+			);
+			return result;
+		} catch (error) {
+			// Persist whatever was rendered so far even when a turn fails.
+			await this.invoke<void>(
+				"persistSessionMessages",
+				session.sessionId,
+				session.agent.getMessages(),
+				session.config.systemPrompt,
+			);
+			throw error;
+		} finally {
+			session.turnUsageBaseline = undefined;
+		}
 	}
 
 	private async prepareTurnInput(
@@ -963,10 +875,15 @@ export class DefaultSessionManager implements SessionManager {
 		return createSpawnAgentTool({
 			providerId: config.providerId,
 			modelId: config.modelId,
+			cwd: config.cwd,
 			apiKey: config.apiKey,
 			baseUrl: config.baseUrl,
 			providerConfig: config.providerConfig,
 			knownModels: config.knownModels,
+			clineWorkspaceMetadata:
+				config.providerId === "cline"
+					? extractWorkspaceMetadataFromSystemPrompt(config.systemPrompt)
+					: undefined,
 			createSubAgentTools,
 			hooks: config.hooks,
 			extensions: config.extensions,
@@ -1039,6 +956,7 @@ export class DefaultSessionManager implements SessionManager {
 						event.agentId,
 						"failed",
 						`[error] ${event.error.message}`,
+						event.messages,
 					);
 					break;
 				}

package/src/session/index.ts

@@ -6,10 +6,15 @@ export {
 	makeTeamTaskSubSessionId,
 	sanitizeSessionToken,
 } from "./session-graph";
-export type { CreateSessionHostOptions, SessionHost } from "./session-host";
-export { createSessionHost } from "./session-host";
+export type {
+	CreateSessionHostOptions,
+	SessionBackend,
+	SessionHost,
+} from "./session-host";
+export { createSessionHost, resolveSessionBackend } from "./session-host";
 export type {
 	SendSessionInput,
+	SessionAccumulatedUsage,
 	SessionManager,
 	StartSessionInput,
 	StartSessionResult,

package/src/session/session-host.ts

@@ -6,7 +6,7 @@ import type {
 	ToolApprovalRequest,
 	ToolApprovalResult,
 } from "@clinebot/agents";
-import { getRpcServerHealth } from "@clinebot/rpc";
+import { getRpcServerDefaultAddress, getRpcServerHealth } from "@clinebot/rpc";
 import { resolveSessionDataDir } from "@clinebot/shared/storage";
 import { nanoid } from "nanoid";
 import type { ToolExecutors } from "../default-tools";
@@ -17,9 +17,9 @@ import type { SessionManager } from "./session-manager";
 import { CoreSessionService } from "./session-service";
 
 const DEFAULT_RPC_ADDRESS =
-	process.env.CLINE_RPC_ADDRESS?.trim() || "127.0.0.1:4317";
+	process.env.CLINE_RPC_ADDRESS?.trim() || getRpcServerDefaultAddress();
 
-type SessionBackend = RpcCoreSessionService | CoreSessionService;
+export type SessionBackend = RpcCoreSessionService | CoreSessionService;
 
 let cachedBackend: SessionBackend | undefined;
 let backendInitPromise: Promise<SessionBackend> | undefined;
@@ -41,24 +41,35 @@ export interface CreateSessionHostOptions {
 
 export type SessionHost = SessionManager;
 
-function isLikelyScriptEntryPath(pathValue: string | undefined): boolean {
-	if (!pathValue) {
-		return false;
-	}
-	return /\.(?:[cm]?[jt]s|tsx?)$/i.test(pathValue);
-}
-
 function startRpcServerInBackground(address: string): void {
-	const launcher = process.argv[0];
-	const entry = process.argv[1];
-	const startArgs = ["rpc", "start", "--address", address];
-	const args =
-		entry && isLikelyScriptEntryPath(entry) ? [entry, ...startArgs] : startArgs;
+	const launcher = process.execPath;
+	const entryArg = process.argv[1]?.trim();
+	if (!entryArg) {
+		return;
+	}
+	const entry = resolve(process.cwd(), entryArg);
+	if (!existsSync(entry)) {
+		return;
+	}
+	const conditionsArg = process.execArgv.find((arg) =>
+		arg.startsWith("--conditions="),
+	);
+	const args = [
+		...(conditionsArg ? [conditionsArg] : []),
+		entry,
+		"rpc",
+		"start",
+		"--address",
+		address,
+	];
 
 	const child = spawn(launcher, args, {
 		detached: true,
 		stdio: "ignore",
-		env: process.env,
+		env: {
+			...process.env,
+			CLINE_NO_INTERACTIVE: "1",
+		},
 		cwd: process.cwd(),
 	});
 	child.unref();
@@ -116,7 +127,7 @@ function resolveHostDistinctId(explicitDistinctId: string | undefined): string {
 	return generatedDistinctId;
 }
 
-async function resolveBackend(
+export async function resolveSessionBackend(
 	options: CreateSessionHostOptions,
 ): Promise<SessionBackend> {
 	if (cachedBackend) {
@@ -179,7 +190,8 @@ async function resolveBackend(
 export async function createSessionHost(
 	options: CreateSessionHostOptions,
 ): Promise<SessionHost> {
-	const backend = options.sessionService ?? (await resolveBackend(options));
+	const backend =
+		options.sessionService ?? (await resolveSessionBackend(options));
 	return new DefaultSessionManager({
 		sessionService: backend,
 		defaultToolExecutors: options.defaultToolExecutors,

package/src/session/session-manager.ts

@@ -40,9 +40,20 @@ export interface SendSessionInput {
 	userFiles?: string[];
 }
 
+export interface SessionAccumulatedUsage {
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+	totalCost: number;
+}
+
 export interface SessionManager {
 	start(input: StartSessionInput): Promise<StartSessionResult>;
 	send(input: SendSessionInput): Promise<AgentResult | undefined>;
+	getAccumulatedUsage(
+		sessionId: string,
+	): Promise<SessionAccumulatedUsage | undefined>;
 	abort(sessionId: string): Promise<void>;
 	stop(sessionId: string): Promise<void>;
 	dispose(reason?: string): Promise<void>;

package/src/session/unified-session-persistence-service.ts

@@ -499,15 +499,21 @@ export class UnifiedSessionPersistenceService {
 	async persistSessionMessages(
 		sessionId: string,
 		messages: LlmsProviders.Message[],
+		systemPrompt?: string,
 	): Promise<void> {
 		const path =
 			(await this.sessionPathFromStore(sessionId, "messages_path")) ??
 			this.sessionMessagesPath(sessionId);
-		writeFileSync(
-			path,
-			`${JSON.stringify({ version: 1, updated_at: nowIso(), messages }, null, 2)}\n`,
-			"utf8",
-		);
+		const payload: {
+			version: number;
+			updated_at: string;
+			systemPrompt?: string;
+			messages: LlmsProviders.Message[];
+		} = { version: 1, updated_at: nowIso(), messages };
+		if (systemPrompt !== undefined && systemPrompt !== "") {
+			payload.systemPrompt = systemPrompt;
+		}
+		writeFileSync(path, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
 	}
 
 	async applySubagentStatus(