codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/algenta/policy.test.ts

@@ -0,0 +1,260 @@
+// B6/B7 PR10 (proof-honesty + fail-closed): engine-evidence default, unknown-profile
+// fail-closed, caller session_id path-validated + artifact run id server-generated, and
+// proofRunDir traversal-safe.
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { expect, test } from "bun:test";
+import { normalizeSessionPayload, resolveEngineConfig, resolveSessionPolicy } from "./server/policy";
+import { proofRunDir } from "./proofs";
+
+const ARGS = { working_dir: "/work", prompt: "fix it" } as never;
+const base = { working_dir: "/work", prompt: "fix it", task_spec: { issue_text: "fix it" } };
+
+test("engine mode defaults to requiring engine evidence (simulate_patch / fail-on-zero)", () => {
+	const cfg = resolveEngineConfig({ engine: { url: "http://engine:8000" } });
+	expect(cfg.enabled).toBe(true);
+	expect(cfg.requiredTools).toEqual(["simulate_patch"]);
+	expect(cfg.failOnZeroCalls).toBe(true);
+});
+
+test("explicit fail_on_zero_calls:false is honored; no url => engine disabled", () => {
+	expect(resolveEngineConfig({ engine: { url: "http://e:8000", fail_on_zero_calls: false } }).failOnZeroCalls).toBe(false);
+	expect(resolveEngineConfig({}).enabled).toBe(false);
+});
+
+test("unknown approval_profile fails closed; absent => default; valid => ok", () => {
+	expect(() => resolveSessionPolicy({ approval_profile: "totally_made_up" }, ARGS)).toThrow();
+	expect(() => resolveSessionPolicy({}, ARGS)).not.toThrow();
+	expect(() => resolveSessionPolicy({ approval_profile: "repository_review" }, ARGS)).not.toThrow();
+});
+
+test("local validation tool profile defaults to local_validation and keeps run_commands enabled", () => {
+	const policy = resolveSessionPolicy(
+		{},
+		{ ...ARGS, tool_profile: "no_exploration_local_validation" } as never,
+	);
+	expect(policy.profile).toBe("local_validation");
+	expect(policy.toolPolicies.run_commands?.enabled).toBe(true);
+	expect(policy.toolPolicies.run_commands?.autoApprove).toBe(true);
+});
+
+test("exact restore contract defaults to local_validation shell lane", () => {
+	const prompt = [
+		"Fix this repository issue:",
+		"Target file: src/app.py",
+		"Original valid git head: abc123",
+		"Restore it exactly with: git restore --source abc123 -- src/app.py",
+	].join("\n");
+	const policy = resolveSessionPolicy({}, { ...ARGS, prompt } as never);
+	expect(policy.profile).toBe("local_validation");
+	expect(policy.toolPolicies.run_commands?.enabled).toBe(true);
+	expect(policy.toolPolicies.read_files?.enabled).toBe(false);
+	expect(policy.toolPolicies.search_codebase?.enabled).toBe(false);
+	expect(policy.toolPolicies.fetch_web_content?.enabled).toBe(false);
+	expect(policy.toolPolicies.ask_question?.enabled).toBe(false);
+	expect(policy.toolPolicies.editor?.enabled).toBe(false);
+	expect(policy.toolPolicies.apply_patch?.enabled).toBe(false);
+	expect(policy.toolPolicies.skills?.enabled).toBe(false);
+	expect(policy.toolPolicies.localize?.enabled).toBe(false);
+	expect(policy.toolPolicies.graph_query?.enabled).toBe(false);
+	expect(policy.toolPolicies.simulate_patch?.enabled).toBe(false);
+});
+
+test("explicit approval_profile still overrides the tool-profile-derived default", () => {
+	const policy = resolveSessionPolicy(
+		{ approval_profile: "repository_fix_gated" },
+		{ ...ARGS, tool_profile: "no_exploration_local_validation" } as never,
+	);
+	expect(policy.profile).toBe("repository_fix_gated");
+	expect(policy.toolPolicies.run_commands?.enabled).toBeUndefined();
+});
+
+test("server session policy disables patch tools for exact restore contracts when shell restore is allowed", () => {
+	const prompt = [
+		"Fix this repository issue:",
+		"Target file: src/app.py",
+		"Original valid git head: abc123",
+		"Restore it exactly with: git restore --source abc123 -- src/app.py",
+	].join("\n");
+	const policy = resolveSessionPolicy(
+		{},
+		{
+			...ARGS,
+			prompt,
+			tool_profile: "no_exploration_local_validation",
+		} as never,
+	);
+	expect(policy.toolPolicies.run_commands?.enabled).toBe(true);
+	expect(policy.toolPolicies.read_files?.enabled).toBe(false);
+	expect(policy.toolPolicies.search_codebase?.enabled).toBe(false);
+	expect(policy.toolPolicies.fetch_web_content?.enabled).toBe(false);
+	expect(policy.toolPolicies.ask_question?.enabled).toBe(false);
+	expect(policy.toolPolicies.editor?.enabled).toBe(false);
+	expect(policy.toolPolicies.apply_patch?.enabled).toBe(false);
+	expect(policy.toolPolicies.skills?.enabled).toBe(false);
+	expect(policy.toolPolicies.localize?.enabled).toBe(false);
+	expect(policy.toolPolicies.graph_query?.enabled).toBe(false);
+	expect(policy.toolPolicies.simulate_patch?.enabled).toBe(false);
+});
+
+test("server session policy disables write tools for triage tasks", () => {
+	const policy = resolveSessionPolicy({}, { ...ARGS, task_kind: "triage" } as never);
+	expect(policy.toolPolicies.editor?.enabled).toBe(false);
+	expect(policy.toolPolicies.apply_patch?.enabled).toBe(false);
+	expect(policy.toolPolicies.run_commands?.enabled).toBeUndefined();
+});
+
+test("session_id is path-validated; the artifact run id is server-generated (decoupled)", () => {
+	const ok = normalizeSessionPayload({ ...base, session_id: "sess-123" }, "owner");
+	expect(ok.sessionId).toBe("sess-123");
+	expect(ok.agentRunId).not.toBe("sess-123");
+	expect(ok.agentRunId.startsWith("run_")).toBe(true);
+	expect(() => normalizeSessionPayload({ ...base, session_id: "../evil" }, "owner")).toThrow();
+	expect(() => normalizeSessionPayload({ ...base, session_id: "a/b" }, "owner")).toThrow();
+});
+
+test("proofRunDir rejects unsafe run ids and confines to the runs root", () => {
+	const ctx = { rootDir: "/tmp/root" } as never;
+	expect(proofRunDir(ctx, "run_abc-123")).toBe("/tmp/root/build/proofs/cline/runs/run_abc-123");
+	expect(() => proofRunDir(ctx, "../escape")).toThrow();
+	expect(() => proofRunDir(ctx, "a/b")).toThrow();
+});
+
+test("normalizeSessionPayload prioritizes explicit issue targets over suspect ranking", () => {
+	const workingDir = mkdtempSync(path.join(tmpdir(), "algenta-policy-"));
+	try {
+		mkdirSync(path.join(workingDir, "patterns"), { recursive: true });
+		writeFileSync(
+			path.join(workingDir, "patterns", "dependency_injection.py"),
+			[
+				"class Service:",
+				"    pass",
+				"__codna_benchmark__ = (",
+				"    pass",
+			].join("\n"),
+			"utf8",
+		);
+		const session = normalizeSessionPayload(
+			{
+				working_dir: workingDir,
+				task_spec: {
+					issue_text:
+						'Reporter: py_compile\nFile "patterns/dependency_injection.py", line 3\nSyntaxError: "(" was never closed',
+				},
+				injected_context: {
+					suspect_files: ["patterns/other/hsm/hsm.py"],
+					context_bundle: [
+						{
+							file_path: "patterns/other/hsm/hsm.py",
+							numbered_source: "     1\tprint('wrong file')",
+						},
+					],
+					evidence_items: [
+						{
+							file_path: "patterns/other/hsm/hsm.py",
+							snippet: "print('wrong file')",
+						},
+					],
+				},
+			},
+			"owner",
+		);
+		expect(session.prompt).toContain(
+			"Explicit target file: patterns/dependency_injection.py.",
+		);
+		expect(session.prompt).not.toContain("patterns/other/hsm/hsm.py");
+		expect(session.injectedContext).toContain("TARGET FILES");
+		expect(session.injectedContext).toContain("TARGET FILE EXCERPTS");
+		expect(session.injectedContext).toContain("FILE patterns/dependency_injection.py:1-4");
+		expect(session.injectedContext).toContain("focus_line: 3");
+		expect(session.injectedContext).toContain("excerpt_reaches_eof: yes");
+		expect(session.injectedContext).toContain("__codna_benchmark__ = (");
+		expect(session.injectedContext).not.toContain('"suspect_files"');
+		expect(session.injectedContext).not.toContain("patterns/other/hsm/hsm.py");
+	} finally {
+		rmSync(workingDir, { recursive: true, force: true });
+	}
+});
+
+test("normalizeSessionPayload compacts non-explicit injected context into ranked files", () => {
+	const workingDir = mkdtempSync(path.join(tmpdir(), "algenta-policy-"));
+	try {
+		const session = normalizeSessionPayload(
+			{
+				working_dir: workingDir,
+				task_spec: { issue_text: "checkout fails during startup" },
+				injected_context: {
+					suspect_files: ["src/app.py", "src/helpers.py"],
+				},
+			},
+			"owner",
+		);
+		expect(session.prompt).toContain("Likely files: src/app.py, src/helpers.py.");
+		expect(session.injectedContext).toBe("RANKED FILES\n- src/app.py\n- src/helpers.py");
+	} finally {
+		rmSync(workingDir, { recursive: true, force: true });
+	}
+});
+
+test("normalizeSessionPayload uses Telys Tier 1A window for path-only explicit targets", () => {
+	const workingDir = mkdtempSync(path.join(tmpdir(), "algenta-policy-"));
+	try {
+		mkdirSync(path.join(workingDir, "src"), { recursive: true });
+		writeFileSync(
+			path.join(workingDir, "src", "large.py"),
+			Array.from({ length: 240 }, (_value, index) => `line_${index + 1}`).join("\n"),
+			"utf8",
+		);
+		const session = normalizeSessionPayload(
+			{
+				working_dir: workingDir,
+				task_spec: { issue_text: "checkout handler fails in src/large.py" },
+				injected_context: {
+					localization_tier: "tier_1a_path_hinted_telys",
+					telys_context_mode: "path_hint_telys_window_context",
+					suspect_files: ["src/large.py"],
+					context_bundle: [
+						{
+							file_path: "src/large.py",
+							symbol_name: "telys_window",
+							start_line: 200,
+							end_line: 202,
+							numbered_source: "   200\tline_200\n   201\tline_201\n   202\tline_202",
+						},
+					],
+				},
+			},
+			"owner",
+		);
+		expect(session.prompt).toContain("Explicit target file: src/large.py.");
+		expect(session.injectedContext).toContain("TARGET FILES");
+		expect(session.injectedContext).not.toContain("TARGET FILE EXCERPTS");
+		expect(session.injectedContext).toContain("CONTEXT BUNDLE");
+		expect(session.injectedContext).toContain("FILE src/large.py symbol=telys_window lines=200-202");
+		expect(session.injectedContext).toContain("line_201");
+		expect(session.injectedContext).not.toContain("line_1");
+	} finally {
+		rmSync(workingDir, { recursive: true, force: true });
+	}
+});
+
+test("normalizeSessionPayload preserves explicit task_kind and rejects unknown values", () => {
+	const triage = normalizeSessionPayload(
+		{
+			...base,
+			task_kind: "triage",
+		},
+		"owner",
+	);
+	expect(triage.taskKind).toBe("triage");
+	expect(() =>
+		normalizeSessionPayload(
+			{
+				...base,
+				task_kind: "rewrite",
+			},
+			"owner",
+		),
+	).toThrow("task_kind must be one of");
+});

