codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/llms/src/providers/middleware/split-tool-images.ts

@@ -0,0 +1,293 @@
+// LanguageModelV3 middleware that recovers image bytes from
+// `role:"tool"` messages whose content arrays the downstream chat-completions
+// converter would otherwise destroy.
+//
+// Background: AI SDK's `LanguageModelV3ToolResultOutput` of type `'content'`
+// may contain `image-data`, `image-url`, `file-data`, `file-url`, or
+// `image-file-id` parts. The OpenAI Chat Completions wire format does NOT
+// support multimodal tool messages — `role:"tool"` content must be a single
+// string. The `@ai-sdk/openai-compatible` chat-messages converter therefore
+// just `JSON.stringify`s the parts array. The image bytes survive as escaped
+// base64 inside a string, which the model treats as ~50KB of opaque text and
+// hallucinates the image's actual contents.
+//
+// This middleware operates on the typed `LanguageModelV3Prompt` BEFORE the
+// downstream converter runs. For every `role:"tool"` message containing
+// image/file parts inside a tool-result `output.type === 'content'` value,
+// it:
+//
+//   1. Replaces the media parts inside the tool-result with placeholder
+//      text parts: `(see following user message for image)`. The
+//      tool-result then carries only text — safe for any wire format.
+//   2. Inserts a synthetic `role:"user"` message right after the tool
+//      message, carrying the media parts as `LanguageModelV3FilePart`s.
+//
+// Because the synthetic user message is typed (not raw JSON), every
+// downstream converter — Chat Completions, Mistral, Anthropic, Bedrock,
+// etc. — translates it to its own native multimodal user-content shape
+// without further help.
+//
+// This pattern is documented in the OpenAI Chat Completions spec
+// (consecutive `user` messages are concatenated by the model) and is a
+// direct port of the proven wire pattern used by classic Cline's
+// `convertToOpenAiMessages` (see `src/core/api/transform/openai-format.ts`
+// in origin/main).
+//
+// Replaces fetch interceptor `vendors/openai-compatible-image-rewrite.ts`,
+// which did the same rewrite at the wire layer (post-converter). The
+// middleware approach is preferred because:
+//   * No JSON parse / restringify round-trip on every chat-completions
+//     request.
+//   * Works equally for any converter — `@ai-sdk/mistral` (which has its
+//     own chat-messages converter) was previously uncovered.
+//   * Decoupled from the AI SDK's wire-output shape: if the SDK ever
+//     changes how it serialises content arrays, this layer doesn't care.
+
+import type {
+	LanguageModelV3CallOptions,
+	LanguageModelV3FilePart,
+	LanguageModelV3Message,
+	LanguageModelV3Middleware,
+	LanguageModelV3TextPart,
+	LanguageModelV3ToolResultOutput,
+	LanguageModelV3ToolResultPart,
+} from "@ai-sdk/provider";
+
+const IMAGE_PLACEHOLDER = "(see following user message for image)";
+
+type ContentOutput = Extract<
+	LanguageModelV3ToolResultOutput,
+	{ type: "content" }
+>;
+type ContentPart = ContentOutput["value"][number];
+
+function isMediaContentPart(part: ContentPart): part is Extract<
+	ContentPart,
+	{
+		type:
+			| "image-data"
+			| "image-url"
+			| "file-data"
+			| "file-url"
+			| "image-file-id";
+	}
+> {
+	switch (part.type) {
+		case "image-data":
+		case "image-url":
+		case "file-data":
+		case "file-url":
+		case "image-file-id":
+			return true;
+		default:
+			return false;
+	}
+}
+
+/**
+ * Convert a media content-part from a `ToolResultOutput` of type `'content'`
+ * into the equivalent `LanguageModelV3FilePart` for use in a user message.
+ * Returns `null` for `image-file-id` parts because `LanguageModelV3FilePart`
+ * has no provider-file-id slot — those parts are left in place inside the
+ * tool-result and pass through to the converter as-is. (Image-file-id is
+ * an OpenAI-specific reference; if a caller is using it they are already
+ * on a multimodal-aware path and don't need this rewrite.)
+ */
+function mediaPartToFilePart(
+	part: Extract<
+		ContentPart,
+		{
+			type:
+				| "image-data"
+				| "image-url"
+				| "file-data"
+				| "file-url"
+				| "image-file-id";
+		}
+	>,
+): LanguageModelV3FilePart | null {
+	switch (part.type) {
+		case "image-data":
+			return {
+				type: "file",
+				data: part.data,
+				mediaType: part.mediaType,
+				...(part.providerOptions
+					? { providerOptions: part.providerOptions }
+					: {}),
+			};
+		case "image-url":
+			return {
+				type: "file",
+				// FilePart.data accepts a URL or string. Pass the URL string;
+				// the converter will wire it through to e.g. `image_url.url`.
+				data: part.url,
+				// AI SDK requires a mediaType. We don't know the actual type
+				// from a URL, so fall back to a wildcard image type — the
+				// downstream converter (chat-completions) only needs the
+				// URL anyway.
+				mediaType: "image/*",
+				...(part.providerOptions
+					? { providerOptions: part.providerOptions }
+					: {}),
+			};
+		case "file-data":
+			return {
+				type: "file",
+				data: part.data,
+				mediaType: part.mediaType,
+				...(part.filename ? { filename: part.filename } : {}),
+				...(part.providerOptions
+					? { providerOptions: part.providerOptions }
+					: {}),
+			};
+		case "file-url":
+			return {
+				type: "file",
+				data: part.url,
+				mediaType: "application/octet-stream",
+				...(part.providerOptions
+					? { providerOptions: part.providerOptions }
+					: {}),
+			};
+		case "image-file-id":
+			// No FilePart equivalent — caller is on a path that already handles
+			// provider-side file references, so we leave the part in place.
+			return null;
+	}
+}
+
+interface SplitResult {
+	stripped: ContentOutput;
+	media: LanguageModelV3FilePart[];
+}
+
+/**
+ * Split a tool-result `output` of type `'content'` into:
+ *   - a `stripped` output where every media part is replaced by a
+ *     placeholder text part, and
+ *   - the list of media parts converted to `LanguageModelV3FilePart`.
+ *
+ * Returns `null` if the output isn't of type `'content'`, or if it doesn't
+ * carry any extractable media parts (in which case no rewrite is needed).
+ */
+function splitContentOutputMedia(
+	output: LanguageModelV3ToolResultOutput,
+): SplitResult | null {
+	if (output.type !== "content") {
+		return null;
+	}
+	const media: LanguageModelV3FilePart[] = [];
+	const newValue: ContentOutput["value"] = [];
+	for (const part of output.value) {
+		if (!isMediaContentPart(part)) {
+			newValue.push(part);
+			continue;
+		}
+		const filePart = mediaPartToFilePart(part);
+		if (!filePart) {
+			// Unhandled media kind (image-file-id) — pass through unchanged.
+			newValue.push(part);
+			continue;
+		}
+		media.push(filePart);
+		const placeholder: LanguageModelV3TextPart = {
+			type: "text",
+			text: IMAGE_PLACEHOLDER,
+		};
+		newValue.push(placeholder);
+	}
+	if (media.length === 0) {
+		return null;
+	}
+	return {
+		stripped: {
+			type: "content",
+			value: newValue,
+		},
+		media,
+	};
+}
+
+/**
+ * Walk a `LanguageModelV3Prompt` and rewrite every `role:"tool"` message
+ * containing image/file parts inside its tool-result `output`s. See the
+ * file-level comment for the rewrite shape.
+ *
+ * Returns the (possibly new) prompt array and a `mutated` flag for
+ * test/observation use.
+ */
+export function rewritePromptToolImages(prompt: LanguageModelV3Message[]): {
+	prompt: LanguageModelV3Message[];
+	mutated: boolean;
+} {
+	const newPrompt: LanguageModelV3Message[] = [];
+	let mutated = false;
+
+	for (const message of prompt) {
+		if (message.role !== "tool") {
+			newPrompt.push(message);
+			continue;
+		}
+
+		const collectedMedia: LanguageModelV3FilePart[] = [];
+		const newContent: typeof message.content = message.content.map((part) => {
+			if (part.type !== "tool-result") {
+				return part;
+			}
+			const split = splitContentOutputMedia(part.output);
+			if (!split) {
+				return part;
+			}
+			collectedMedia.push(...split.media);
+			const newPart: LanguageModelV3ToolResultPart = {
+				...part,
+				output: split.stripped,
+			};
+			return newPart;
+		});
+
+		newPrompt.push({ ...message, content: newContent });
+
+		if (collectedMedia.length > 0) {
+			newPrompt.push({
+				role: "user",
+				content: collectedMedia,
+			});
+			mutated = true;
+		}
+	}
+
+	return { prompt: newPrompt, mutated };
+}
+
+/**
+ * `LanguageModelV3Middleware` that splits image-carrying tool-result
+ * messages so chat-completions-style converters don't lose the bytes.
+ *
+ * Apply via `wrapLanguageModel({ model, middleware: splitToolImagesMiddleware })`
+ * in any provider whose downstream converter doesn't natively handle
+ * multimodal `role:"tool"` content (currently: `@ai-sdk/openai-compatible`,
+ * `@ai-sdk/mistral`).
+ *
+ * Anthropic's converter natively renders content arrays on tool-result
+ * messages and should NOT use this middleware — it would replace
+ * structurally-faithful tool-results with the placeholder text + sibling
+ * user message pattern unnecessarily.
+ */
+export const splitToolImagesMiddleware: LanguageModelV3Middleware = {
+	specificationVersion: "v3",
+	transformParams: async ({ params }) => {
+		const { prompt: newPrompt, mutated } = rewritePromptToolImages(
+			params.prompt,
+		);
+		if (!mutated) {
+			return params;
+		}
+		const next: LanguageModelV3CallOptions = {
+			...params,
+			prompt: newPrompt,
+		};
+		return next;
+	},
+};

