@clinebot/core 0.0.34 → 0.0.36

package/src/services/local-runtime-bootstrap.ts

@@ -0,0 +1,318 @@
+import type {
+	AgentConfig,
+	AgentHooks,
+	ITelemetryService,
+	Tool,
+	ToolApprovalRequest,
+	ToolApprovalResult,
+	WorkspaceInfo,
+} from "@clinebot/shared";
+import { resolveAndLoadAgentPlugins } from "../extensions/plugin/plugin-config-loader";
+import type {
+	PluginInitializationFailure,
+	PluginInitializationWarning,
+} from "../extensions/plugin/plugin-load-report";
+import type { ToolExecutors } from "../extensions/tools";
+import type { TeamEvent } from "../extensions/tools/team";
+import { createCheckpointHooks } from "../hooks/checkpoint-hooks";
+import {
+	createHookAuditHooks,
+	createHookConfigFileHooks,
+	mergeAgentHooks,
+} from "../hooks/hook-file-hooks";
+import type {
+	LocalRuntimeConfigOverrides,
+	LocalRuntimeStartOptions,
+	StartSessionInput,
+} from "../runtime/runtime-host";
+import type { RuntimeBuilderInput } from "../runtime/session-runtime";
+import type { CoreSessionConfig } from "../types/config";
+import {
+	type ProviderConfig,
+	type ProviderSettings,
+	toProviderConfig,
+} from "../types/provider-settings";
+import { resolveWorkspacePath } from "./config";
+import { filterExtensionToolRegistrations } from "./global-settings";
+import { hasRuntimeHooks, mergeAgentExtensions } from "./session-data";
+import type { ProviderSettingsManager } from "./storage/provider-settings-manager";
+import { buildWorkspaceMetadataWithInfo } from "./workspace-manifest";
+
+function formatPluginFailure(failure: PluginInitializationFailure): string {
+	const label = failure.pluginName ?? failure.pluginPath;
+	return `${label}: ${failure.message}`;
+}
+
+function logPluginDiagnostics(
+	failures: PluginInitializationFailure[],
+	warnings: PluginInitializationWarning[],
+	logger: CoreSessionConfig["logger"],
+): void {
+	if (warnings.length > 0) {
+		for (const warning of warnings) {
+			logger?.log(warning.message, { severity: "warn" });
+		}
+	}
+	if (failures.length === 0) {
+		return;
+	}
+	const preview = failures.slice(0, 3).map(formatPluginFailure).join("; ");
+	const suffix = failures.length > 3 ? `; and ${failures.length - 3} more` : "";
+	logger?.log(
+		`Some plugins failed to initialize. ${preview}${suffix}. Use --verbose for more details.`,
+		{ severity: "warn" },
+	);
+	for (const failure of failures) {
+		logger?.log(
+			`Plugin initialization failed (${failure.phase}) for ${failure.pluginPath}`,
+			{
+				severity: "warn",
+				stack: failure.stack,
+				pluginPath: failure.pluginPath,
+				pluginName: failure.pluginName,
+			},
+		);
+	}
+}
+
+function resolveReasoningSettings(
+	config: CoreSessionConfig,
+	storedReasoning: ProviderSettings["reasoning"],
+): ProviderSettings["reasoning"] {
+	const hasThinking = typeof config.thinking === "boolean";
+	const hasEffort = typeof config.reasoningEffort === "string";
+	if (!hasThinking && !hasEffort) return storedReasoning;
+	return {
+		...(storedReasoning ?? {}),
+		...(hasThinking ? { enabled: config.thinking } : {}),
+		...(hasEffort ? { effort: config.reasoningEffort } : {}),
+	};
+}
+
+function buildProviderConfig(
+	config: CoreSessionConfig,
+	providerSettingsManager: ProviderSettingsManager,
+	modelCatalogDefaults?: Partial<ProviderSettings["modelCatalog"]>,
+	defaultFetch?: typeof fetch,
+): ProviderConfig {
+	const stored = providerSettingsManager.getProviderSettings(config.providerId);
+	const modelCatalog =
+		modelCatalogDefaults || stored?.modelCatalog
+			? {
+					...(modelCatalogDefaults ?? {}),
+					...(stored?.modelCatalog ?? {}),
+				}
+			: undefined;
+	const settings: ProviderSettings = {
+		...(stored ?? {}),
+		provider: config.providerId,
+		model: config.modelId,
+		apiKey: config.apiKey ?? stored?.apiKey,
+		baseUrl: config.baseUrl ?? stored?.baseUrl,
+		headers: config.headers ?? stored?.headers,
+		reasoning: resolveReasoningSettings(config, stored?.reasoning),
+		modelCatalog,
+	};
+	const providerConfig = toProviderConfig(settings);
+	if (config.knownModels) {
+		providerConfig.knownModels = config.knownModels;
+	}
+	if (config.extensionContext) {
+		providerConfig.extensionContext = config.extensionContext;
+	}
+	// Thread a host-provided custom fetch through to the AI gateway providers.
+	// Precedence: explicit per-session config > stored provider settings > host default.
+	const sessionFetch = (config as { fetch?: typeof fetch }).fetch;
+	const resolvedFetch = sessionFetch ?? providerConfig.fetch ?? defaultFetch;
+	if (resolvedFetch) {
+		providerConfig.fetch = resolvedFetch;
+	}
+	return providerConfig;
+}
+
+export interface PrepareLocalRuntimeBootstrapOptions {
+	input: StartSessionInput;
+	localRuntime?: LocalRuntimeStartOptions;
+	sessionId: string;
+	providerSettingsManager: ProviderSettingsManager;
+	defaultTelemetry?: ITelemetryService;
+	defaultToolExecutors?: Partial<ToolExecutors>;
+	defaultToolPolicies?: AgentConfig["toolPolicies"];
+	defaultRequestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult>;
+	/**
+	 * Host-level default `fetch` threaded into `ProviderConfig.fetch` so the
+	 * AI gateway providers can use a custom HTTP implementation.
+	 */
+	defaultFetch?: typeof fetch;
+	onPluginEvent: (event: { name: string; payload?: unknown }) => void;
+	onTeamEvent: (event: TeamEvent) => void;
+	createSpawnTool: () => Tool;
+	readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
+	writeSessionMetadata: (
+		metadata: Record<string, unknown>,
+	) => Promise<void> | void;
+}
+
+export interface LocalRuntimeBootstrap {
+	effectiveInput: StartSessionInput;
+	config: CoreSessionConfig;
+	providerConfig: ProviderConfig;
+	workspaceMetadata: string;
+	/** Structured git + path metadata generated alongside workspaceMetadata. */
+	workspaceInfo: WorkspaceInfo;
+	extensions: AgentConfig["extensions"];
+	hooks: AgentHooks | undefined;
+	toolPolicies: AgentConfig["toolPolicies"];
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult>;
+	pluginSandboxShutdown?: () => Promise<void>;
+	runtimeBuilderInput: RuntimeBuilderInput;
+}
+
+export async function prepareLocalRuntimeBootstrap(
+	options: PrepareLocalRuntimeBootstrapOptions,
+): Promise<LocalRuntimeBootstrap> {
+	const {
+		input,
+		sessionId,
+		providerSettingsManager,
+		defaultTelemetry,
+		defaultToolExecutors,
+		defaultToolPolicies,
+		defaultRequestToolApproval,
+		defaultFetch,
+		onPluginEvent,
+		onTeamEvent,
+		createSpawnTool,
+		localRuntime,
+		readSessionMetadata,
+		writeSessionMetadata,
+	} = options;
+	const workspacePath = resolveWorkspacePath(input.config);
+	const configOverrides = localRuntime?.configOverrides as
+		| Partial<LocalRuntimeConfigOverrides>
+		| undefined;
+	const localConfig = configOverrides as Partial<CoreSessionConfig> | undefined;
+
+	// Generate workspace + git metadata once, early, so it can be forwarded to
+	// hooks and extensions. The serialized string goes into CoreSessionConfig
+	// as workspaceMetadata; the structured object is kept as workspaceInfo.
+	const { workspaceInfo, workspaceMetadata } =
+		await buildWorkspaceMetadataWithInfo(input.config.cwd);
+
+	const fileHooks = createHookConfigFileHooks({
+		cwd: input.config.cwd,
+		workspacePath,
+		rootSessionId: sessionId,
+		logger: configOverrides?.logger,
+		workspaceInfo,
+	});
+	const auditHooks = hasRuntimeHooks(configOverrides?.hooks)
+		? undefined
+		: createHookAuditHooks({
+				rootSessionId: sessionId,
+				workspacePath,
+				workspaceInfo,
+			});
+	const baseHooks = mergeAgentHooks([
+		configOverrides?.hooks,
+		fileHooks,
+		auditHooks,
+	]);
+
+	let loadedPlugins:
+		| Awaited<ReturnType<typeof resolveAndLoadAgentPlugins>>
+		| undefined;
+	try {
+		loadedPlugins = await resolveAndLoadAgentPlugins({
+			pluginPaths: localConfig?.pluginPaths,
+			workspacePath,
+			cwd: input.config.cwd,
+			onEvent: onPluginEvent,
+			providerId: input.config.providerId,
+			modelId: input.config.modelId,
+			workspaceInfo,
+		});
+		logPluginDiagnostics(
+			loadedPlugins.failures,
+			loadedPlugins.warnings,
+			configOverrides?.logger,
+		);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		configOverrides?.logger?.log?.(
+			`plugin loading failed; continuing without plugins (${message})`,
+		);
+	}
+
+	const extensions = mergeAgentExtensions(
+		configOverrides?.extensions,
+		filterExtensionToolRegistrations(loadedPlugins?.extensions),
+	);
+	const baseConfig: CoreSessionConfig = {
+		...input.config,
+		...(configOverrides ?? {}),
+		hooks: baseHooks,
+		extensions,
+		telemetry: configOverrides?.telemetry ?? defaultTelemetry,
+	};
+	const providerConfig = buildProviderConfig(
+		baseConfig,
+		providerSettingsManager,
+		localRuntime?.modelCatalogDefaults,
+		defaultFetch,
+	);
+	const hooks = mergeAgentHooks([
+		baseConfig.hooks,
+		baseConfig.checkpoint?.enabled === true
+			? createCheckpointHooks({
+					cwd: baseConfig.cwd,
+					sessionId,
+					logger: baseConfig.logger,
+					createCheckpoint: baseConfig.checkpoint?.createCheckpoint,
+					readSessionMetadata,
+					writeSessionMetadata,
+				})
+			: undefined,
+	]);
+	const config: CoreSessionConfig = {
+		...baseConfig,
+		providerConfig,
+		workspaceMetadata,
+		hooks,
+	};
+	const toolPolicies =
+		input.toolPolicies ?? baseConfig.toolPolicies ?? defaultToolPolicies;
+	const requestToolApproval =
+		input.requestToolApproval ?? defaultRequestToolApproval;
+	const effectiveToolExecutors =
+		localRuntime?.defaultToolExecutors ?? defaultToolExecutors;
+
+	return {
+		effectiveInput: input,
+		config,
+		providerConfig,
+		workspaceMetadata,
+		workspaceInfo,
+		extensions,
+		hooks,
+		toolPolicies,
+		requestToolApproval,
+		pluginSandboxShutdown: loadedPlugins?.shutdown,
+		runtimeBuilderInput: {
+			config,
+			hooks,
+			extensions,
+			onTeamEvent,
+			createSpawnTool,
+			onTeamRestored: localRuntime?.onTeamRestored,
+			userInstructionWatcher: localRuntime?.userInstructionWatcher,
+			defaultToolExecutors: effectiveToolExecutors,
+			logger: config.logger,
+			telemetry: config.telemetry,
+		},
+	};
+}

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/{providers → 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/{providers → 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 { 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;