codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/services/providers/model-source.ts

@@ -0,0 +1,105 @@
+function parseModelIdList(input: unknown): string[] {
+	if (!Array.isArray(input)) return [];
+	return input
+		.map((item) => {
+			if (typeof item === "string") return item.trim();
+			if (item && typeof item === "object") {
+				const entry = item as { id?: unknown; name?: unknown; model?: unknown };
+				for (const value of [entry.id, entry.name, entry.model]) {
+					if (typeof value === "string" && value.trim()) {
+						return value.trim();
+					}
+				}
+			}
+			return "";
+		})
+		.filter((id) => id.length > 0);
+}
+
+export function extractModelIdsFromPayload(
+	payload: unknown,
+	providerId: string,
+): string[] {
+	const rootArray = parseModelIdList(payload);
+	if (rootArray.length > 0) return rootArray;
+	if (!payload || typeof payload !== "object") return [];
+
+	const data = payload as {
+		data?: unknown;
+		models?: unknown;
+		providers?: Record<string, unknown>;
+	};
+
+	const direct = parseModelIdList(data.data ?? data.models);
+	if (direct.length > 0) return direct;
+
+	if (
+		data.models &&
+		typeof data.models === "object" &&
+		!Array.isArray(data.models)
+	) {
+		const keys = Object.keys(data.models).filter((k) => k.trim().length > 0);
+		if (keys.length > 0) return keys;
+	}
+
+	const scoped = data.providers?.[providerId];
+	if (scoped && typeof scoped === "object") {
+		const nested = scoped as { models?: unknown };
+		const list = parseModelIdList(nested.models ?? scoped);
+		if (list.length > 0) return list;
+	}
+
+	return [];
+}
+
+export async function fetchModelIdsFromSource(
+	url: string,
+	providerId: string,
+): Promise<string[]> {
+	const response = await fetch(url, { method: "GET" });
+	if (!response.ok) {
+		throw new Error(
+			`failed to fetch models from ${url}: HTTP ${response.status}`,
+		);
+	}
+	return extractModelIdsFromPayload(
+		(await response.json()) as unknown,
+		providerId,
+	);
+}
+
+function trimTrailingSlash(value: string): string {
+	return value.replace(/\/+$/, "");
+}
+
+export function resolveModelsSourceUrl(
+	baseUrl: string | undefined,
+	defaultBaseUrl: string | undefined,
+	modelsSourceUrl: string | undefined,
+): string | undefined {
+	const source = modelsSourceUrl?.trim();
+	if (!source) return undefined;
+	const configuredBase = baseUrl?.trim();
+	if (!configuredBase || !defaultBaseUrl?.trim()) return source;
+
+	try {
+		const sourceUrl = new URL(source);
+		const defaultBase = new URL(defaultBaseUrl);
+		const configured = new URL(configuredBase);
+		if (sourceUrl.origin !== defaultBase.origin) return source;
+
+		const defaultPath = trimTrailingSlash(defaultBase.pathname);
+		const configuredPath = trimTrailingSlash(configured.pathname);
+		if (defaultPath && sourceUrl.pathname.startsWith(`${defaultPath}/`)) {
+			const suffix = sourceUrl.pathname.slice(defaultPath.length);
+			configured.pathname = `${configuredPath}${suffix}`;
+		} else {
+			configured.pathname = sourceUrl.pathname;
+		}
+		configured.search = sourceUrl.search;
+		configured.hash = sourceUrl.hash;
+		return configured.toString();
+	} catch {
+		return source;
+	}
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/services/providers/provider-config-fields.test.ts

@@ -0,0 +1,137 @@
+import * as LlmsModels from "@cline/llms";
+import { afterEach, describe, expect, it } from "vitest";
+import { registerCustomProvider } from "./local-provider-registry";
+import { getProviderConfigFields } from "./provider-config-fields";
+
+afterEach(() => {
+	LlmsModels.resetRegistry();
+});
+
+describe("getProviderConfigFields", () => {
+	it("returns api-key auth with only apiKey for cloud providers", () => {
+		const result = getProviderConfigFields("anthropic");
+		expect(result.providerId).toBe("anthropic");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields.apiKey).toEqual({});
+		expect(result.fields.baseUrl).toBeUndefined();
+	});
+
+	it("returns api-key auth with apiKey + baseUrl for ollama", () => {
+		const result = getProviderConfigFields("ollama");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields.apiKey).toEqual({
+			note: "Keep empty if no API key for local inference.",
+		});
+		expect(result.fields.baseUrl?.defaultValue).toBe(
+			"http://localhost:11434/v1",
+		);
+	});
+
+	it("returns api-key auth with apiKey + baseUrl for LM Studio", () => {
+		const result = getProviderConfigFields("lmstudio");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields.apiKey).toEqual({});
+		expect(result.fields.baseUrl?.defaultValue).toBe(
+			"http://localhost:1234/v1",
+		);
+	});
+
+	it("returns api-key auth with apiKey + baseUrl for LiteLLM", () => {
+		const result = getProviderConfigFields("litellm");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields.apiKey).toEqual({});
+		expect(result.fields.baseUrl?.defaultValue).toBe(
+			"http://localhost:4000/v1",
+		);
+	});
+
+	it("returns api-key auth with apiKey + baseUrl for user-added providers", () => {
+		registerCustomProvider("internal-router", {
+			provider: {
+				name: "Internal Router",
+				baseUrl: "https://llm.internal.example/v1",
+				defaultModelId: "alpha",
+				protocol: "openai-responses",
+			},
+			models: {
+				alpha: { name: "Alpha" },
+			},
+		});
+
+		const result = getProviderConfigFields("internal-router");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields.apiKey).toEqual({});
+		expect(result.fields.baseUrl?.defaultValue).toBe(
+			"https://llm.internal.example/v1",
+		);
+	});
+
+	it("returns oauth auth with no fields for cline", () => {
+		const result = getProviderConfigFields("cline");
+		expect(result.authMethod).toBe("oauth");
+		expect(result.fields).toEqual({});
+	});
+
+	it("returns oauth auth with no fields for openai-codex", () => {
+		const result = getProviderConfigFields("openai-codex");
+		expect(result.authMethod).toBe("oauth");
+		expect(result.fields).toEqual({});
+	});
+
+	it("returns local auth with no fields for openai-codex-cli", () => {
+		const result = getProviderConfigFields("openai-codex-cli");
+		expect(result.authMethod).toBe("local");
+		expect(result.fields).toEqual({});
+	});
+
+	it("returns api-key auth with apiKey + baseUrl for OpenAI Compatible", () => {
+		const result = getProviderConfigFields("openai-compatible");
+		expect(result.providerId).toBe("openai-compatible");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields.apiKey).toEqual({});
+		expect(result.fields.baseUrl?.defaultValue).toBe(
+			"https://api.openai.com/v1",
+		);
+	});
+
+	it("returns api-key auth with awsRegion, apiKey, and awsProfile for bedrock", () => {
+		const result = getProviderConfigFields("bedrock");
+		expect(result.providerId).toBe("bedrock");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.description).toMatch(/AWS region/i);
+		expect(Object.keys(result.fields)).toEqual([
+			"awsRegion",
+			"apiKey",
+			"awsProfile",
+		]);
+		expect(result.fields.awsRegion?.label).toBe("AWS Region");
+		expect(result.fields.awsRegion?.placeholder).toBe("us-east-1");
+		expect(result.fields.apiKey?.optional).toBe(true);
+		expect(result.fields.awsProfile?.optional).toBe(true);
+	});
+
+	it("returns SAP AI Core client credential fields instead of a generic API key", () => {
+		const result = getProviderConfigFields("sapaicore");
+		expect(result.providerId).toBe("sapaicore");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.description).toMatch(/not a generic API key/i);
+		expect(Object.keys(result.fields)).toEqual([
+			"baseUrl",
+			"sapClientId",
+			"sapClientSecret",
+			"sapTokenUrl",
+			"sapResourceGroup",
+			"sapDeploymentId",
+		]);
+		expect(result.fields.apiKey).toBeUndefined();
+		expect(result.fields.baseUrl?.label).toBe("AI Core Base URL");
+		expect(result.fields.sapResourceGroup?.optional).toBe(true);
+		expect(result.fields.sapDeploymentId?.optional).toBe(true);
+	});
+
+	it("falls back to a single api-key field for unknown providers", () => {
+		const result = getProviderConfigFields("not-a-real-provider");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields).toEqual({ apiKey: {} });
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/services/providers/provider-config-fields.ts

@@ -0,0 +1,211 @@
+import * as LlmsModels from "@cline/llms";
+import { isOAuthProviderId } from "@cline/shared";
+
+export type ProviderConfigFieldKey =
+	| "apiKey"
+	| "baseUrl"
+	| "awsRegion"
+	| "awsProfile"
+	| "sapClientId"
+	| "sapClientSecret"
+	| "sapTokenUrl"
+	| "sapResourceGroup"
+	| "sapDeploymentId";
+
+export interface ProviderConfigFieldRequirement {
+	defaultValue?: string;
+	label?: string;
+	note?: string;
+	placeholder?: string;
+	optional?: boolean;
+}
+
+export interface ProviderConfigFields {
+	providerId: string;
+	authMethod: "api-key" | "oauth" | "local";
+	fields: Partial<
+		Record<ProviderConfigFieldKey, ProviderConfigFieldRequirement>
+	>;
+	/** Optional description shown above the fields (e.g. AWS region auto-fill hint). */
+	description?: string;
+}
+
+const FIELD_KEYS: ProviderConfigFieldKey[] = [
+	"apiKey",
+	"baseUrl",
+	"awsRegion",
+	"awsProfile",
+	"sapClientId",
+	"sapClientSecret",
+	"sapTokenUrl",
+	"sapResourceGroup",
+	"sapDeploymentId",
+];
+
+interface ProviderConfigFieldMetadata {
+	description?: string;
+	fields: Partial<
+		Record<ProviderConfigFieldKey, ProviderConfigFieldRequirement>
+	>;
+	mode?: "merge" | "replace";
+}
+
+const PROVIDER_CONFIG_FIELD_METADATA: Partial<
+	Record<string, ProviderConfigFieldMetadata>
+> = {
+	bedrock: {
+		mode: "replace",
+		description:
+			"AWS region is required for Bedrock. It can be auto-filled from AWS_REGION, AWS_DEFAULT_REGION, or ~/.aws/config.",
+		fields: {
+			awsRegion: {
+				label: "AWS Region",
+				placeholder: "us-east-1",
+			},
+			apiKey: {
+				label: "AWS Bedrock API Key (optional)",
+				placeholder: "Leave blank to use AWS profile/default chain",
+				optional: true,
+			},
+			awsProfile: {
+				label: "AWS Profile Name (optional)",
+				placeholder: "default",
+				optional: true,
+			},
+		},
+	},
+	ollama: {
+		fields: {
+			apiKey: {
+				note: "Keep empty if no API key for local inference.",
+			},
+		},
+	},
+	sapaicore: {
+		mode: "replace",
+		description:
+			"SAP AI Core uses OAuth client credentials and an AI Core API URL, not a generic API key.",
+		fields: {
+			baseUrl: {
+				label: "AI Core Base URL",
+				placeholder: "https://api.ai.<region>.aws.ml.hana.ondemand.com",
+			},
+			sapClientId: {
+				label: "Client ID",
+				placeholder: "sb-...|xsuaa_std!b...",
+			},
+			sapClientSecret: {
+				label: "Client Secret",
+				placeholder: "SAP AI Core client secret",
+			},
+			sapTokenUrl: {
+				label: "Token URL",
+				placeholder: "https://<subdomain>.authentication.sap.hana.ondemand.com",
+			},
+			sapResourceGroup: {
+				label: "Resource Group",
+				placeholder: "default",
+				optional: true,
+			},
+			sapDeploymentId: {
+				label: "Deployment ID",
+				placeholder: "SAP AI Core deployment id",
+				optional: true,
+			},
+		},
+	},
+};
+
+function mergeFields(
+	baseFields: ProviderConfigFields["fields"],
+	metadataFields: ProviderConfigFieldMetadata["fields"],
+): ProviderConfigFields["fields"] {
+	const fields: ProviderConfigFields["fields"] = {};
+	for (const field of FIELD_KEYS) {
+		const base = baseFields[field];
+		const metadata = metadataFields[field];
+		if (base || metadata) fields[field] = { ...base, ...metadata };
+	}
+	return fields;
+}
+
+function applyProviderConfigFieldMetadata(
+	config: ProviderConfigFields,
+): ProviderConfigFields {
+	const metadata = PROVIDER_CONFIG_FIELD_METADATA[config.providerId];
+	if (!metadata) return config;
+
+	return {
+		...config,
+		description: metadata.description ?? config.description,
+		fields:
+			metadata.mode === "replace"
+				? metadata.fields
+				: mergeFields(config.fields, metadata.fields),
+	};
+}
+
+const EDITABLE_BASE_URL_PROVIDER_IDS = new Set([
+	"ollama",
+	"lmstudio",
+	"litellm",
+	"openai-compatible",
+]);
+
+function shouldExposeBaseUrlField(
+	providerId: string,
+	collection: LlmsModels.ModelCollection | undefined,
+): boolean {
+	if (!collection?.provider.baseUrl) return false;
+	if (collection.provider.source !== "system") return true;
+	return EDITABLE_BASE_URL_PROVIDER_IDS.has(providerId);
+}
+
+/**
+ * Project a provider into the inputs a configure-dialog should render.
+ *
+ * No fields are marked "required". `llms` no longer pre-flights credentials,
+ * so a missing API key surfaces as the provider's own auth error rather than
+ * a synthetic SDK failure. UIs may still require fields client-side if they
+ * want, but the runtime does not.
+ *
+ * - OAuth providers (`cline`, `oca`, `openai-codex`) return `authMethod:
+ *   "oauth"` with no fields; the configure UI should route to the OAuth
+ *   login flow instead.
+ * - Local auth providers return `authMethod: "local"` with no fields. The
+ *   configure UI should show provider-specific local readiness instead.
+ * - All other providers return `apiKey`. Built-in local/proxy-style providers
+ *   with user-supplied endpoints, plus user-added providers with saved
+ *   endpoints, also return a pre-filled `baseUrl` field.
+ *
+ * Returns the same fallback shape for unknown providers (single `apiKey`
+ * input, no default base URL) so callers can render a reasonable configure
+ * dialog without per-id branches.
+ */
+export function getProviderConfigFields(
+	providerId: string,
+): ProviderConfigFields {
+	const id = LlmsModels.normalizeProviderId(providerId);
+	if (isOAuthProviderId(id)) {
+		return { providerId: id, authMethod: "oauth", fields: {} };
+	}
+
+	const collection = LlmsModels.MODEL_COLLECTIONS_BY_PROVIDER_ID[id];
+	if (collection?.provider.capabilities?.includes("local-auth")) {
+		return { providerId: id, authMethod: "local", fields: {} };
+	}
+
+	const defaultBaseUrl = collection?.provider.baseUrl;
+	const fields: ProviderConfigFields["fields"] = {
+		apiKey: {},
+	};
+	if (shouldExposeBaseUrlField(id, collection)) {
+		fields.baseUrl = { defaultValue: defaultBaseUrl };
+	}
+
+	return applyProviderConfigFieldMetadata({
+		providerId: id,
+		authMethod: "api-key",
+		fields,
+	});
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/services/session-artifacts.ts

@@ -0,0 +1,138 @@
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	rmdirSync,
+	rmSync,
+	unlinkSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import {
+	parseSubSessionId,
+	parseTeamTaskSubSessionId,
+} from "../session/models/session-graph";
+
+export function nowIso(): string {
+	return new Date().toISOString();
+}
+
+export function unlinkIfExists(path: string | null | undefined): void {
+	if (!path || !existsSync(path)) {
+		return;
+	}
+	try {
+		unlinkSync(path);
+	} catch {
+		// Best effort cleanup.
+	}
+}
+
+export interface SessionArtifactPaths {
+	messagesPath: string;
+}
+
+function childArtifactFileStem(sessionId: string): {
+	rootSessionId: string;
+	fileStem: string;
+} {
+	const teamTask = parseTeamTaskSubSessionId(sessionId);
+	if (teamTask) {
+		return {
+			rootSessionId: teamTask.rootSessionId,
+			fileStem: `${teamTask.agentId}__${teamTask.teamTaskId}`,
+		};
+	}
+
+	const subagent = parseSubSessionId(sessionId);
+	if (subagent) {
+		return {
+			rootSessionId: subagent.rootSessionId,
+			fileStem: subagent.agentId,
+		};
+	}
+
+	return {
+		rootSessionId: sessionId,
+		fileStem: sessionId,
+	};
+}
+
+export class SessionArtifacts {
+	constructor(private readonly ensureSessionsDir: () => string) {}
+
+	public sessionArtifactsDir(sessionId: string): string {
+		return join(this.ensureSessionsDir(), sessionId);
+	}
+
+	public ensureSessionArtifactsDir(sessionId: string): string {
+		const dir = this.sessionArtifactsDir(sessionId);
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		return dir;
+	}
+
+	public sessionMessagesPath(sessionId: string): string {
+		return join(
+			this.sessionArtifactsDir(sessionId),
+			`${sessionId}.messages.json`,
+		);
+	}
+
+	public sessionManifestPath(sessionId: string, ensureDir = false): string {
+		const base = ensureDir
+			? this.ensureSessionArtifactsDir(sessionId)
+			: this.sessionArtifactsDir(sessionId);
+		return join(base, `${sessionId}.json`);
+	}
+
+	public removeSessionDirIfEmpty(sessionId: string): void {
+		let dir = this.sessionArtifactsDir(sessionId);
+		const sessionsDir = this.ensureSessionsDir();
+		while (dir.startsWith(sessionsDir) && dir !== sessionsDir) {
+			if (!existsSync(dir)) {
+				dir = dirname(dir);
+				continue;
+			}
+			try {
+				if (readdirSync(dir).length > 0) {
+					break;
+				}
+				rmdirSync(dir);
+			} catch {
+				// Best-effort cleanup.
+				break;
+			}
+			dir = dirname(dir);
+		}
+	}
+
+	public removeSessionDir(sessionId: string): void {
+		this.removeDir(this.sessionArtifactsDir(sessionId));
+	}
+
+	public removeDir(dir: string): void {
+		if (!existsSync(dir)) {
+			return;
+		}
+		try {
+			rmSync(dir, { recursive: true, force: true });
+		} catch {
+			// Best-effort cleanup.
+		}
+	}
+
+	public subagentArtifactPaths(
+		sessionId: string,
+		subAgentId: string,
+		activeTeamTaskSessionId?: string,
+	): SessionArtifactPaths {
+		void subAgentId;
+		void activeTeamTaskSessionId;
+		const { rootSessionId, fileStem } = childArtifactFileStem(sessionId);
+		const dir = this.sessionArtifactsDir(rootSessionId);
+		return {
+			messagesPath: join(dir, `${fileStem}.messages.json`),
+		};
+	}
+}