codna/agent-core/vendor/cline/sdk/packages/llms/src/providers/model-facts.ts

@@ -0,0 +1,270 @@
+import type {
+	GatewayModelRoute,
+	GatewayProviderContext,
+	GatewayReasoningFormat,
+	GatewayStreamRequest,
+} from "@cline/shared";
+
+export function resolveModelFamily(
+	context: GatewayProviderContext,
+): string | undefined {
+	const family = context.model.metadata?.family;
+	return typeof family === "string" ? family : undefined;
+}
+
+export function normalizeRoutingValue(value: string | undefined) {
+	const normalized = value?.trim().toLowerCase();
+	return normalized ? normalized : undefined;
+}
+
+function normalizedFamily(context: GatewayProviderContext): string {
+	return normalizeRoutingValue(resolveModelFamily(context)) ?? "";
+}
+
+function normalizedModelId(
+	request: Pick<GatewayStreamRequest, "modelId">,
+): string {
+	return normalizeRoutingValue(request.modelId) ?? "";
+}
+
+function geminiModelDescriptor(input: {
+	request: Pick<GatewayStreamRequest, "modelId">;
+	context: GatewayProviderContext;
+}): string {
+	return [
+		input.request.modelId,
+		input.context.model.id,
+		input.context.model.name,
+		input.context.model.metadata?.family,
+	]
+		.filter(Boolean)
+		.join(" ")
+		.toLowerCase();
+}
+
+function isAnthropicLineageValue(value: string | undefined): boolean {
+	const normalized = normalizeRoutingValue(value);
+	return normalized
+		? normalized.includes("anthropic") || normalized.includes("claude")
+		: false;
+}
+
+function isClaudeLineageValue(value: string | undefined): boolean {
+	return normalizeRoutingValue(value)?.includes("claude") ?? false;
+}
+
+function isQwenLineageValue(value: string | undefined): boolean {
+	const normalized = normalizeRoutingValue(value);
+	return normalized
+		? /(^|[/:._-])qwen(?:$|[/:._-]|\d)/.test(normalized)
+		: false;
+}
+
+export function isAnthropicCompatibleModel(options: {
+	modelId?: string;
+	family?: string;
+}): boolean {
+	const family = normalizeRoutingValue(options.family);
+	if (family) {
+		return isAnthropicLineageValue(family);
+	}
+
+	return isAnthropicCompatibleModelId(options.modelId);
+}
+
+export function isAnthropicCompatibleModelId(
+	modelId: string | undefined,
+): boolean {
+	if (!modelId) {
+		return false;
+	}
+
+	return isAnthropicLineageValue(modelId);
+}
+
+export function isClaudeModelId(modelId: string | undefined): boolean {
+	if (!modelId) {
+		return false;
+	}
+
+	return isClaudeLineageValue(modelId);
+}
+
+export function isQwenModel(options: {
+	modelId?: string;
+	family?: string;
+}): boolean {
+	const family = normalizeRoutingValue(options.family);
+	if (isQwenLineageValue(family)) {
+		return true;
+	}
+
+	return isQwenLineageValue(options.modelId);
+}
+
+export function isGemini3Model(input: {
+	request: Pick<GatewayStreamRequest, "modelId">;
+	context: GatewayProviderContext;
+}): boolean {
+	return /(^|[/\s])gemini-3([.-]|$)/.test(geminiModelDescriptor(input));
+}
+
+export function isGeminiProModel(input: {
+	request: Pick<GatewayStreamRequest, "modelId">;
+	context: GatewayProviderContext;
+}): boolean {
+	return /(^|[/\s])gemini-2\.5-pro([-\s]|$)/.test(geminiModelDescriptor(input));
+}
+
+export function isGeminiFlashModel(input: {
+	request: Pick<GatewayStreamRequest, "modelId">;
+	context: GatewayProviderContext;
+}): boolean {
+	const descriptor = geminiModelDescriptor(input);
+	return (
+		/(^|[/\s])gemini-(?:\d(?:\.\d)?-)?flash(?:-lite|-image)?([-\s]|$)/.test(
+			descriptor,
+		) || descriptor.includes("gemini-flash")
+	);
+}
+
+export function supportsGeminiThinking(input: {
+	request: Pick<GatewayStreamRequest, "modelId">;
+	context: GatewayProviderContext;
+}): boolean {
+	const descriptor = geminiModelDescriptor(input);
+	return (
+		isGemini3Model(input) ||
+		/(^|[/\s])gemini-2\.5([-\s]|$)/.test(descriptor) ||
+		descriptor.includes("gemini-flash-latest")
+	);
+}
+
+function modelFamilyMatches(
+	family: string | undefined,
+	routeFamily: string | undefined,
+): boolean {
+	const normalizedFamily = normalizeRoutingValue(family);
+	const normalizedRouteFamily = normalizeRoutingValue(routeFamily);
+	if (!normalizedFamily || !normalizedRouteFamily) {
+		return false;
+	}
+	if (normalizedFamily === normalizedRouteFamily) {
+		return true;
+	}
+	return normalizedRouteFamily === "qwen"
+		? isQwenLineageValue(normalizedFamily)
+		: false;
+}
+
+export function modelRouteMatches(
+	route: GatewayModelRoute,
+	options: {
+		modelId?: string;
+		family?: string;
+		capabilities?: readonly string[];
+	},
+): boolean {
+	if (
+		"requiredCapability" in route &&
+		route.requiredCapability &&
+		!options.capabilities?.includes(route.requiredCapability)
+	) {
+		return false;
+	}
+
+	switch (route.matcher) {
+		case "anthropic-compatible":
+			return isAnthropicCompatibleModel(options);
+		case "model-family":
+			return modelFamilyMatches(options.family, route.family);
+		case "model-id":
+			return (
+				normalizeRoutingValue(options.modelId) ===
+				normalizeRoutingValue(route.modelId)
+			);
+	}
+}
+
+export function providerReasoningRouteMatches(
+	format: GatewayReasoningFormat,
+	request: Pick<GatewayStreamRequest, "modelId">,
+	context: GatewayProviderContext,
+): boolean {
+	const reasoning = context.provider.metadata?.routing?.reasoning;
+	if (reasoning?.format !== format) {
+		return false;
+	}
+
+	return reasoning.routes.some((route) =>
+		modelRouteMatches(route, {
+			modelId: request.modelId,
+			family: resolveModelFamily(context),
+			capabilities: context.model.capabilities,
+		}),
+	);
+}
+
+export function isGlmModel(
+	request: Pick<GatewayStreamRequest, "modelId">,
+	context: GatewayProviderContext,
+): boolean {
+	const family = normalizedFamily(context);
+
+	// Dynamic provider fallback: some routed/local catalogs only provide ids.
+	return family.includes("glm") || normalizedModelId(request).includes("glm");
+}
+
+export function isMiniMaxM3Model(
+	request: Pick<GatewayStreamRequest, "modelId">,
+	_context: GatewayProviderContext,
+): boolean {
+	const modelId = normalizedModelId(request);
+
+	return modelId === "minimax-m3" || modelId === "minimax/minimax-m3";
+}
+
+export function isKimiK26Family(context: GatewayProviderContext): boolean {
+	return normalizedFamily(context) === "kimi-k2.6";
+}
+
+export function isMoonshotKimiModelIdFallback(
+	request: Pick<GatewayStreamRequest, "modelId">,
+): boolean {
+	// Dynamic provider fallback for Moonshot-routed model ids when family
+	// metadata is absent or not specific enough.
+	return normalizedModelId(request).includes("moonshotai/kimi-");
+}
+
+export function isDeepSeekFamily(context: GatewayProviderContext): boolean {
+	return normalizedFamily(context).includes("deepseek");
+}
+
+export function getReasoningDefaultOnMetadata(
+	context: GatewayProviderContext,
+): boolean | undefined {
+	const value = context.model.metadata?.reasoningDefaultOn;
+	return typeof value === "boolean" ? value : undefined;
+}
+
+export function isOllamaQwen3ModelIdFallback(
+	request: Pick<GatewayStreamRequest, "providerId" | "modelId">,
+): boolean {
+	// Local Ollama models are discovered from /api/tags and often only provide
+	// names such as "qwen3-coder:30b". This fallback is used by
+	// modelReasoningDefaultsOn when no catalog metadata is present.
+	return (
+		request.providerId === "ollama" &&
+		normalizedModelId(request).includes("qwen3")
+	);
+}
+
+export function modelReasoningDefaultsOn(options: {
+	request: Pick<GatewayStreamRequest, "providerId" | "modelId">;
+	context: GatewayProviderContext;
+}): boolean {
+	return (
+		getReasoningDefaultOnMetadata(options.context) ??
+		isOllamaQwen3ModelIdFallback(options.request)
+	);
+}

