@clinebot/core 0.0.35 → 0.0.36

package/src/services/plugin-tools.ts

@@ -0,0 +1,85 @@
+import type { AgentConfig, Tool } from "@clinebot/shared";
+import { resolveAgentPluginPaths } from "../extensions/plugin/plugin-config-loader";
+import { loadAgentPluginsFromPathsWithDiagnostics } from "../extensions/plugin/plugin-loader";
+import { resolveDisabledToolNames } from "./global-settings";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentExtensionApi = Parameters<NonNullable<AgentExtension["setup"]>>[0];
+
+export interface PluginToolSummary {
+	name: string;
+	pluginName: string;
+	path: string;
+	source: "workspace-plugin" | "global-plugin";
+	enabled: boolean;
+	description?: string;
+}
+
+function collectRegisteredTools(
+	extension: AgentExtension,
+	workspaceInfo?: { rootPath: string },
+): Tool[] {
+	if (!extension.setup) {
+		return [];
+	}
+
+	const tools: Tool[] = [];
+	const api: AgentExtensionApi = {
+		registerTool: (tool) => tools.push(tool),
+		registerCommand: () => {},
+		registerMessageBuilder: () => {},
+		registerProvider: () => {},
+	};
+	extension.setup(api, { workspaceInfo });
+	return tools;
+}
+
+export async function listPluginTools(input: {
+	workspacePath: string;
+	cwd?: string;
+	disabledToolNames?: ReadonlyArray<string>;
+	providerId?: string;
+	modelId?: string;
+}): Promise<PluginToolSummary[]> {
+	const pluginPaths = resolveAgentPluginPaths({
+		workspacePath: input.workspacePath,
+		cwd: input.cwd,
+	});
+	const disabled = resolveDisabledToolNames(input.disabledToolNames);
+	const summaries: PluginToolSummary[] = [];
+
+	for (const pluginPath of pluginPaths) {
+		const report = await loadAgentPluginsFromPathsWithDiagnostics(
+			[pluginPath],
+			{
+				cwd: input.cwd,
+				providerId: input.providerId,
+				modelId: input.modelId,
+			},
+		);
+		for (const extension of report.plugins) {
+			for (const tool of collectRegisteredTools(extension, {
+				rootPath: input.workspacePath,
+			})) {
+				summaries.push({
+					name: tool.name,
+					pluginName: extension.name,
+					path: pluginPath,
+					source: pluginPath.startsWith(input.workspacePath)
+						? "workspace-plugin"
+						: "global-plugin",
+					enabled: !disabled.has(tool.name),
+					description: tool.description?.trim() || undefined,
+				});
+			}
+		}
+	}
+
+	return summaries.sort((left, right) => {
+		const nameOrder = left.name.localeCompare(right.name);
+		if (nameOrder !== 0) {
+			return nameOrder;
+		}
+		return left.path.localeCompare(right.path);
+	});
+}

