@clinebot/core 0.0.36 → 0.0.37

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

@@ -2,34 +2,70 @@ 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 { ProviderCapability, ProviderModel } from "@clinebot/shared";
+import {
+	type ModelCapability,
+	ModelCapabilitySchema,
+	type ModelInfo,
+	type ProviderCapability,
+	ProviderCapabilitySchema,
+	type ProviderClient,
+	ProviderClientSchema,
+	type ProviderModel,
+	type ProviderProtocol,
+	ProviderProtocolSchema,
+} from "@clinebot/shared";
+import { z } from "zod";
+import type {
+	ProviderSettings,
+	StoredProviderSettings,
+} from "../../types/provider-settings";
 import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
 
-export type StoredModelsFile = {
-	version: 1;
-	providers: Record<
-		string,
-		{
-			provider: {
-				name: string;
-				baseUrl: string;
-				defaultModelId?: string;
-				capabilities?: ProviderCapability[];
-				modelsSourceUrl?: string;
-			};
-			models: Record<
-				string,
-				{
-					id: string;
-					name: string;
-					supportsVision?: boolean;
-					supportsAttachments?: boolean;
-					supportsReasoning?: boolean;
-				}
-			>;
-		}
-	>;
-};
+export const StoredModelEntrySchema = z
+	.object({
+		id: z.string().optional(),
+		name: z.string().optional(),
+		capabilities: z.array(ModelCapabilitySchema).optional(),
+		supportsVision: z.boolean().optional(),
+		supportsAttachments: z.boolean().optional(),
+		supportsReasoning: z.boolean().optional(),
+	})
+	.passthrough();
+
+export type StoredModelEntry = z.infer<typeof StoredModelEntrySchema>;
+
+export const StoredProviderMetadataSchema = z
+	.object({
+		name: z.string(),
+		baseUrl: z.string(),
+		defaultModelId: z.string().optional(),
+		protocol: ProviderProtocolSchema.optional(),
+		client: ProviderClientSchema.optional(),
+		capabilities: z.array(ProviderCapabilitySchema).optional(),
+		modelsSourceUrl: z.string().optional(),
+	})
+	.passthrough();
+
+export const StoredProviderEntrySchema = z
+	.object({
+		provider: StoredProviderMetadataSchema.optional(),
+		models: z.record(z.string(), StoredModelEntrySchema).optional(),
+	})
+	.passthrough();
+
+export type StoredProviderEntry = z.infer<typeof StoredProviderEntrySchema>;
+
+export const StoredModelsFileSchema = z.object({
+	version: z.literal(1),
+	providers: z.record(z.string(), StoredProviderEntrySchema),
+});
+
+export type StoredModelsFile = z.infer<typeof StoredModelsFileSchema>;
+
+const StoredModelsFileEnvelopeSchema = z.object({
+	version: z.literal(1),
+	providers: z.record(z.string(), z.unknown()),
+});
 
 const LOADED_MODELS_REGISTRY_PATHS = new Set<string>();
 
@@ -51,21 +87,29 @@ export function emptyModelsFile(): StoredModelsFile {
 	return { version: 1, providers: {} };
 }
 
