codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/services/llms/configured-provider-registry.ts

@@ -0,0 +1,193 @@
+import type { ProviderConfig } from "./provider-settings";
+import type {
+	BuiltInProviderSummary,
+	CreateHandlerInput,
+	ProviderConfigDefaults,
+	ProviderSelectionConfig,
+	RegisteredProviderSummary,
+} from "./runtime-types";
+
+interface ConfiguredProviderRecord {
+	id: string;
+	models: Set<string>;
+	defaultModel: string;
+	defaults: ProviderConfigDefaults;
+}
+
+interface RegisterConfiguredProviderInput {
+	id: string;
+	models: readonly string[];
+	defaultModel?: string;
+	defaults?: ProviderConfigDefaults;
+}
+
+function cloneDefaults(
+	defaults: ProviderConfigDefaults | undefined,
+): ProviderConfigDefaults {
+	return defaults ? { ...defaults } : {};
+}
+
+function resolveApiKey(
+	apiKey?: string,
+	apiKeyEnv?: string,
+): string | undefined {
+	if (apiKey) {
+		return apiKey;
+	}
+	if (!apiKeyEnv) {
+		return undefined;
+	}
+	const runtimeProcess = globalThis.process;
+	if (!runtimeProcess?.env) {
+		return undefined;
+	}
+	return runtimeProcess.env[apiKeyEnv];
+}
+
+function assertNonEmptyModels(
+	providerId: string,
+	models: readonly string[],
+): void {
+	if (!models.length) {
+		throw new Error(
+			`Provider "${providerId}" must include at least one model.`,
+		);
+	}
+}
+
+export function toBuiltInProviderSummary(input: {
+	collection: BuiltInProviderSummary["id"] extends string
+		? {
+				provider: Pick<
+					import("@cline/llms").ProviderInfo,
+					| "id"
+					| "name"
+					| "description"
+					| "protocol"
+					| "baseUrl"
+					| "capabilities"
+					| "env"
+					| "defaultModelId"
+				>;
+				models: Record<string, unknown>;
+			}
+		: never;
+}): BuiltInProviderSummary {
+	const models = Object.keys(input.collection.models);
+	return {
+		id: input.collection.provider.id,
+		name: input.collection.provider.name,
+		description: input.collection.provider.description,
+		protocol: input.collection.provider.protocol,
+		baseUrl: input.collection.provider.baseUrl,
+		capabilities: input.collection.provider.capabilities,
+		env: input.collection.provider.env,
+		models,
+		defaultModel: input.collection.provider.defaultModelId,
+		modelCount: models.length,
+	};
+}
+
+export class ConfiguredProviderRegistry {
+	private readonly providers = new Map<string, ConfiguredProviderRecord>();
+
+	register(input: RegisterConfiguredProviderInput): void {
+		assertNonEmptyModels(input.id, input.models);
+		const defaultModel = input.defaultModel ?? input.models[0];
+		if (!defaultModel) {
+			throw new Error(`Provider "${input.id}" must define a default model.`);
+		}
+		if (!input.models.includes(defaultModel)) {
+			throw new Error(
+				`Default model "${defaultModel}" is not included in configured models for "${input.id}".`,
+			);
+		}
+		const existing = this.providers.get(input.id);
+		this.providers.set(input.id, {
+			id: input.id,
+			models: new Set([...(existing?.models ?? []), ...input.models]),
+			defaultModel,
+			defaults: {
+				...(existing?.defaults ?? {}),
+				...cloneDefaults(input.defaults),
+			},
+		});
+	}
+
+	registerSelectionConfig(provider: ProviderSelectionConfig): void {
+		this.register({
+			id: provider.id,
+			models: provider.models,
+			defaultModel: provider.defaultModel,
+			defaults: {
+				apiKey: resolveApiKey(provider.apiKey, provider.apiKeyEnv),
+				routingProviderId: provider.builtinProviderId,
+				baseUrl: provider.baseUrl,
+				headers: provider.headers,
+				timeoutMs: provider.timeoutMs,
+				capabilities: provider.capabilities,
+				...cloneDefaults(provider.settings),
+			},
+		});
+	}
+
+	registerModel(providerId: string, modelId: string): void {
+		const existing = this.providers.get(providerId);
+		if (!existing) {
+			this.providers.set(providerId, {
+				id: providerId,
+				models: new Set([modelId]),
+				defaultModel: modelId,
+				defaults: {},
+			});
+			return;
+		}
+		existing.models.add(modelId);
+	}
+
+	createHandlerConfig(input: CreateHandlerInput): ProviderConfig {
+		const provider = this.require(input.providerId);
+		const modelId = input.modelId ?? provider.defaultModel;
+		if (!provider.models.has(modelId)) {
+			throw new Error(
+				`Model "${modelId}" is not configured for provider "${input.providerId}".`,
+			);
+		}
+		return {
+			providerId: input.providerId,
+			modelId,
+			...provider.defaults,
+			...input.overrides,
+		};
+	}
+
+	list(): RegisteredProviderSummary[] {
+		return Array.from(this.providers.values()).map((provider) => ({
+			id: provider.id,
+			models: Array.from(provider.models),
+			defaultModel: provider.defaultModel,
+		}));
+	}
+
+	getModels(providerId: string): string[] {
+		return Array.from(this.require(providerId).models);
+	}
+
+	hasProvider(providerId: string): boolean {
+		return this.providers.has(providerId);
+	}
+
+	hasModel(providerId: string, modelId: string): boolean {
+		return this.providers.get(providerId)?.models.has(modelId) ?? false;
+	}
+
+	private require(providerId: string): ConfiguredProviderRecord {
+		const provider = this.providers.get(providerId);
+		if (!provider) {
+			throw new Error(
+				`Provider "${providerId}" is not configured in this SDK instance.`,
+			);
+		}
+		return provider;
+	}
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/services/llms/handler-factory.test.ts

@@ -0,0 +1,288 @@
+import type { AgentConfig, AgentModel, ITelemetryService } from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const gatewayMock = vi.hoisted(() => {
+	const createAgentModel = vi.fn();
+	return {
+		createAgentModel,
+		createGateway: vi.fn(() => ({ createAgentModel })),
+		// Registry helpers used by createAgentModelFromConfig. Default to "no
+		// registered handler" so existing tests exercise the gateway path.
+		hasRegisteredHandler: vi.fn(() => false),
+		createHandlerAsync: vi.fn(),
+	};
+});
+
+vi.mock("@cline/llms", () => ({
+	createGateway: gatewayMock.createGateway,
+	MODEL_COLLECTIONS_BY_PROVIDER_ID: {},
+	hasRegisteredHandler: gatewayMock.hasRegisteredHandler,
+	createHandlerAsync: gatewayMock.createHandlerAsync,
+	normalizeProviderId: (id: string) => id,
+}));
+
+describe("createAgentModelFromConfig", () => {
+	beforeEach(() => {
+		gatewayMock.createAgentModel.mockReset();
+		gatewayMock.createGateway.mockClear();
+		gatewayMock.createGateway.mockImplementation(() => ({
+			createAgentModel: gatewayMock.createAgentModel,
+		}));
+		gatewayMock.hasRegisteredHandler.mockReset();
+		gatewayMock.hasRegisteredHandler.mockReturnValue(false);
+		gatewayMock.createHandlerAsync.mockReset();
+	});
+
+	it("forwards effective telemetry into the gateway", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+		const logger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const telemetry = {
+			capture: vi.fn(),
+		} as unknown as ITelemetryService;
+		const model = {} as AgentModel;
+		gatewayMock.createAgentModel.mockReturnValue(model);
+
+		const result = createAgentModelFromConfig(
+			{
+				providerId: "mock-provider",
+				modelId: "mock-model",
+				apiKey: "key",
+				systemPrompt: "",
+				tools: [],
+			},
+			logger,
+			telemetry,
+		);
+
+		expect(result).toBe(model);
+		expect(gatewayMock.createGateway).toHaveBeenCalledWith(
+			expect.objectContaining({
+				logger,
+				telemetry,
+			}),
+		);
+	});
+
+	it("falls back to config telemetry when no override is supplied", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+		const telemetry = {
+			capture: vi.fn(),
+		} as unknown as ITelemetryService;
+
+		createAgentModelFromConfig(
+			{
+				providerId: "mock-provider",
+				modelId: "mock-model",
+				apiKey: "key",
+				systemPrompt: "",
+				tools: [],
+				telemetry,
+			},
+			undefined,
+		);
+
+		expect(gatewayMock.createGateway).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				telemetry,
+			}),
+		);
+	});
+
+	it("preserves model capabilities and metadata when configuring gateway models", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		createAgentModelFromConfig(
+			{
+				providerId: "openrouter",
+				modelId: "qwen/qwen3.6-plus",
+				apiKey: "test-key",
+				systemPrompt: "",
+				tools: [],
+				knownModels: {
+					"qwen/qwen3.6-plus": {
+						id: "qwen/qwen3.6-plus",
+						name: "Qwen3.6 Plus",
+						contextWindow: 1_000_000,
+						maxInputTokens: 1_000_000,
+						maxTokens: 65_536,
+						capabilities: [
+							"tools",
+							"reasoning",
+							"structured_output",
+							"prompt-cache",
+						],
+						pricing: {
+							input: 0.325,
+							output: 1.95,
+							cacheRead: 0.0325,
+							cacheWrite: 0.40625,
+						},
+						releaseDate: "2026-04-02",
+						family: "qwen",
+					},
+				},
+			} satisfies AgentConfig,
+			undefined,
+		);
+
+		const gatewayConfig = (
+			gatewayMock.createGateway.mock.calls as unknown as Array<
+				[
+					{
+						providerConfigs: Array<{
+							models: Array<Record<string, unknown>>;
+						}>;
+					},
+				]
+			>
+		)[0][0];
+		const model = gatewayConfig.providerConfigs[0].models[0];
+		expect(model).toMatchObject({
+			id: "qwen/qwen3.6-plus",
+			name: "Qwen3.6 Plus",
+			contextWindow: 1_000_000,
+			maxInputTokens: 1_000_000,
+			maxOutputTokens: 65_536,
+			capabilities: expect.arrayContaining([
+				"text",
+				"tools",
+				"reasoning",
+				"structured-output",
+				"prompt-cache",
+			]),
+			metadata: {
+				family: "qwen",
+				pricing: {
+					input: 0.325,
+					output: 1.95,
+					cacheRead: 0.0325,
+					cacheWrite: 0.40625,
+				},
+				releaseDate: "2026-04-02",
+			},
+		});
+	});
+
+	it("forwards Bedrock AWS settings as gateway provider options", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		createAgentModelFromConfig(
+			{
+				providerId: "bedrock",
+				modelId: "anthropic.claude-sonnet-4-5-20250929-v1:0",
+				systemPrompt: "",
+				tools: [],
+				providerConfig: {
+					providerId: "bedrock",
+					modelId: "anthropic.claude-sonnet-4-5-20250929-v1:0",
+					region: "us-west-2",
+					aws: {
+						authentication: "profile",
+						profile: "dev-profile",
+					},
+				},
+			},
+			undefined,
+		);
+
+		expect(gatewayMock.createGateway).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				providerConfigs: [
+					expect.objectContaining({
+						providerId: "bedrock",
+						options: expect.objectContaining({
+							region: "us-west-2",
+							authentication: "profile",
+							profile: "dev-profile",
+						}),
+					}),
+				],
+			}),
+		);
+	});
+
+	it("forwards Vertex GCP settings as gateway provider options", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		createAgentModelFromConfig(
+			{
+				providerId: "vertex",
+				modelId: "gemini-3-flash-preview",
+				systemPrompt: "",
+				tools: [],
+				providerConfig: {
+					providerId: "vertex",
+					modelId: "gemini-3-flash-preview",
+					gcp: {
+						projectId: "test-project",
+						region: "global",
+					},
+				},
+			},
+			undefined,
+		);
+
+		expect(gatewayMock.createGateway).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				providerConfigs: [
+					expect.objectContaining({
+						providerId: "vertex",
+						options: expect.objectContaining({
+							project: "test-project",
+							projectId: "test-project",
+							location: "global",
+							region: "global",
+						}),
+					}),
+				],
+			}),
+		);
+	});
+
+	it("uses a registered handler (adapter) instead of the gateway, building it lazily", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		// Pretend a host handler is registered for this provider.
+		gatewayMock.hasRegisteredHandler.mockReturnValue(true);
+		const apiHandler = {
+			getMessages: () => [],
+			getModel: () => ({ id: "vscode-lm", info: { id: "vscode-lm" } }),
+			// eslint-disable-next-line require-yield
+			async *createMessage() {
+				/* no chunks for this assertion */
+			},
+		};
+		// createHandlerAsync resolves both sync- and async-registered handlers.
+		gatewayMock.createHandlerAsync.mockResolvedValue(apiHandler);
+
+		const result = createAgentModelFromConfig(
+			{
+				providerId: "vscode-lm",
+				modelId: "copilot/claude-sonnet",
+				apiKey: "",
+				systemPrompt: "",
+				tools: [],
+			},
+			undefined,
+		);
+
+		// The gateway is not used, and the AgentModel surface is exposed.
+		expect(gatewayMock.createGateway).not.toHaveBeenCalled();
+		expect(typeof result.stream).toBe("function");
+
+		// The handler is resolved lazily — only once the stream is consumed.
+		expect(gatewayMock.createHandlerAsync).not.toHaveBeenCalled();
+		for await (const _ of await result.stream({
+			systemPrompt: "",
+			messages: [],
+			tools: [],
+		})) {
+			// drain
+		}
+		expect(gatewayMock.createHandlerAsync).toHaveBeenCalledTimes(1);
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/services/llms/handler-factory.ts

@@ -0,0 +1,197 @@
+import {
+	createGateway,
+	createHandlerAsync,
+	hasRegisteredHandler,
+	MODEL_COLLECTIONS_BY_PROVIDER_ID,
+	normalizeProviderId,
+} from "@cline/llms";
+import type {
+	AgentConfig,
+	AgentModel,
+	BasicLogger,
+	GatewayModelDefinition,
+	ITelemetryService,
+	ModelInfo,
+} from "@cline/shared";
+import { createAgentModelFromApiHandler } from "./apihandler-agent-model-adapter";
+import type { ProviderConfig } from "./provider-settings";
+
+function compactOptions(
+	options: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+	const compacted = Object.fromEntries(
+		Object.entries(options).filter(([, value]) => value !== undefined),
+	);
+	return Object.keys(compacted).length > 0 ? compacted : undefined;
+}
+
+function buildGatewayProviderOptions(
+	config: ProviderConfig,
+): Record<string, unknown> | undefined {
+	const options: Record<string, unknown> = {
+		region: config.region,
+		apiLine: config.apiLine,
+		openRouterProviderSorting: config.openRouterProviderSorting,
+		modelCatalog: config.modelCatalog,
+	};
+
+	if (config.providerId === "bedrock") {
+		Object.assign(options, {
+			authentication: config.aws?.authentication,
+			profile: config.aws?.profile,
+			accessKeyId: config.aws?.accessKey,
+			secretAccessKey: config.aws?.secretKey,
+			sessionToken: config.aws?.sessionToken,
+			usePromptCache: config.aws?.usePromptCache,
+			useCrossRegionInference: config.useCrossRegionInference,
+			useGlobalInference: config.useGlobalInference,
+			endpoint: config.aws?.endpoint,
+			customModelBaseId: config.aws?.customModelBaseId,
+		});
+	}
+
+	if (config.providerId === "vertex") {
+		const gcpRegion = config.gcp?.region ?? config.region;
+		Object.assign(options, {
+			project: config.gcp?.projectId,
+			projectId: config.gcp?.projectId,
+			location: gcpRegion,
+			region: gcpRegion,
+		});
+	}
+
+	return compactOptions(options);
+}
+
+export function resolveKnownModelsFromConfig(
+	config: AgentConfig,
+): Record<string, ModelInfo> | undefined {
+	const pc = config.providerConfig as ProviderConfig | undefined;
+	if (pc?.knownModels) {
+		return pc.knownModels;
+	}
+	if (config.knownModels) {
+		return config.knownModels;
+	}
+	return (
+		MODEL_COLLECTIONS_BY_PROVIDER_ID[config.providerId]?.models ?? undefined
+	);
+}
+
+function toGatewayCapabilities(
+	capabilities: ModelInfo["capabilities"],
+): GatewayModelDefinition["capabilities"] {
+	if (!capabilities?.length) {
+		return undefined;
+	}
+
+	const mapped = new Set<
+		NonNullable<GatewayModelDefinition["capabilities"]>[number]
+	>();
+	for (const capability of capabilities) {
+		switch (capability) {
+			case "tools":
+			case "reasoning":
+			case "prompt-cache":
+			case "images":
+				mapped.add(capability);
+				break;
+			case "structured_output":
+				mapped.add("structured-output");
+				break;
+			default:
+				mapped.add("text");
+		}
+	}
+
+	mapped.add("text");
+	return [...mapped];
+}
+
+function toGatewayConfiguredModel(
+	id: string,
+	model: ModelInfo,
+): Omit<GatewayModelDefinition, "providerId"> {
+	return {
+		id,
+		name: model.name ?? id,
+		description: model.description,
+		contextWindow: model.contextWindow,
+		maxInputTokens: model.maxInputTokens,
+		maxOutputTokens: model.maxTokens,
+		capabilities: toGatewayCapabilities(model.capabilities),
+		metadata: {
+			family: model.family,
+			pricing: model.pricing,
+			status: model.status,
+			releaseDate: model.releaseDate,
+		},
+	};
+}
+
+export function createAgentModelFromConfig(
+	config: AgentConfig,
+	logger: BasicLogger | undefined,
+	telemetry?: ITelemetryService,
+): AgentModel {
+	const pc = config.providerConfig as ProviderConfig | undefined;
+	const baseProviderConfig =
+		pc?.providerId === config.providerId ? pc : undefined;
+	const normalizedProviderConfig: ProviderConfig = {
+		...(baseProviderConfig ?? {}),
+		providerId: config.providerId,
+		modelId: config.modelId,
+		apiKey: config.apiKey ?? baseProviderConfig?.apiKey,
+		baseUrl: config.baseUrl ?? baseProviderConfig?.baseUrl,
+		headers: config.headers ?? baseProviderConfig?.headers,
+		knownModels: resolveKnownModelsFromConfig(config),
+		maxOutputTokens: config.maxTokensPerTurn,
+		reasoningEffort: config.reasoningEffort,
+		thinkingBudgetTokens: config.thinkingBudgetTokens,
+		thinking: config.thinking,
+		logger,
+		extensionContext: config.extensionContext,
+	};
+
+	// Host-registered custom handlers (e.g. VS Code LM, which needs the host's
+	// `vscode.lm` API) are not part of the gateway. When a handler is registered
+	// for this provider, adapt its `ApiHandler` surface onto the `AgentModel`
+	// contract the runtime expects. The handler is built lazily (via
+	// `createHandlerAsync`) on the first stream so that providers registered
+	// with `registerAsyncHandler` resolve correctly.
+	if (
+		hasRegisteredHandler(
+			normalizeProviderId(normalizedProviderConfig.providerId),
+		)
+	) {
+		return createAgentModelFromApiHandler(() =>
+			createHandlerAsync(normalizedProviderConfig),
+		);
+	}
+
+	return createGateway({
+		providerConfigs: [
+			{
+				providerId: normalizedProviderConfig.providerId,
+				apiKey: normalizedProviderConfig.apiKey,
+				baseUrl: normalizedProviderConfig.baseUrl,
+				headers: normalizedProviderConfig.headers,
+				options: buildGatewayProviderOptions(normalizedProviderConfig),
+				models: normalizedProviderConfig.knownModels
+					? Object.entries(normalizedProviderConfig.knownModels).map(
+							([id, model]) => toGatewayConfiguredModel(id, model),
+						)
+					: undefined,
+			},
+		],
+		logger,
+		telemetry:
+			telemetry ?? config.telemetry ?? config.extensionContext?.telemetry,
+	}).createAgentModel(
+		{
+			providerId: normalizedProviderConfig.providerId,
+			modelId: normalizedProviderConfig.modelId,
+		},
+		{ maxTokens: normalizedProviderConfig.maxOutputTokens },
+	);
+}