codna/agent-core/vendor/cline/algenta/postbuild.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# Post-build: symlink the built @cline/* workspace packages into node_modules so
+# files OUTSIDE the workspace packages (algenta/*) can `import "@cline/core"`.
+# Run after:  bun install && bun run build:sdk
+set -euo pipefail
+root="$(cd "$(dirname "$0")/.." && pwd)"   # vendored cline root
+
+lock_dir="$root/node_modules/.cline-postbuild.lock"
+lock_started_at="$(date +%s)"
+mkdir -p "$root/node_modules"
+while ! mkdir "$lock_dir" 2>/dev/null; do
+  now="$(date +%s)"
+  if [ "$((now - lock_started_at))" -ge 30 ]; then
+    echo "timed out waiting for postbuild lock: $lock_dir" >&2
+    exit 1
+  fi
+  sleep 0.1
+done
+trap 'rmdir "$lock_dir" 2>/dev/null || true' EXIT
+
+mkdir -p "$root/node_modules/@cline"
+for p in shared llms agents core sdk; do
+  dest="$root/node_modules/@cline/$p"
+  if [ -e "$dest" ] && [ ! -L "$dest" ]; then
+    echo "refusing to replace non-symlink dependency path: $dest" >&2
+    exit 1
+  fi
+  rm -f "$dest"
+  ln -s "../../sdk/packages/$p" "$dest"
+done
+echo "linked @cline/{shared,llms,agents,core,sdk}"