+export function parseModelsFile(input: unknown): StoredModelsFile {
+	const result = StoredModelsFileEnvelopeSchema.safeParse(input);
+	if (!result.success) {
+		return emptyModelsFile();
+	}
+
+	const providers: StoredModelsFile["providers"] = {};
+	for (const [providerId, entry] of Object.entries(result.data.providers)) {
+		const provider = StoredProviderEntrySchema.safeParse(entry);
+		if (provider.success) {
+			providers[providerId] = provider.data;
+		}
+	}
+	return { version: 1, providers };
+}
+
 export function readModelsFileSync(filePath: string): StoredModelsFile {
 	if (!existsSync(filePath)) {
 		return emptyModelsFile();
 	}
 	try {
 		const raw = readFileSync(filePath, "utf8");
-		const parsed = JSON.parse(raw) as Partial<StoredModelsFile>;
-		if (
-			parsed &&
-			parsed.version === 1 &&
-			parsed.providers &&
-			typeof parsed.providers === "object"
-		) {
-			return { version: 1, providers: parsed.providers };
-		}
+		return parseModelsFile(JSON.parse(raw) as unknown);
 	} catch {
 		// Invalid or missing files fall back to an empty registry.
 	}
@@ -77,15 +121,7 @@ export async function readModelsFile(
 ): Promise<StoredModelsFile> {
 	try {
 		const raw = await readFile(filePath, "utf8");
-		const parsed = JSON.parse(raw) as Partial<StoredModelsFile>;
-		if (
-			parsed &&
-			parsed.version === 1 &&
-			parsed.providers &&
-			typeof parsed.providers === "object"
-		) {
-			return { version: 1, providers: parsed.providers };
-		}
+		return parseModelsFile(JSON.parse(raw) as unknown);
 	} catch {
 		// Invalid or missing files fall back to an empty registry.
 	}
@@ -97,7 +133,8 @@ export function writeModelsFileSync(
 	state: StoredModelsFile,
 ): void {
 	mkdirSync(dirname(filePath), { recursive: true });
-	writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+	const parsed = StoredModelsFileSchema.parse(state);
+	writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
 }
 
 export async function writeModelsFile(
@@ -105,7 +142,8 @@ export async function writeModelsFile(
 	state: StoredModelsFile,
 ): Promise<void> {
 	await mkdir(dirname(filePath), { recursive: true });
-	await writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+	const parsed = StoredModelsFileSchema.parse(state);
+	await writeFile(filePath, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
 }
 
 export function toProviderModel(
@@ -167,6 +205,168 @@ function toModelCapabilities(
 	return [...next];
 }
 
+function isCompleteProviderMetadata(
+	provider: StoredProviderEntry["provider"],
+): provider is NonNullable<StoredProviderEntry["provider"]> {
+	return (
+		provider != null &&
+		typeof provider.name === "string" &&
+		typeof provider.baseUrl === "string"
+	);
+}
+
+function resolveProviderProtocol(
+	protocol: ProviderProtocol | undefined,
+	fallback: ProviderProtocol | undefined,
+): ProviderProtocol {
+	return protocol ?? fallback ?? "openai-chat";
+}
+
+function resolveProviderClient(
+	client: ProviderClient | undefined,
+	protocol: ProviderProtocol,
+	fallback: ProviderClient | undefined,
+): ProviderClient {
+	return (
+		client ??
+		fallback ??
+		(protocol === "openai-responses" ? "openai" : "openai-compatible")
+	);
+}
+
+function toStoredModelInfo(
+	modelId: string,
+	model: StoredModelEntry | undefined,
+): ModelInfo {
+	const capabilities = new Set<ModelCapability>(model?.capabilities ?? []);
+	if (model?.supportsVision) capabilities.add("images");
+	if (model?.supportsAttachments) capabilities.add("files");
+	if (model?.supportsReasoning) capabilities.add("reasoning");
+
+	return {
+		id: modelId,
+		name: model?.name ?? modelId,
+		capabilities: capabilities.size > 0 ? [...capabilities] : undefined,
+	};
+}
+
+function registerCustomModels(
+	providerId: string,
+	models: StoredProviderEntry["models"] | undefined,
+): void {
+	for (const [modelKey, model] of Object.entries(models ?? {})) {
+		const modelId = model.id?.trim() || modelKey.trim();
+		if (!modelId) {
+			continue;
+		}
+		LlmsModels.registerModel(
+			providerId,
+			modelId,
+			toStoredModelInfo(modelId, model),
+		);
+	}
+}
+
+function modelInfoWithDefaults(
+	modelId: string,
+	info: ModelInfo | undefined,
+	capabilities: ModelInfo["capabilities"] | undefined,
+): ModelInfo {
+	return {
+		...(info ?? {}),
+		id: modelId,
+		name: info?.name ?? modelId,
+		capabilities: info?.capabilities ?? capabilities,
+	};
+}
+
+function getGeneratedModelsForProvider(
+	providerId: string,
+): Record<string, ModelInfo> {
+	const generated = Object.assign(
+		{},
+		...LlmsModels.resolveProviderModelCatalogKeys(providerId).map(
+			(catalogKey) => LlmsModels.getGeneratedModelsForProvider(catalogKey),
+		),
+	);
+	return generated as Record<string, ModelInfo>;
+}
+
+export function registerProviderSettingsProvider(
+	settings: ProviderSettings,
+): void {
+	const providerId = settings.provider.trim();
+	if (!providerId || LlmsModels.isBuiltInProviderId(providerId)) {
+		return;
+	}
+
+	const baseUrl = settings.baseUrl?.trim();
+	if (!baseUrl) {
+		return;
+	}
+
+	const existingCollection = LlmsModels.MODEL_COLLECTIONS_BY_PROVIDER_ID[
+		providerId
+	] as LlmsModels.ModelCollection | undefined;
+	const generatedModels = getGeneratedModelsForProvider(providerId);
+	const modelCapabilities = toModelCapabilities(settings.capabilities);
+	const fallbackCapabilities =
+		modelCapabilities.length > 0 ? modelCapabilities : undefined;
+	const modelId = settings.model?.trim();
+	const models: Record<string, ModelInfo> = {
+		...generatedModels,
+		...(existingCollection?.models ?? {}),
+	};
+
+	if (modelId) {
+		models[modelId] = modelInfoWithDefaults(
+			modelId,
+			models[modelId],
+			fallbackCapabilities,
+		);
+	}
+
+	const modelIds = Object.keys(models).filter(Boolean);
+	const defaultModelId = modelId || modelIds[0];
+	if (!defaultModelId) {
+		return;
+	}
+	const protocol = resolveProviderProtocol(
+		settings.protocol,
+		existingCollection?.provider.protocol,
+	);
+	const client = resolveProviderClient(
+		settings.client,
+		protocol,
+		existingCollection?.provider.client,
+	);
+
+	LlmsModels.registerProvider({
+		provider: {
+			id: providerId,
+			name: existingCollection?.provider.name ?? titleCaseFromId(providerId),
+			description: existingCollection?.provider.description,
+			protocol,
+			client,
+			baseUrl,
+			defaultModelId,
+			capabilities:
+				toProviderCapabilities(settings.capabilities) ??
+				existingCollection?.provider.capabilities,
+			source: "file",
+		},
+		models,
+	});
+}
+
+export function registerConfiguredProvidersFromSettings(
+	state: StoredProviderSettings,
+): void {
+	for (const entry of Object.values(state.providers)) {
+		registerProviderSettingsProvider(entry.settings);
+	}
+}
+
 /**
  * Custom Provider Registry
  *
@@ -176,20 +376,35 @@ function toModelCapabilities(
  */
 export function registerCustomProvider(
 	providerId: string,
-	entry: StoredModelsFile["providers"][string],
+	entry: StoredProviderEntry,
 ): void {
+	const storedModels = entry.models ?? {};
+	if (!isCompleteProviderMetadata(entry.provider)) {
+		registerCustomModels(providerId, storedModels);
+		return;
+	}
+
 	const modelCapabilities = toModelCapabilities(entry.provider.capabilities);
-	const modelEntries = Object.values(entry.models)
-		.map((model) => model.id.trim())
-		.filter((modelId) => modelId.length > 0);
+	const modelEntries = Object.entries(storedModels)
+		.map(([modelKey, model]) => ({
+			id: model.id?.trim() || modelKey.trim(),
+			model,
+		}))
+		.filter(({ id }) => id.length > 0);
 	const defaultModelId =
-		entry.provider.defaultModelId?.trim() || modelEntries[0] || "default";
+		entry.provider.defaultModelId?.trim() || modelEntries[0]?.id || "default";
+	const protocol = resolveProviderProtocol(entry.provider.protocol, undefined);
+	const client = resolveProviderClient(
+		entry.provider.client,
+		protocol,
+		undefined,
+	);
 	const normalizedModels = Object.fromEntries(
-		modelEntries.map((modelId) => [
-			modelId,
+		modelEntries.map(({ id, model }) => [
+			id,
 			{
-				id: modelId,
-				name: entry.models[modelId]?.name ?? modelId,
+				id,
+				name: model.name ?? id,
 				capabilities:
 					modelCapabilities.length > 0 ? modelCapabilities : undefined,
 				status: "active" as const,
@@ -201,11 +416,12 @@ export function registerCustomProvider(
 		provider: {
 			id: providerId,
 			name: entry.provider.name.trim() || titleCaseFromId(providerId),
-			protocol: "openai-chat",
-			client: "openai-compatible",
+			protocol,
+			client,
 			baseUrl: entry.provider.baseUrl,
 			defaultModelId,
 			capabilities: toProviderCapabilities(entry.provider.capabilities),
+			source: "file",
 		},
 		models: normalizedModels,
 	});

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

@@ -14,7 +14,9 @@ import { loginOcaOAuth } from "../../auth/oca";
 import { resolveProviderConfig } from "../../llms/provider-defaults";
 import type {
 	ModelInfo,
+	ProviderClient,
 	ProviderConfig,
+	ProviderProtocol,
 	ProviderSettings,
 } from "../../llms/provider-settings";
 import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
@@ -38,6 +40,8 @@ export interface UpdateLocalProviderRequest {
 	models?: string[];
 	defaultModelId?: string | null;
 	modelsSourceUrl?: string | null;
+	protocol?: ProviderProtocol | null;
+	client?: ProviderClient | null;
 	capabilities?: ProviderCapability[] | null;
 }
 
@@ -256,6 +260,7 @@ function removeProviderFromSettingsState(
 		mutated = true;
 	}
 	if (mutated) manager.write(state);
+	LlmsModels.unregisterProvider(providerId);
 }
 
 // --- Public API ---
@@ -338,6 +343,8 @@ export async function addLocalProvider(
 			headers: normalizedHeaders,
 			timeout: request.timeoutMs,
 			model: defaultModelId,
+			protocol: request.protocol,
+			client: request.client,
 		},
 		{ setLastUsed: false },
 	);
@@ -350,6 +357,8 @@ export async function addLocalProvider(
 			name: providerName,
 			baseUrl,
 			defaultModelId,
+			protocol: request.protocol,
+			client: request.client,
 			capabilities,
 			modelsSourceUrl: sourceUrl,
 		},
@@ -380,11 +389,40 @@ export async function updateLocalProvider(
 
 	const modelsPath = resolveModelsRegistryPath(manager);
 	const modelsState = await readModelsFile(modelsPath);
-	const existingEntry = modelsState.providers[providerId];
+	let existingEntry = modelsState.providers[providerId];
 	if (!existingEntry) {
-		throw new Error(`provider "${providerId}" does not exist`);
-	}
+		const existingSettings = manager.getProviderSettings(providerId);
+		if (!existingSettings) {
+			throw new Error(`provider "${providerId}" does not exist`);
+		}
 
+		const seedModelId =
+			uniqueTrimmed(request.models)[0] ?? existingSettings.model?.trim();
+		if (!seedModelId) {
+			throw new Error(
+				`provider "${providerId}" cannot be updated because no model is configured`,
+			);
+		}
+
+		// Ephemeral seed for the existing update path; final state is computed and written below.
+		existingEntry = {
+			provider: {
+				name: request.name?.trim() || titleCaseFromId(providerId),
+				baseUrl:
+					request.baseUrl?.trim() ?? existingSettings.baseUrl?.trim() ?? "",
+				defaultModelId: seedModelId,
+				protocol: existingSettings.protocol,
+				client: existingSettings.client,
+				capabilities: existingSettings.capabilities,
+			},
+			models: buildProviderModels([seedModelId], existingSettings.capabilities),
+		};
+	}
+	if (!existingEntry.provider) {
+		throw new Error(
+			`provider "${providerId}" cannot be updated because it is a model overlay (no provider metadata)`,
+		);
+	}
 	const providerName =
 		request.name?.trim() ?? existingEntry.provider.name.trim();
 	if (!providerName) throw new Error("name is required");
@@ -399,6 +437,14 @@ export async function updateLocalProvider(
 			: request.capabilities === null
 				? undefined
 				: [...new Set(request.capabilities)];
+	const protocol =
+		request.protocol === undefined
+			? existingEntry.provider.protocol
+			: (request.protocol ?? undefined);
+	const client =
+		request.client === undefined
+			? existingEntry.provider.client
+			: (request.client ?? undefined);
 
 	const explicitModels = uniqueTrimmed(request.models);
 	const nextModelsSourceUrl =
@@ -408,7 +454,7 @@ export async function updateLocalProvider(
 	const shouldRecomputeModels =
 		request.models !== undefined ||
 		(request.modelsSourceUrl !== undefined && !!nextModelsSourceUrl);
-	const existingModelIds = Object.keys(existingEntry.models)
+	const existingModelIds = Object.keys(existingEntry.models ?? {})
 		.map((id) => id.trim())
 		.filter(Boolean);
 	const modelIds = await resolveModelIds({
@@ -440,6 +486,10 @@ export async function updateLocalProvider(
 		baseUrl,
 		model: defaultModelId,
 	};
+	if (protocol) nextSettings.protocol = protocol;
+	else delete nextSettings.protocol;
+	if (client) nextSettings.client = client;
+	else delete nextSettings.client;
 	if (request.apiKey !== undefined) {
 		const apiKey = request.apiKey?.trim() ?? "";
 		if (apiKey) nextSettings.apiKey = apiKey;
@@ -465,6 +515,8 @@ export async function updateLocalProvider(
 			name: providerName,
 			baseUrl,
 			defaultModelId,
+			protocol,
+			client,
 			capabilities,
 			modelsSourceUrl: nextModelsSourceUrl,
 		},
@@ -541,6 +593,8 @@ export async function listLocalProviders(
 					: undefined,
 				baseUrl: persistedSettings?.baseUrl ?? info?.baseUrl,
 				defaultModelId: info?.defaultModelId,
+				protocol: persistedSettings?.protocol ?? info?.protocol,
+				client: persistedSettings?.client ?? info?.client,
 				authDescription: "This provider uses API keys for authentication.",
 				baseUrlDescription: "The base endpoint to use for provider requests.",
 				modelList,
@@ -596,6 +650,9 @@ export function saveLocalProviderSettings(
 		"contextWindow",
 		"timeout",
 		"apiLine",
+		"protocol",
+		"client",
+		"routingProviderId",
 		"capabilities",
 	] as const) {
 		if (Object.hasOwn(request, key)) next[key] = request[key];
@@ -640,9 +697,12 @@ function toProviderApiKey(
 	providerId: OAuthProviderId,
 	credentials: { access: string },
 ): string {
-	return providerId === "cline"
-		? `workos:${credentials.access}`
-		: credentials.access;
+	if (providerId === "cline") {
+		return credentials.access.startsWith("workos:")
+			? credentials.access
+			: `workos:${credentials.access}`;
+	}
+	return credentials.access;
 }
 
 export async function loginLocalProvider(

package/src/services/session-data.ts

@@ -153,22 +153,24 @@ export function withLatestAssistantTurnMetadata(
 		assistantIndexes.push(next.length - 1 - lastAssistantIndex);
 	}
 
-	const usage = result.usage;
-	const lastAssistantIndexForUsage =
-		assistantIndexes[assistantIndexes.length - 1];
+	const lastAssistantIndex = 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;
+		// Use per-turn metrics already stamped on the message if available.
+		// Only fall back to result.usage (total run usage) for the terminal
+		// assistant message when no per-turn metrics are present, to avoid
+		// attaching session totals to intermediate turn messages.
+		let metrics = target.metrics;
+		if (!metrics && targetIndex === lastAssistantIndex) {
+			const usage = result.usage;
+			metrics = {
+				inputTokens: usage.inputTokens,
+				outputTokens: usage.outputTokens,
+				cacheReadTokens: usage.cacheReadTokens ?? 0,
+				cacheWriteTokens: usage.cacheWriteTokens ?? 0,
+				cost: usage.totalCost,
+			};
+		}
 		next[targetIndex] = {
 			...normalizeStoredMessageModelMetadata(target, {
 				id: result.model.id,

package/src/services/session-telemetry.ts

@@ -1,7 +1,6 @@
 import type { ITelemetryService } from "@clinebot/shared";
 import { resolveDocumentsExtensionPath } from "@clinebot/shared/storage";
 import { listHookConfigFiles } from "../extensions/config/hooks-config-loader";
-import type { SessionSource } from "../types/common";
 import type { CoreSessionConfig } from "../types/config";
 import {
 	captureHookDiscovery,
@@ -14,10 +13,15 @@ import {
 } from "./telemetry/core-events";
 import type { enrichPromptWithMentions } from "./workspace";
 
+/**
+ * Emits local-only session creation telemetry (task.created/restarted and
+ * hook discovery). The transport-agnostic `session.started` event is
+ * emitted from `ClineCore.start` so it fires for every backend (local,
+ * hub, remote) at the outer API boundary.
+ */
 export function emitSessionCreationTelemetry(
 	config: CoreSessionConfig,
 	sessionId: string,
-	source: SessionSource,
 	isRestart: boolean,
 	workspacePath: string,
 	agentIdentity?: Partial<TelemetryAgentIdentityProperties>,
@@ -36,19 +40,6 @@ export function emitSessionCreationTelemetry(
 		});
 	}
 	captureHookDiscoveryTelemetry(config.telemetry, { workspacePath });
-	config.telemetry?.capture({
-		event: "session.started",
-		properties: {
-			sessionId,
-			source,
-			providerId: config.providerId,
-			modelId: config.modelId,
-			enableTools: config.enableTools,
-			enableSpawnAgent: config.enableSpawnAgent,
-			enableAgentTeams: config.enableAgentTeams,
-			...agentIdentity,
-		},
-	});
 }
 
 export function captureHookDiscoveryTelemetry(

package/src/services/storage/file-team-store.ts

@@ -138,16 +138,12 @@ export class FileTeamStore implements TeamStore {
 
 	loadRuntime(teamName: string): TeamRuntimeLoadResult {
 		const envelope = this.readEnvelope(teamName);
-		const interruptedRunIds = this.markInProgressRunsInterrupted(
-			teamName,
-			"runtime_recovered",
-		);
 		return {
 			state: envelope?.teamState
 				? reviveTeamRuntimeStateDates(envelope.teamState)
 				: undefined,
 			teammates: envelope?.teammates ?? [],
-			interruptedRunIds,
+			interruptedRunIds: [],
 		};
 	}