codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/shared/src/tools/create.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { zodToJsonSchema } from "../parse/zod";
+import { createTool } from "./create";
+
+describe("createTool", () => {
+	it("adds a top-level object type for raw object-like JSON schemas", () => {
+		const tool = createTool({
+			name: "raw_schema_tool",
+			description: "Tool with a raw object-like schema",
+			inputSchema: {
+				properties: {
+					value: {
+						type: "string",
+					},
+				},
+				required: ["value"],
+				additionalProperties: false,
+			},
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.inputSchema).toEqual({
+			type: "object",
+			properties: {
+				value: {
+					type: "string",
+				},
+			},
+			required: ["value"],
+			additionalProperties: false,
+		});
+	});
+
+	it("applies default execution policy fields", () => {
+		const tool = createTool({
+			name: "defaulted_tool",
+			description: "Tool with default execution policy",
+			inputSchema: { type: "object" },
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.timeoutMs).toBe(30_000);
+		expect(tool.retryable).toBe(true);
+		expect(tool.maxRetries).toBe(3);
+	});
+
+	it("preserves explicit execution policy fields", () => {
+		const tool = createTool({
+			name: "custom_policy_tool",
+			description: "Tool with custom execution policy",
+			inputSchema: { type: "object" },
+			timeoutMs: 1_000,
+			retryable: false,
+			maxRetries: 0,
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.timeoutMs).toBe(1_000);
+		expect(tool.retryable).toBe(false);
+		expect(tool.maxRetries).toBe(0);
+	});
+
+	it("strips the $schema meta-key emitted by Zod v4's toJSONSchema", () => {
+		// Zod v4 always adds "$schema" to the output of z.toJSONSchema().
+		// LLM tool APIs don't need it and some may reject it.
+		const schema = z.object({ value: z.string() });
+		const tool = createTool({
+			name: "zod_schema_tool",
+			description: "Tool with a Zod-derived schema",
+			inputSchema: zodToJsonSchema(schema),
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.inputSchema).not.toHaveProperty("$schema");
+		expect(tool.inputSchema).toHaveProperty("type", "object");
+	});
+
+	it("infers type:object when all anyOf branches are objects", () => {
+		// Build the anyOf manually to avoid depending on Zod's output shape.
+		const tool = createTool({
+			name: "all_object_anyof_tool",
+			description: "Tool with all-object anyOf branches",
+			inputSchema: {
+				anyOf: [
+					{ type: "object", properties: { a: { type: "string" } } },
+					{ type: "object", properties: { b: { type: "number" } } },
+				],
+			},
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.inputSchema).toHaveProperty("type", "object");
+	});
+
+	it("throws when inputSchema has a top-level anyOf with non-object branches", () => {
+		// A mixed-type union (objects + strings) is not a valid tool input_schema
+		// for any major LLM provider.  createTool must reject it at registration
+		// time so the bug surfaces immediately rather than at inference time.
+		expect(() =>
+			createTool({
+				name: "bad_union_tool",
+				description: "Tool with a mixed-type union schema",
+				inputSchema: {
+					anyOf: [
+						{ type: "object", properties: { commands: { type: "array" } } },
+						{ type: "string" },
+					],
+				},
+				execute: async () => ({ ok: true }),
+			}),
+		).toThrow(/top level/i);
+	});
+
+	it("infers type:object for allOf when at least one branch has type:object", () => {
+		// The canonical allOf case: one branch sets type + properties, another
+		// adds required without repeating type: "object".  The current input is
+		// still unambiguously object-shaped.
+		const tool = createTool({
+			name: "allof_tool",
+			description: "Tool with an allOf schema",
+			inputSchema: {
+				allOf: [
+					{ type: "object", properties: { commands: { type: "array" } } },
+					{ required: ["commands"] },
+				],
+			},
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.inputSchema).toEqual({
+			type: "object",
+			allOf: [
+				{ type: "object", properties: { commands: { type: "array" } } },
+				{ required: ["commands"] },
+			],
+		});
+	});
+
+	it("merges multiple required-only allOf branches without hoisting them", () => {
+		// Multiple branches each contribute required constraints.  None of them
+		// should be flattened — the allOf composition stays intact, only the
+		// top-level type: "object" is added.
+		const tool = createTool({
+			name: "allof_multi_required_tool",
+			description: "Tool with multiple required-only allOf branches",
+			inputSchema: {
+				allOf: [
+					{ type: "object" },
+					{ required: ["commands"] },
+					{ required: ["foo", "commands"] },
+				],
+			},
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.inputSchema).toEqual({
+			type: "object",
+			allOf: [
+				{ type: "object" },
+				{ required: ["commands"] },
+				{ required: ["foo", "commands"] },
+			],
+		});
+	});
+
+	it("throws when allOf has no branch with type:object", () => {
+		// We cannot verify the schema is object-shaped without at least one
+		// branch asserting type: "object". Fail loudly rather than forward an
+		// ambiguous schema to a provider that may reject it at inference time.
+		expect(() =>
+			createTool({
+				name: "allof_no_type_tool",
+				description: "Tool with allOf but no typed branch",
+				inputSchema: {
+					allOf: [{ required: ["commands"] }, { minProperties: 1 }],
+				},
+				execute: async () => ({ ok: true }),
+			}),
+		).toThrow(/top level/i);
+	});
+
+	it("throws when a Zod union schema with non-object branches is passed as inputSchema", () => {
+		// The concrete regression: passing a coercion/union schema (e.g.
+		// StructuredCommandsInputUnionSchema) directly as inputSchema must fail
+		// loudly, not silently forward a broken anyOf to the LLM provider.
+		const unionSchema = z.union([
+			z.object({ commands: z.array(z.string()) }),
+			z.string(),
+		]);
+
+		expect(() =>
+			createTool({
+				name: "union_schema_tool",
+				description: "Tool mistakenly using a union as inputSchema",
+				inputSchema: zodToJsonSchema(unionSchema),
+				execute: async () => ({ ok: true }),
+			}),
+		).toThrow(/top level/i);
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/shared/src/tools/create.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+import type { AgentTool, AgentToolContext } from "../agent";
+import { zodToJsonSchema } from "../parse/zod";
+
+function normalizeToolInputSchema(
+	inputSchema: Record<string, unknown>,
+): Record<string, unknown> {
+	// Zod v4's z.toJSONSchema() always emits a "$schema" meta-key that is not
+	// needed in LLM tool definitions and can confuse strict validators.
+	// Strip it here so all downstream consumers get a clean schema.
+	const { $schema: _ignored, ...schema } = inputSchema;
+
+	if (typeof schema.type === "string") {
+		return schema;
+	}
+	if (
+		"properties" in schema ||
+		"required" in schema ||
+		"additionalProperties" in schema
+	) {
+		return {
+			type: "object",
+			...schema,
+		};
+	}
+	for (const key of ["oneOf", "anyOf", "allOf"] as const) {
+		const branches = schema[key];
+		if (!Array.isArray(branches) || branches.length === 0) {
+			continue;
+		}
+
+		if (key === "allOf") {
+			// allOf means the input must satisfy ALL branches simultaneously.
+			// A single branch explicitly typed as an object is sufficient to
+			// constrain the top-level shape — other branches are free to add
+			// required, minProperties, etc. without repeating type: "object".
+			// If no branch asserts type: "object" we cannot verify the schema
+			// is object-shaped, so fail loudly just as we do for anyOf/oneOf —
+			// the developer should make the object constraint explicit.
+			const hasObjectBranch = branches.some(
+				(branch) =>
+					branch &&
+					typeof branch === "object" &&
+					(branch as Record<string, unknown>).type === "object",
+			);
+			if (hasObjectBranch) {
+				return { type: "object", ...schema };
+			}
+			throw new Error(
+				`Tool inputSchema must describe an object at the top level, but ` +
+					`the schema has a top-level "allOf" with no branch that asserts ` +
+					`type: "object". Add type: "object" to at least one allOf branch ` +
+					`to make the object constraint explicit.`,
+			);
+		}
+
+		// oneOf / anyOf: the input matches ONE (or at least one) branch.
+		// Every branch must be object-shaped — a single non-object branch means
+		// the top-level input can be a string, array, etc., which providers
+		// reject.  Fail loudly at registration time so the bug surfaces
+		// immediately rather than at inference time.
+		const allObjectBranches = branches.every(
+			(branch) =>
+				branch &&
+				typeof branch === "object" &&
+				(branch as Record<string, unknown>).type === "object",
+		);
+		if (allObjectBranches) {
+			return { type: "object", ...schema };
+		}
+		throw new Error(
+			`Tool inputSchema must describe an object at the top level, but ` +
+				`the schema has a top-level "${key}" whose branches include ` +
+				`non-object types. Pass the strict object schema as inputSchema ` +
+				`and reserve union/coercion schemas for use inside execute().`,
+		);
+	}
+	return schema;
+}
+
+export function createTool<TInput, TOutput>(config: {
+	name: string;
+	description: string;
+	inputSchema: Record<string, unknown>;
+	execute: (input: TInput, context: AgentToolContext) => Promise<TOutput>;
+	lifecycle?: AgentTool<TInput, TOutput>["lifecycle"];
+	timeoutMs?: number;
+	retryable?: boolean;
+	maxRetries?: number;
+}): AgentTool<TInput, TOutput>;
+export function createTool<TSchema extends z.ZodTypeAny, TOutput>(config: {
+	name: string;
+	description: string;
+	inputSchema: TSchema;
+	execute: (
+		input: z.infer<TSchema>,
+		context: AgentToolContext,
+	) => Promise<TOutput>;
+	lifecycle?: AgentTool<z.infer<TSchema>, TOutput>["lifecycle"];
+	timeoutMs?: number;
+	retryable?: boolean;
+	maxRetries?: number;
+}): AgentTool<z.infer<TSchema>, TOutput>;
+export function createTool<TInput, TOutput>(config: {
+	name: string;
+	description: string;
+	inputSchema: Record<string, unknown> | z.ZodTypeAny;
+	execute: (input: TInput, context: AgentToolContext) => Promise<TOutput>;
+	lifecycle?: AgentTool<TInput, TOutput>["lifecycle"];
+	timeoutMs?: number;
+	retryable?: boolean;
+	maxRetries?: number;
+}): AgentTool<TInput, TOutput> {
+	const inputSchema = normalizeToolInputSchema(
+		config.inputSchema instanceof z.ZodType
+			? zodToJsonSchema(config.inputSchema)
+			: config.inputSchema,
+	);
+
+	return {
+		name: config.name,
+		description: config.description,
+		inputSchema,
+		lifecycle: config.lifecycle,
+		timeoutMs: config.timeoutMs ?? 30_000,
+		retryable: config.retryable ?? true,
+		maxRetries: config.maxRetries ?? 3,
+		execute: config.execute,
+	};
+}

codna/agent-core/vendor/cline/sdk/packages/shared/src/types/auth.ts

@@ -0,0 +1,41 @@
+/**
+ * Canonical list of OAuth provider IDs managed by the platform.
+ * Derive sets, types, and guards from this single source of truth.
+ */
+export const OAUTH_PROVIDER_IDS = ["cline", "oca", "openai-codex"] as const;
+
+export type OAuthProviderId = (typeof OAUTH_PROVIDER_IDS)[number];
+
+/**
+ * Check whether a provider ID is a managed OAuth provider.
+ */
+export function isOAuthProviderId(
+	providerId: string,
+): providerId is OAuthProviderId {
+	return (OAUTH_PROVIDER_IDS as readonly string[]).includes(providerId);
+}
+
+/**
+ * Error‑message sub-strings that indicate an auth / credential failure.
+ * Used to decide whether a failed API call should trigger an OAuth refresh.
+ */
+export const AUTH_ERROR_PATTERNS = [
+	"401",
+	"403",
+	"unauthorized",
+	"forbidden",
+	"invalid token",
+	"expired token",
+	"authentication",
+] as const;
+
+/**
+ * Returns `true` when `error` looks like an authentication failure
+ * *and* the provider is a managed OAuth provider.
+ */
+export function isLikelyAuthError(error: unknown, providerId: string): boolean {
+	if (!isOAuthProviderId(providerId)) return false;
+	const message =
+		error instanceof Error ? error.message.toLowerCase() : String(error);
+	return AUTH_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
+}

codna/agent-core/vendor/cline/sdk/packages/shared/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from "./auth";
+export * from "./vcr";

codna/agent-core/vendor/cline/sdk/packages/shared/src/types/vcr.ts

@@ -0,0 +1,14 @@
+/** A single recorded HTTP interaction. */
+export interface VcrRecording {
+	scope: string;
+	method: string;
+	path: string;
+	body?: string;
+	/** Sanitized canonical request body used as an optional playback contract. */
+	requestBody?: string;
+	status: number;
+	response: unknown;
+	responseIsBinary: boolean;
+	/** Content-Type header from the original response (captured at record time). */
+	contentType?: string;
+}

codna/agent-core/vendor/cline/sdk/packages/shared/src/vcr.test.ts

@@ -0,0 +1,229 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { disposeAll } from "./dispose";
+import type { VcrRecording } from "./types/vcr";
+import { initVcr } from "./vcr";
+
+const ORIGINAL_ENV = { ...process.env };
+const ORIGINAL_FETCH = globalThis.fetch;
+const tempDirs: string[] = [];
+
+function createTempCassettePath(): string {
+	const dir = mkdtempSync(path.join(os.tmpdir(), "cline-vcr-test-"));
+	tempDirs.push(dir);
+	return path.join(dir, "cassette.json");
+}
+
+function readCassette(filePath: string): VcrRecording[] {
+	return JSON.parse(readFileSync(filePath, "utf8")) as VcrRecording[];
+}
+
+afterEach(async () => {
+	await disposeAll();
+	process.env = { ...ORIGINAL_ENV };
+	globalThis.fetch = ORIGINAL_FETCH;
+	for (const dir of tempDirs.splice(0)) {
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+describe("VCR request body contracts", () => {
+	it("records sanitized request body contracts when opted in", async () => {
+		const cassettePath = createTempCassettePath();
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+		process.env.CLINE_VCR_INCLUDE_REQUEST_BODY = "1";
+		globalThis.fetch = vi.fn(async () => {
+			return new Response(JSON.stringify({ ok: true }), {
+				status: 200,
+				headers: { "content-type": "application/json" },
+			});
+		}) as typeof fetch;
+
+		initVcr("record");
+
+		const response = await fetch("https://api.example.test/v1/chat", {
+			method: "POST",
+			body: JSON.stringify({
+				model: "test-model",
+				api_key: "secret",
+				accessToken: "oauth-secret",
+				z: 2,
+				a: 1,
+			}),
+		});
+		await response.text();
+		await disposeAll();
+
+		const recordings = readCassette(cassettePath);
+		expect(recordings).toHaveLength(1);
+		expect(recordings[0]).not.toHaveProperty("body");
+		expect(recordings[0]?.requestBody).toBe(
+			'{"a":1,"accessToken":"REDACTED","api_key":"REDACTED","model":"test-model","z":2}',
+		);
+	});
+
+	it("canonicalizes URL-encoded bodies when content type is form encoded", async () => {
+		const cassettePath = createTempCassettePath();
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+		process.env.CLINE_VCR_INCLUDE_REQUEST_BODY = "1";
+		globalThis.fetch = vi.fn(async () => {
+			return new Response("ok", {
+				status: 200,
+				headers: { "content-type": "text/plain" },
+			});
+		}) as typeof fetch;
+
+		initVcr("record");
+
+		const response = await fetch("https://api.example.test/v1/token", {
+			method: "POST",
+			headers: {
+				"content-type": "application/x-www-form-urlencoded;charset=UTF-8",
+			},
+			body: "access_token=secret&model=test-model&tag=one&tag=two",
+		});
+		await response.text();
+		await disposeAll();
+
+		const recordings = readCassette(cassettePath);
+		expect(recordings).toHaveLength(1);
+		expect(recordings[0]?.requestBody).toBe(
+			'{"access_token":"REDACTED","model":"test-model","tag":["one","two"]}',
+		);
+	});
+
+	it("leaves URL-encoded-looking strings raw without form content type", async () => {
+		const cassettePath = createTempCassettePath();
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+		process.env.CLINE_VCR_INCLUDE_REQUEST_BODY = "1";
+		globalThis.fetch = vi.fn(async () => {
+			return new Response("ok", {
+				status: 200,
+				headers: { "content-type": "text/plain" },
+			});
+		}) as typeof fetch;
+
+		initVcr("record");
+
+		const response = await fetch("https://api.example.test/v1/upload", {
+			method: "POST",
+			body: "dGVzdA==",
+		});
+		await response.text();
+		await disposeAll();
+
+		const recordings = readCassette(cassettePath);
+		expect(recordings).toHaveLength(1);
+		expect(recordings[0]?.requestBody).toBe("dGVzdA==");
+	});
+
+	it("matches sanitized request body contracts during playback", async () => {
+		const cassettePath = createTempCassettePath();
+		const recording: VcrRecording = {
+			scope: "https://api.example.test",
+			method: "POST",
+			path: "/v1/chat",
+			requestBody: '{"api_key":"REDACTED","model":"test-model"}',
+			status: 200,
+			response: "ok",
+			responseIsBinary: false,
+			contentType: "text/plain",
+		};
+		writeFileSync(cassettePath, JSON.stringify([recording], null, 2));
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+
+		initVcr("playback");
+
+		const response = await fetch("https://api.example.test/v1/chat", {
+			method: "POST",
+			body: JSON.stringify({
+				model: "test-model",
+				api_key: "runtime-secret",
+			}),
+		});
+
+		expect(await response.text()).toBe("ok");
+	});
+
+	it("plays back legacy cassettes without request body contracts", async () => {
+		const cassettePath = createTempCassettePath();
+		const recording: VcrRecording = {
+			scope: "https://api.example.test",
+			method: "POST",
+			path: "/v1/chat",
+			status: 200,
+			response: "ok",
+			responseIsBinary: false,
+			contentType: "text/plain",
+		};
+		writeFileSync(cassettePath, JSON.stringify([recording], null, 2));
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+
+		initVcr("playback");
+
+		const response = await fetch("https://api.example.test/v1/chat", {
+			method: "POST",
+			body: JSON.stringify({
+				model: "changed-model",
+				api_key: "runtime-secret",
+			}),
+		});
+
+		expect(await response.text()).toBe("ok");
+	});
+
+	it("fails playback when the sanitized request body changes", async () => {
+		const cassettePath = createTempCassettePath();
+		const recording: VcrRecording = {
+			scope: "https://api.example.test",
+			method: "POST",
+			path: "/v1/chat",
+			requestBody: '{"api_key":"REDACTED","model":"test-model"}',
+			status: 200,
+			response: "ok",
+			responseIsBinary: false,
+			contentType: "text/plain",
+		};
+		writeFileSync(cassettePath, JSON.stringify([recording], null, 2));
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+
+		initVcr("playback");
+
+		let thrown: unknown;
+		try {
+			await fetch("https://api.example.test/v1/chat", {
+				method: "POST",
+				body: JSON.stringify({
+					model: "other-model",
+					api_key: "runtime-secret",
+				}),
+			});
+		} catch (error) {
+			thrown = error;
+		}
+
+		expect(thrown).toBeInstanceOf(Error);
+		if (!(thrown instanceof Error)) {
+			throw new Error("Expected request body mismatch to throw an Error");
+		}
+		expect(thrown.message).toContain("Request body mismatch");
+		expect(thrown.message).toContain(
+			'expected: {"api_key":"REDACTED","model":"test-model"}',
+		);
+		expect(thrown.message).toContain(
+			'actual:   {"api_key":"REDACTED","model":"other-model"}',
+		);
+
+		const response = await fetch("https://api.example.test/v1/chat", {
+			method: "POST",
+			body: JSON.stringify({
+				model: "test-model",
+				api_key: "runtime-secret",
+			}),
+		});
+
+		expect(await response.text()).toBe("ok");
+	});
+});