codna/agent-core/vendor/cline/algenta/proof-artifacts.test.ts

@@ -0,0 +1,55 @@
+import { expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { degradedProofRuntimeContext, readProofArtifacts } from "./proofs";
+
+async function withProofRun(
+	runId: string,
+	files: Record<string, string>,
+): Promise<{ root: string; ctx: ReturnType<typeof degradedProofRuntimeContext> }> {
+	const root = await mkdtemp(path.join(os.tmpdir(), "algenta-proofs-"));
+	const ctx = degradedProofRuntimeContext(root, "test");
+	const runDir = path.join(root, "build", "proofs", "cline", "runs", runId);
+	await mkdir(runDir, { recursive: true });
+	for (const [name, body] of Object.entries(files)) {
+		await writeFile(path.join(runDir, name), body, "utf8");
+	}
+	return { root, ctx };
+}
+
+test("readProofArtifacts returns the run's JSON + ndjson bundle", async () => {
+	const { root, ctx } = await withProofRun("run-abc123", {
+		"gate.json": JSON.stringify({ terminal_state: "succeeded", apply_allowed: true }),
+		"messages.json": JSON.stringify({ sensitive: true, messages: [{ role: "user" }] }),
+		"events.ndjson": '{"event":"a"}\n{"event":"b"}\n',
+	});
+	try {
+		const bundle = await readProofArtifacts(ctx, "run-abc123");
+		expect(bundle).not.toBeNull();
+		expect(bundle!.run_id).toBe("run-abc123");
+		expect((bundle!.artifacts["gate.json"] as { terminal_state: string }).terminal_state).toBe(
+			"succeeded",
+		);
+		// missing artifacts (usage/tool_calls/...) are simply omitted, not errors
+		expect(bundle!.artifacts["usage.json"]).toBeUndefined();
+		expect((bundle!.artifacts["events.ndjson"] as unknown[]).length).toBe(2);
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+});
+
+test("readProofArtifacts returns null when the run dir has no artifacts", async () => {
+	const root = await mkdtemp(path.join(os.tmpdir(), "algenta-proofs-"));
+	const ctx = degradedProofRuntimeContext(root, "test");
+	try {
+		expect(await readProofArtifacts(ctx, "never-finalized")).toBeNull();
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+});
+
+test("readProofArtifacts rejects a path-unsafe runId", async () => {
+	const ctx = degradedProofRuntimeContext(os.tmpdir(), "test");
+	await expect(readProofArtifacts(ctx, "../../etc/passwd")).rejects.toThrow();
+});

codna/agent-core/vendor/cline/algenta/proof-provider.ts

@@ -0,0 +1,301 @@
+import { Llms } from "@cline/core";
+import type {
+	ApiHandler,
+	ApiStreamChunk,
+	HandlerModelInfo,
+	Message,
+	ToolDefinition,
+} from "@cline/llms";
+
+export const ALGENTA_PROOF_PROVIDER_ID = "algenta-proof";
+export const ALGENTA_PROOF_MODEL_ID = "algenta/gpt-proof-model";
+export const ALGENTA_PROOF_API_KEY_ENV = "ALGENTA_PROOF_API_KEY";
+
+const DEFAULT_TARGET_FILE = "proof-target.txt";
+const TARGET_FILE_PATTERN = /(?:^|\n)\s*TARGET_FILE\s*=\s*([^\n\r]+)/i;
+
+const MODEL_INFO = {
+	id: ALGENTA_PROOF_MODEL_ID,
+	name: "Algenta Deterministic Proof Model",
+	contextWindow: 16_384,
+	maxInputTokens: 16_384,
+	maxTokens: 2_048,
+	capabilities: ["tools", "streaming", "prompt-cache"] as const,
+	apiFormat: "default" as const,
+	systemRole: "system" as const,
+	status: "active" as const,
+	family: "algenta-proof",
+};
+
+type ProofStep =
+	| {
+			toolName: "localize";
+			arguments: { issue: string; changed_files: string[]; failing_tests: string[] };
+			usage: { inputTokens: number; outputTokens: number; cacheWriteTokens?: number };
+	  }
+	| {
+			toolName: "graph_query";
+			arguments: { file_path: string; direction: "both" };
+			usage: { inputTokens: number; outputTokens: number; cacheReadTokens: number };
+	  }
+	| {
+			toolName: "apply_patch";
+			arguments: { input: string };
+			usage: { inputTokens: number; outputTokens: number; cacheReadTokens: number };
+	  }
+	| {
+			toolName: "simulate_patch";
+			arguments: { confidence: number };
+			usage: { inputTokens: number; outputTokens: number; cacheReadTokens: number };
+	  }
+	| {
+			finalText: string;
+			usage: { inputTokens: number; outputTokens: number; cacheReadTokens: number };
+	  };
+
+let providerRegistered = false;
+let streamSequence = 0;
+
+function nextStreamId(): string {
+	streamSequence += 1;
+	return `algenta_proof_${streamSequence}`;
+}
+
+function collectCompletedToolResults(messages: Message[]): Set<string> {
+	const completed = new Set<string>();
+	for (const message of messages) {
+		for (const part of message.content ?? []) {
+			if (
+				part &&
+				typeof part === "object" &&
+				"type" in part &&
+				part.type === "tool_result" &&
+				"name" in part &&
+				typeof part.name === "string"
+			) {
+				completed.add(part.name);
+			}
+		}
+	}
+	return completed;
+}
+
+function latestUserText(messages: Message[]): string {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message.role !== "user") {
+			continue;
+		}
+		const text = message.content
+			.map((part) =>
+				part && typeof part === "object" && "type" in part && part.type === "text"
+					? ("text" in part && typeof part.text === "string" ? part.text : "")
+					: "",
+			)
+			.join("\n")
+			.trim();
+		if (text) {
+			return text;
+		}
+	}
+	return "";
+}
+
+function ensureToolAvailable(tools: ToolDefinition[] | undefined, toolName: string): void {
+	if (!tools?.some((tool) => tool.name === toolName)) {
+		const available = tools?.map((tool) => tool.name).sort().join(", ") || "none";
+		throw new Error(
+			`Algenta proof provider requires tool '${toolName}', but it is not available in the runtime (available: ${available}).`,
+		);
+	}
+}
+
+function resolveTargetFile(messages: Message[]): string {
+	const latestPrompt = latestUserText(messages);
+	const match = latestPrompt.match(TARGET_FILE_PATTERN);
+	const candidate = match?.[1]?.trim();
+	return candidate || DEFAULT_TARGET_FILE;
+}
+
+function proofPatchInput(targetFile: string): string {
+	return [
+		"*** Begin Patch",
+		`*** Update File: ${targetFile}`,
+		"@@",
+		" alpha",
+		"+beta",
+		"*** End Patch",
+	].join("\n");
+}
+
+function resolveProofStep(messages: Message[], tools: ToolDefinition[] | undefined): ProofStep {
+	const latestPrompt = latestUserText(messages).toLowerCase();
+	const targetFile = resolveTargetFile(messages);
+	if (latestPrompt.includes("prime runtime extensions")) {
+		return {
+			finalText: "Algenta proof runtime primed. Continue to execute the tool sequence.",
+			usage: {
+				inputTokens: 48,
+				outputTokens: 12,
+				cacheWriteTokens: 8,
+			},
+		};
+	}
+	const completed = collectCompletedToolResults(messages);
+	if (!completed.has("localize")) {
+		ensureToolAvailable(tools, "localize");
+		return {
+			toolName: "localize",
+			arguments: {
+				issue: "Prove the live Algenta engine-backed plugin plane for parity.",
+				changed_files: [targetFile],
+				failing_tests: ["tests/test_cline_live_run_proof.py"],
+			},
+			usage: {
+				inputTokens: 120,
+				outputTokens: 24,
+				cacheWriteTokens: 64,
+			},
+		};
+	}
+	if (!completed.has("graph_query")) {
+		ensureToolAvailable(tools, "graph_query");
+		return {
+			toolName: "graph_query",
+			arguments: { file_path: targetFile, direction: "both" },
+			usage: {
+				inputTokens: 128,
+				outputTokens: 20,
+				cacheReadTokens: 18,
+			},
+		};
+	}
+	if (!completed.has("apply_patch")) {
+		ensureToolAvailable(tools, "apply_patch");
+		return {
+			toolName: "apply_patch",
+			arguments: { input: proofPatchInput(targetFile) },
+			usage: {
+				inputTokens: 140,
+				outputTokens: 26,
+				cacheReadTokens: 24,
+			},
+		};
+	}
+	if (!completed.has("simulate_patch")) {
+		ensureToolAvailable(tools, "simulate_patch");
+		return {
+			toolName: "simulate_patch",
+			arguments: { confidence: 0.99 },
+			usage: {
+				inputTokens: 152,
+				outputTokens: 22,
+				cacheReadTokens: 32,
+			},
+		};
+	}
+	return {
+		finalText: "Algenta live proof run completed.",
+		usage: {
+			inputTokens: 160,
+			outputTokens: 14,
+			cacheReadTokens: 40,
+		},
+	};
+}
+
+class AlgentaProofHandler implements ApiHandler {
+	readonly #modelInfo: HandlerModelInfo;
+
+	constructor(modelId: string) {
+		this.#modelInfo = {
+			id: modelId,
+			info: { ...MODEL_INFO, id: modelId },
+		};
+	}
+
+	getMessages(systemPrompt: string, messages: Message[]): unknown {
+		return { systemPrompt, messages };
+	}
+
+	getModel(): HandlerModelInfo {
+		return this.#modelInfo;
+	}
+
+	async *createMessage(
+		_systemPrompt: string,
+		messages: Message[],
+		tools?: ToolDefinition[],
+	): AsyncGenerator<ApiStreamChunk> {
+		const streamId = nextStreamId();
+		const step = resolveProofStep(messages, tools);
+		yield {
+			type: "usage",
+			id: streamId,
+			inputTokens: step.usage.inputTokens,
+			outputTokens: step.usage.outputTokens,
+			cacheReadTokens: step.usage.cacheReadTokens,
+			cacheWriteTokens: step.usage.cacheWriteTokens,
+			totalCost: 0,
+		};
+
+		if ("toolName" in step) {
+			yield {
+				type: "tool_calls",
+				id: streamId,
+				tool_call: {
+					call_id: `${streamId}_${step.toolName}`,
+					function: {
+						id: `${streamId}_${step.toolName}`,
+						name: step.toolName,
+						arguments: step.arguments,
+					},
+				},
+			};
+			return;
+		}
+
+		yield {
+			type: "text",
+			id: streamId,
+			text: step.finalText,
+		};
+		yield {
+			type: "done",
+			id: streamId,
+			success: true,
+		};
+	}
+}
+
+export function ensureAlgentaProofProviderRegistered(): void {
+	if (providerRegistered) {
+		return;
+	}
+	Llms.registerProvider({
+		provider: {
+			id: ALGENTA_PROOF_PROVIDER_ID,
+			name: "Algenta Proof Provider",
+			description:
+				"Deterministic proof-only provider that drives the vendored Cline runtime through a fixed tool sequence.",
+			defaultModelId: ALGENTA_PROOF_MODEL_ID,
+			env: [ALGENTA_PROOF_API_KEY_ENV],
+			client: "custom",
+			source: "system",
+		},
+		models: {},
+	});
+	Llms.registerModel(
+		ALGENTA_PROOF_PROVIDER_ID,
+		ALGENTA_PROOF_MODEL_ID,
+		MODEL_INFO,
+	);
+	Llms.registerHandler(ALGENTA_PROOF_PROVIDER_ID, (config) => {
+		const modelId =
+			typeof config.modelId === "string" && config.modelId.trim()
+				? config.modelId
+				: ALGENTA_PROOF_MODEL_ID;
+		return new AlgentaProofHandler(modelId);
+	});
+	providerRegistered = true;
+}