package/src/services/providers/local-provider-registry.ts

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import * as LlmsModels from "@clinebot/llms";
-import type { RpcProviderCapability, RpcProviderModel } from "@clinebot/shared";
+import type { ProviderCapability, ProviderModel } from "@clinebot/shared";
 import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
 
 export type StoredModelsFile = {
@@ -14,7 +14,7 @@ export type StoredModelsFile = {
 				name: string;
 				baseUrl: string;
 				defaultModelId?: string;
-				capabilities?: RpcProviderCapability[];
+				capabilities?: ProviderCapability[];
 				modelsSourceUrl?: string;
 			};
 			models: Record<
@@ -108,14 +108,14 @@ export async function writeModelsFile(
 	await writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
 }
 
-export function toRpcProviderModel(
+export function toProviderModel(
 	modelId: string,
 	info: {
 		name?: string;
 		capabilities?: string[];
 		thinkingConfig?: unknown;
 	},
-): RpcProviderModel {
+): ProviderModel {
 	return {
 		id: modelId,
 		name: info.name ?? modelId,
@@ -127,7 +127,7 @@ export function toRpcProviderModel(
 }
 
 function toProviderCapabilities(
-	capabilities: RpcProviderCapability[] | undefined,
+	capabilities: ProviderCapability[] | undefined,
 ): Array<"reasoning" | "prompt-cache" | "tools"> | undefined {
 	if (!capabilities || capabilities.length === 0) {
 		return undefined;
@@ -146,7 +146,7 @@ function toProviderCapabilities(
 }
 
 function toModelCapabilities(
-	capabilities: RpcProviderCapability[] | undefined,
+	capabilities: ProviderCapability[] | undefined,
 ): Array<
 	"streaming" | "tools" | "reasoning" | "prompt-cache" | "images" | "files"
 > {

package/src/services/providers/local-provider-service.ts

@@ -1,23 +1,28 @@
 import * as LlmsModels from "@clinebot/llms";
-import * as LlmsProviders from "@clinebot/llms";
 import type {
-	RpcAddProviderActionRequest,
-	RpcOAuthProviderId,
-	RpcProviderCapability,
-	RpcProviderListItem,
-	RpcProviderModel,
-	RpcSaveProviderSettingsActionRequest,
+	AddProviderActionRequest,
+	OAuthProviderId,
+	ProviderCapability,
+	ProviderListItem,
+	ProviderModel,
+	SaveProviderSettingsActionRequest,
 } from "@clinebot/shared";
 import { createOAuthClientCallbacks } from "../../auth/client";
 import { loginClineOAuth } from "../../auth/cline";
 import { loginOpenAICodex } from "../../auth/codex";
 import { loginOcaOAuth } from "../../auth/oca";
+import { resolveProviderConfig } from "../../llms/provider-defaults";
+import type {
+	ModelInfo,
+	ProviderConfig,
+	ProviderSettings,
+} from "../../llms/provider-settings";
 import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
 import {
 	readModelsFile,
 	registerCustomProvider,
 	resolveModelsRegistryPath,
-	toRpcProviderModel,
+	toProviderModel,
 	writeModelsFile,
 } from "./local-provider-registry";
 
@@ -33,7 +38,7 @@ export interface UpdateLocalProviderRequest {
 	models?: string[];
 	defaultModelId?: string | null;
 	modelsSourceUrl?: string | null;
-	capabilities?: RpcProviderCapability[] | null;
+	capabilities?: ProviderCapability[] | null;
 }
 
 export interface DeleteLocalProviderRequest {
@@ -86,12 +91,12 @@ function stableColor(id: string): string {
 	return palette[hash % palette.length];
 }
 
-function toSortedRpcProviderModels(
-	modelMap: Record<string, LlmsProviders.ModelInfo>,
-): RpcProviderModel[] {
+function toSortedProviderModels(
+	modelMap: Record<string, ModelInfo>,
+): ProviderModel[] {
 	return Object.entries(modelMap)
 		.sort(([a], [b]) => a.localeCompare(b))
-		.map(([modelId, info]) => toRpcProviderModel(modelId, info));
+		.map(([modelId, info]) => toProviderModel(modelId, info));
 }
 
 // --- Model ID parsing ---
@@ -163,14 +168,14 @@ async function fetchModelIdsFromSource(
 
 async function resolveProviderModelMap(
 	providerId: string,
-	config?: LlmsProviders.ProviderConfig,
-): Promise<Record<string, LlmsProviders.ModelInfo>> {
+	config?: ProviderConfig,
+): Promise<Record<string, ModelInfo>> {
 	const registeredModels = await LlmsModels.getModelsForProvider(providerId);
 	if (!config) {
 		return registeredModels;
 	}
 
-	const resolved = await LlmsProviders.resolveProviderConfig(
+	const resolved = await resolveProviderConfig(
 		providerId,
 		{
 			loadPrivateOnAuth: true,
@@ -202,7 +207,7 @@ function normalizeHeaders(
 
 function buildProviderModels(
 	modelIds: string[],
-	capabilities: RpcProviderCapability[] | undefined,
+	capabilities: ProviderCapability[] | undefined,
 ) {
 	const supportsVision = capabilities?.includes("vision") ?? false;
 	const supportsReasoning = capabilities?.includes("reasoning") ?? false;
@@ -257,7 +262,7 @@ function removeProviderFromSettingsState(
 
 export async function addLocalProvider(
 	manager: ProviderSettingsManager,
-	request: Omit<RpcAddProviderActionRequest, "action">,
+	request: Omit<AddProviderActionRequest, "action">,
 ): Promise<{
 	providerId: string;
 	settingsPath: string;
@@ -508,17 +513,17 @@ export async function deleteLocalProvider(
 
 export async function listLocalProviders(
 	manager: ProviderSettingsManager,
-): Promise<{ providers: RpcProviderListItem[]; settingsPath: string }> {
+): Promise<{ providers: ProviderListItem[]; settingsPath: string }> {
 	const state = manager.read();
 	const ids = LlmsModels.getProviderIds().sort((a, b) => a.localeCompare(b));
 
 	const providers = await Promise.all(
-		ids.map(async (id): Promise<RpcProviderListItem> => {
+		ids.map(async (id): Promise<ProviderListItem> => {
 			const [info, registeredModels] = await Promise.all([
 				LlmsModels.getProvider(id),
 				LlmsModels.getModelsForProvider(id),
 			]);
-			const modelList = toSortedRpcProviderModels(registeredModels);
+			const modelList = toSortedProviderModels(registeredModels);
 			const persistedSettings = state.providers[id]?.settings;
 			const name = info?.name ?? titleCaseFromId(id);
 			return {
@@ -548,17 +553,17 @@ export async function listLocalProviders(
 
 export async function getLocalProviderModels(
 	providerId: string,
-	config?: LlmsProviders.ProviderConfig,
-): Promise<{ providerId: string; models: RpcProviderModel[] }> {
+	config?: ProviderConfig,
+): Promise<{ providerId: string; models: ProviderModel[] }> {
 	const id = providerId.trim();
 	const modelMap = await resolveProviderModelMap(id, config);
-	const models = toSortedRpcProviderModels(modelMap);
+	const models = toSortedProviderModels(modelMap);
 	return { providerId: id, models };
 }
 
 export function saveLocalProviderSettings(
 	manager: ProviderSettingsManager,
-	request: Omit<RpcSaveProviderSettingsActionRequest, "action">,
+	request: Omit<SaveProviderSettingsActionRequest, "action">,
 ): { providerId: string; enabled: boolean; settingsPath: string } {
 	const providerId = request.providerId.trim();
 
@@ -621,7 +626,7 @@ export function saveLocalProviderSettings(
 	return { providerId, enabled: true, settingsPath: manager.getFilePath() };
 }
 
-export function normalizeOAuthProvider(provider: string): RpcOAuthProviderId {
+export function normalizeOAuthProvider(provider: string): OAuthProviderId {
 	const normalized = provider.trim().toLowerCase();
 	if (normalized === "codex" || normalized === "openai-codex")
 		return "openai-codex";
@@ -632,7 +637,7 @@ export function normalizeOAuthProvider(provider: string): RpcOAuthProviderId {
 }
 
 function toProviderApiKey(
-	providerId: RpcOAuthProviderId,
+	providerId: OAuthProviderId,
 	credentials: { access: string },
 ): string {
 	return providerId === "cline"
@@ -641,8 +646,8 @@ function toProviderApiKey(
 }
 
 export async function loginLocalProvider(
-	providerId: RpcOAuthProviderId,
-	existing: LlmsProviders.ProviderSettings | undefined,
+	providerId: OAuthProviderId,
+	existing: ProviderSettings | undefined,
 	openUrl: (url: string) => void,
 ): Promise<{
 	access: string;
@@ -671,28 +676,28 @@ export async function loginLocalProvider(
 
 export function saveLocalProviderOAuthCredentials(
 	manager: ProviderSettingsManager,
-	providerId: RpcOAuthProviderId,
-	existing: LlmsProviders.ProviderSettings | undefined,
+	providerId: OAuthProviderId,
+	existing: ProviderSettings | undefined,
 	credentials: {
 		access: string;
 		refresh: string;
 		expires: number;
 		accountId?: string;
 	},
-): LlmsProviders.ProviderSettings {
+): ProviderSettings {
 	const auth = {
 		...(existing?.auth ?? {}),
 		accessToken: toProviderApiKey(providerId, credentials),
 		refreshToken: credentials.refresh,
 		accountId: credentials.accountId,
 		expiresAt: credentials.expires,
-	} as LlmsProviders.ProviderSettings["auth"] & { expiresAt?: number };
+	} as ProviderSettings["auth"] & { expiresAt?: number };
 
-	const merged: LlmsProviders.ProviderSettings = {
+	const merged: ProviderSettings = {
 		...(existing ?? {
-			provider: providerId as LlmsProviders.ProviderSettings["provider"],
+			provider: providerId as ProviderSettings["provider"],
 		}),
-		provider: providerId as LlmsProviders.ProviderSettings["provider"],
+		provider: providerId as ProviderSettings["provider"],
 		auth,
 	};
 	manager.saveProviderSettings(merged, { tokenSource: "oauth" });
@@ -700,7 +705,7 @@ export function saveLocalProviderOAuthCredentials(
 }
 
 export function resolveLocalClineAuthToken(
-	settings: LlmsProviders.ProviderSettings | undefined,
+	settings: ProviderSettings | undefined,
 ): string | undefined {
 	const token = settings?.auth?.accessToken?.trim() || settings?.apiKey?.trim();
 	return token && token.length > 0 ? token : undefined;

package/src/services/session-data.ts

@@ -12,7 +12,7 @@ import {
 	type SessionManifest,
 	SessionManifestSchema,
 } from "../session/session-manifest";
-import type { SessionRow } from "../session/session-service";
+import type { SessionRow } from "../session/session-row";
 import type { SessionSource, SessionStatus } from "../types/common";
 import type { StoredMessageWithMetadata } from "../types/session";
 import type { SessionRecord } from "../types/sessions";
@@ -154,22 +154,28 @@ export function withLatestAssistantTurnMetadata(
 	}
 
 	const usage = result.usage;
+	const lastAssistantIndexForUsage =
+		assistantIndexes[assistantIndexes.length - 1];
 	for (const targetIndex of assistantIndexes) {
 		const target = next[targetIndex];
+		const metrics =
+			targetIndex === lastAssistantIndexForUsage
+				? {
+						...(target.metrics ?? {}),
+						inputTokens: usage.inputTokens,
+						outputTokens: usage.outputTokens,
+						cacheReadTokens: usage.cacheReadTokens ?? 0,
+						cacheWriteTokens: usage.cacheWriteTokens ?? 0,
+						cost: usage.totalCost,
+					}
+				: target.metrics;
 		next[targetIndex] = {
 			...normalizeStoredMessageModelMetadata(target, {
 				id: result.model.id,
 				provider: result.model.provider,
 				family: result.model.info?.family,
 			}),
-			metrics: {
-				...(target.metrics ?? {}),
-				inputTokens: usage.inputTokens,
-				outputTokens: usage.outputTokens,
-				cacheReadTokens: usage.cacheReadTokens ?? 0,
-				cacheWriteTokens: usage.cacheWriteTokens ?? 0,
-				cost: usage.totalCost,
-			},
+			...(metrics ? { metrics } : {}),
 			ts: target.ts ?? result.endedAt.getTime(),
 		};
 	}

package/src/services/storage/provider-settings-legacy-migration.ts

@@ -1,10 +1,12 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import * as LlmsModels from "@clinebot/llms";
-import * as LlmsProviders from "@clinebot/llms";
 import { resolveClineDataDir } from "@clinebot/shared/storage";
-import type { ProviderSettings } from "../../types/provider-settings";
-import { emptyStoredProviderSettings } from "../../types/provider-settings";
+import {
+	emptyStoredProviderSettings,
+	type ProviderSettings,
+	ProviderSettingsSchemaTyped as ProviderSettingsSchema,
+} from "../../types/provider-settings";
 import type { ProviderSettingsManager } from "./provider-settings-manager";
 
 type LegacyMode = "plan" | "act";
@@ -659,7 +661,7 @@ function buildLegacyProviderSettings(
 		...(timeout ? { timeout } : {}),
 		...providerSpecific,
 	};
-	const parsed = LlmsProviders.ProviderSettingsSchema.safeParse(settings);
+	const parsed = ProviderSettingsSchema.safeParse(settings);
 	if (!parsed.success) {
 		return undefined;
 	}

package/src/services/storage/provider-settings-manager.ts

@@ -5,7 +5,7 @@ import {
 	emptyStoredProviderSettings,
 	type ProviderConfig,
 	type ProviderSettings,
-	ProviderSettingsSchema,
+	ProviderSettingsSchemaTyped as ProviderSettingsSchema,
 	type ProviderTokenSource,
 	type StoredProviderSettings,
 	StoredProviderSettingsSchema,

package/src/services/workspace-manifest.ts

@@ -52,3 +52,21 @@ export async function buildWorkspaceMetadata(cwd: string): Promise<string> {
 	const workspaceInfo = await generateWorkspaceInfo(cwd);
 	return processWorkspaceInfo(workspaceInfo);
 }
+
+/**
+ * Generate workspace metadata as both a structured `WorkspaceInfo` object and
+ * its pre-serialized string form.
+ *
+ * Use this instead of calling `buildWorkspaceMetadata` + `generateWorkspaceInfo`
+ * separately so the git I/O only happens once.
+ */
+export async function buildWorkspaceMetadataWithInfo(cwd: string): Promise<{
+	workspaceInfo: WorkspaceInfo;
+	workspaceMetadata: string;
+}> {
+	const workspaceInfo = await generateWorkspaceInfo(cwd);
+	return {
+		workspaceInfo,
+		workspaceMetadata: processWorkspaceInfo(workspaceInfo),
+	};
+}

package/src/session/file-session-service.ts

@@ -13,7 +13,7 @@ import type {
 	SessionPersistenceAdapter,
 } from "./persistence-service";
 import { UnifiedSessionPersistenceService } from "./persistence-service";
-import type { SessionRow } from "./session-service";
+import type { SessionRow } from "./session-row";
 
 interface FileSessionIndex {
 	version: 1;

package/src/session/index.ts

@@ -4,36 +4,10 @@ export {
 	type WorkspaceManifest,
 	WorkspaceManifestSchema,
 } from "@clinebot/shared";
-export type {
-	ClineCore,
-	ClineCoreOptions,
-	ClineCoreStartInput,
-} from "../ClineCore";
-export type { SessionBackend } from "../runtime/host";
-export {
-	createRuntimeHost,
-	resolveSessionBackend,
-} from "../runtime/host";
-export type {
-	LocalRuntimeConfigOverrides,
-	LocalRuntimeStartOptions,
-	RuntimeHost,
-	RuntimeHost as SessionHost,
-	RuntimeHostMode,
-	RuntimeSessionConfig,
-	SendSessionInput,
-	SessionAccumulatedUsage,
-	StartSessionInput,
-	StartSessionResult,
-} from "../runtime/runtime-host";
-export { splitCoreSessionConfig } from "../runtime/runtime-host";
 export {
 	generateWorkspaceInfo,
 	normalizeWorkspacePath,
 } from "../services/workspace-manifest";
-export { LocalRuntimeHost } from "../transports/local";
-export { RpcRuntimeHost } from "../transports/rpc";
-export { RpcCoreSessionService } from "./rpc-session-service";
 export {
 	deriveSubsessionStatus,
 	makeSubSessionId,
@@ -44,8 +18,13 @@ export type { SessionManifest } from "./session-manifest";
 export type {
 	CreateRootSessionWithArtifactsInput,
 	RootSessionArtifacts,
-} from "./session-service";
+	SessionRow,
+} from "./session-row";
 export { CoreSessionService } from "./session-service";
+export {
+	FileTeamPersistenceStore,
+	type FileTeamPersistenceStoreOptions,
+} from "./team-persistence-store";
 export type {
 	WorkspaceManager,
 	WorkspaceManagerEvent,