codna/agent-core/vendor/cline/sdk/packages/llms/src/providers/model-registry.ts

@@ -0,0 +1,122 @@
+import type {
+	ModelCollection,
+	ModelInfo,
+	ProviderInfo,
+} from "../catalog/types";
+import { BUILTIN_PROVIDER_COLLECTION_LIST } from "./builtins";
+
+function buildInitialRegistry(): Map<string, ModelCollection> {
+	const map = new Map<string, ModelCollection>();
+	for (const collection of BUILTIN_PROVIDER_COLLECTION_LIST) {
+		map.set(collection.provider.id, {
+			provider: { ...collection.provider },
+			models: Object.fromEntries(
+				Object.entries(collection.models).map(([id, model]) => [
+					id,
+					{ ...model },
+				]),
+			),
+		});
+	}
+	return map;
+}
+
+const PROVIDER_CACHE: Map<string, ModelCollection> = buildInitialRegistry();
+const CUSTOM_MODELS: Map<string, Map<string, ModelInfo>> = new Map();
+const CUSTOM_PROVIDERS: Map<string, ModelCollection> = new Map();
+
+function getProviderFromCache(providerId: string): ModelCollection | undefined {
+	return CUSTOM_PROVIDERS.get(providerId) ?? PROVIDER_CACHE.get(providerId);
+}
+
+export function getProviderIds(): string[] {
+	const builtInIds = Array.from(PROVIDER_CACHE.keys());
+	const customIds = Array.from(CUSTOM_PROVIDERS.keys()).filter(
+		(id) => !PROVIDER_CACHE.has(id),
+	);
+	return [...builtInIds, ...customIds];
+}
+
+export function hasProvider(providerId: string): boolean {
+	return PROVIDER_CACHE.has(providerId) || CUSTOM_PROVIDERS.has(providerId);
+}
+
+export async function getProvider(
+	providerId: string,
+): Promise<ProviderInfo | undefined> {
+	return getProviderFromCache(providerId)?.provider;
+}
+
+export function getProviderCollectionSync(
+	providerId: string,
+): ModelCollection | undefined {
+	return getProviderFromCache(providerId);
+}
+
+export async function getProviderCollection(
+	providerId: string,
+): Promise<ModelCollection | undefined> {
+	return getProviderFromCache(providerId);
+}
+
+export async function getModelsForProvider(
+	providerId: string,
+): Promise<Record<string, ModelInfo>> {
+	const collection = getProviderFromCache(providerId);
+	const builtInModels = collection?.models ?? {};
+	const customModels = CUSTOM_MODELS.get(providerId);
+	if (customModels) {
+		return { ...builtInModels, ...Object.fromEntries(customModels) };
+	}
+	return builtInModels;
+}
+
+export async function getAllProviders(): Promise<ProviderInfo[]> {
+	return getProviderIds()
+		.map((id) => getProviderFromCache(id)?.provider)
+		.filter((p): p is ProviderInfo => p !== undefined);
+}
+
+export function registerProvider(collection: ModelCollection): void {
+	CUSTOM_PROVIDERS.set(collection.provider.id, collection);
+}
+
+export function registerModel(
+	providerId: string,
+	modelId: string,
+	info: ModelInfo,
+): void {
+	if (!CUSTOM_MODELS.has(providerId)) {
+		CUSTOM_MODELS.set(providerId, new Map());
+	}
+	CUSTOM_MODELS.get(providerId)?.set(modelId, { ...info, id: modelId });
+}
+
+export function unregisterProvider(providerId: string): boolean {
+	CUSTOM_MODELS.delete(providerId);
+	return CUSTOM_PROVIDERS.delete(providerId);
+}
+
+export function resetRegistry(): void {
+	CUSTOM_MODELS.clear();
+	CUSTOM_PROVIDERS.clear();
+}
+
+// MODEL_COLLECTIONS_BY_PROVIDER_ID: live view merging custom providers over builtins
+export const MODEL_COLLECTIONS_BY_PROVIDER_ID: Record<string, ModelCollection> =
+	new Proxy({} as Record<string, ModelCollection>, {
+		get(_target, key: string) {
+			return getProviderFromCache(key);
+		},
+		has(_target, key: string) {
+			return PROVIDER_CACHE.has(key) || CUSTOM_PROVIDERS.has(key);
+		},
+		ownKeys() {
+			return getProviderIds();
+		},
+		getOwnPropertyDescriptor(_target, key: string) {
+			const val = getProviderFromCache(key as string);
+			if (val === undefined) return undefined;
+			return { configurable: true, enumerable: true, value: val };
+		},
+	});