codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/agents/bun.mts

@@ -0,0 +1,29 @@
+/// <reference types="@types/bun" />
+export {};
+
+// Externalize third-party runtime deps plus the provider/runtime layer that
+// the Agent facade loads dynamically. `@cline/shared` stays bundled.
+const external = ["@cline/llms", "nanoid"];
+const sourcemap = Bun.env.CLINE_SOURCEMAPS === "1" ? "linked" : "none";
+
+const builds: Parameters<typeof Bun.build>[0][] = [
+	{
+		entrypoints: ["./src/index.ts"],
+		outdir: "./dist",
+		target: "node",
+		minify: true,
+		sourcemap,
+		packages: "bundle",
+		external,
+	},
+];
+
+for (const config of builds) {
+	const result = await Bun.build(config);
+
+	if (result.logs.length > 0) {
+		for (const log of result.logs) {
+			console.warn(log);
+		}
+	}
+}

codna/agent-core/vendor/cline/sdk/packages/agents/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@cline/agents",
+	"version": "0.0.44",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/cline/cline",
+		"directory": "sdk/packages/agents"
+	},
+	"main": "dist/index.js",
+	"dependencies": {
+		"@cline/llms": "workspace:*",
+		"@cline/shared": "workspace:*",
+		"nanoid": "^5.1.7"
+	},
+	"exports": {
+		".": {
+			"browser": "./dist/index.js",
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"description": "Browser-safe agent runtime for the next-generation Cline SDK",
+	"files": [
+		"dist"
+	],
+	"keywords": [
+		"llm",
+		"agents",
+		"ai",
+		"tool-calling"
+	],
+	"license": "Apache-2.0",
+	"scripts": {
+		"build": "bun run bun.mts && bun tsc -p tsconfig.build.json",
+		"dev": "bun build ./src/index.ts --outdir ./dist --target node --format esm --watch",
+		"typecheck": "bun tsc -p tsconfig.dev.json --noEmit",
+		"test": "vitest run",
+		"test:watch": "vitest"
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"type": "module",
+	"types": "dist/index.d.ts"
+}

codna/agent-core/vendor/cline/sdk/packages/agents/src/agent-runtime.provider-form.test.ts

@@ -0,0 +1,210 @@
+import type {
+	AgentMessage,
+	AgentModel,
+	AgentModelEvent,
+	AgentModelRequest,
+	AgentRuntimeEvent,
+} from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AgentRuntime, AgentRuntimeAbortError } from "./agent-runtime";
+import { Agent, createAgent } from "./index";
+
+const { createAgentModel, createGateway } = vi.hoisted(() => {
+	const createAgentModel = vi.fn();
+	const createGateway = vi.fn(() => ({
+		createAgentModel,
+	}));
+	return { createAgentModel, createGateway };
+});
+
+vi.mock("@cline/llms", () => ({
+	createGateway,
+}));
+
+class ScriptedModel implements AgentModel {
+	constructor(
+		private readonly steps: Array<
+			(
+				request: AgentModelRequest,
+			) => Iterable<AgentModelEvent> | AsyncIterable<AgentModelEvent>
+		>,
+	) {}
+
+	async stream(
+		request: AgentModelRequest,
+	): Promise<AsyncIterable<AgentModelEvent>> {
+		const step = this.steps.shift();
+		if (!step) {
+			throw new Error("No scripted model step available");
+		}
+		return toAsyncIterable(step(request));
+	}
+}
+
+async function* toAsyncIterable(
+	events: Iterable<AgentModelEvent> | AsyncIterable<AgentModelEvent>,
+): AsyncIterable<AgentModelEvent> {
+	for await (const event of events) {
+		yield event;
+	}
+}
+
+describe("AgentRuntime (provider-form config + Agent alias)", () => {
+	beforeEach(() => {
+		createGateway.mockClear();
+		createAgentModel.mockReset();
+	});
+
+	it("constructs the runtime via the llms gateway in ESM-safe code", () => {
+		const model = new ScriptedModel([]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = new Agent({
+			providerId: "openai",
+			modelId: "gpt-5",
+			apiKey: "test-key",
+		});
+
+		expect(agent).toBeInstanceOf(Agent);
+		expect(createGateway).toHaveBeenCalledWith({
+			providerConfigs: [
+				{
+					providerId: "openai",
+					apiKey: "test-key",
+					baseUrl: undefined,
+					headers: undefined,
+				},
+			],
+		});
+		expect(createAgentModel).toHaveBeenCalledWith({
+			providerId: "openai",
+			modelId: "gpt-5",
+		});
+	});
+
+	it("forwards abort() to the active AgentRuntime", async () => {
+		let abortReason: unknown;
+		const model = new ScriptedModel([
+			async function* (request) {
+				yield { type: "text-delta", text: "partial" };
+				await new Promise<void>((resolve) => {
+					request.signal?.addEventListener(
+						"abort",
+						() => {
+							abortReason = request.signal?.reason;
+							resolve();
+						},
+						{ once: true },
+					);
+				});
+				yield { type: "finish", reason: "aborted" };
+			},
+		]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = new Agent({
+			providerId: "openai",
+			modelId: "gpt-5",
+		});
+
+		const runPromise = agent.run("cancel me");
+		for (let i = 0; i < 20; i += 1) {
+			if (agent.snapshot().status === "running") {
+				break;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 0));
+		}
+		agent.abort("user cancelled");
+
+		await expect(runPromise).resolves.toMatchObject({
+			status: "aborted",
+		});
+		expect(abortReason).toBeInstanceOf(AgentRuntimeAbortError);
+		if (!(abortReason instanceof AgentRuntimeAbortError)) {
+			throw new Error("expected agent runtime abort reason");
+		}
+		expect(abortReason.message).toBe("user cancelled");
+		expect(abortReason.reason).toBe("user cancelled");
+	});
+
+	it("createAgent() and new Agent() both return an AgentRuntime instance", () => {
+		const model = new ScriptedModel([]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = createAgent({
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4-6",
+		});
+
+		// After the facade/runtime merge (Option B), `Agent` is an alias for
+		// `AgentRuntime`. Both constructors return the same class — verified
+		// here so future refactors don't silently reintroduce a split.
+		expect(agent).toBeInstanceOf(Agent);
+		expect(agent).toBeInstanceOf(AgentRuntime);
+		expect(Agent).toBe(AgentRuntime);
+	});
+
+	it("restores conversation state by rebuilding the runtime", () => {
+		const model = new ScriptedModel([]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = new Agent({
+			providerId: "openai",
+			modelId: "gpt-5",
+		});
+		const messages: AgentMessage[] = [
+			{
+				id: "msg_1",
+				role: "user",
+				content: [{ type: "text", text: "hello" }],
+				createdAt: 1,
+			},
+		];
+
+		agent.restore(messages);
+
+		expect(agent.snapshot().messages).toEqual(messages);
+		expect(agent.snapshot().status).toBe("idle");
+	});
+
+	it("rebinds existing subscribers when restore() replaces the runtime", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{ type: "text-delta", text: "hello" },
+				{ type: "finish", reason: "stop" },
+			],
+			() => [
+				{ type: "text-delta", text: "again" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = new Agent({
+			providerId: "openai",
+			modelId: "gpt-5",
+		});
+		const received: AgentRuntimeEvent["type"][] = [];
+		const unsubscribe = agent.subscribe((event) => {
+			received.push(event.type);
+		});
+
+		agent.restore([
+			{
+				id: "msg_1",
+				role: "user",
+				content: [{ type: "text", text: "restored" }],
+				createdAt: 1,
+			},
+		]);
+		await agent.run("hello");
+
+		expect(received).toContain("run-started");
+		expect(received).toContain("run-finished");
+
+		const countAfterRun = received.length;
+		unsubscribe();
+		await agent.run("again");
+		expect(received).toHaveLength(countAfterRun);
+	});
+});