codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/runtime/config/agent-runtime-config-builder.test.ts

@@ -0,0 +1,268 @@
+/**
+ * Unit tests for `createAgentRuntimeConfig` and its small pure
+ * helpers (`buildModelOptions`, `buildMessageModelInfo`,
+ * `resolveToolExecution`).
+ *
+ */
+
+import type {
+	AgentConfig,
+	AgentModel,
+	AgentModelEvent,
+	AgentTool,
+	ITelemetryService,
+} from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import {
+	buildMessageModelInfo,
+	buildModelOptions,
+	createAgentRuntimeConfig,
+	resolveToolExecution,
+} from "./agent-runtime-config-builder";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function makeAgentConfig(overrides: Partial<AgentConfig> = {}): AgentConfig {
+	return {
+		providerId: "anthropic",
+		modelId: "claude-3-5-sonnet",
+		systemPrompt: "You are a helpful assistant.",
+		tools: [],
+		...overrides,
+	};
+}
+
+const nullModel: AgentModel = {
+	async stream() {
+		return (async function* (): AsyncIterable<AgentModelEvent> {
+			yield { type: "finish", reason: "stop" };
+		})();
+	},
+};
+
+// ---------------------------------------------------------------------------
+// buildModelOptions
+// ---------------------------------------------------------------------------
+
+describe("buildModelOptions", () => {
+	it("returns undefined when no reasoning/budget fields are set", () => {
+		expect(buildModelOptions(makeAgentConfig())).toBeUndefined();
+	});
+
+	it("collects all provided fields", () => {
+		const config = makeAgentConfig({
+			thinking: true,
+			reasoningEffort: "high",
+			thinkingBudgetTokens: 1024,
+			maxTokensPerTurn: 4096,
+			apiTimeoutMs: 60_000,
+		});
+		expect(buildModelOptions(config)).toEqual({
+			thinking: true,
+			reasoningEffort: "high",
+			thinkingBudgetTokens: 1024,
+			maxTokensPerTurn: 4096,
+			apiTimeoutMs: 60_000,
+		});
+	});
+
+	it("omits undefined fields", () => {
+		const config = makeAgentConfig({ thinking: true });
+		expect(buildModelOptions(config)).toEqual({ thinking: true });
+	});
+});
+
+// ---------------------------------------------------------------------------
+// buildMessageModelInfo
+// ---------------------------------------------------------------------------
+
+describe("buildMessageModelInfo", () => {
+	it("builds { id, provider, family } from AgentConfig", () => {
+		const config = makeAgentConfig({
+			providerId: "openai",
+			modelId: "gpt-4o",
+			providerConfig: { family: "gpt-4" },
+		});
+		expect(buildMessageModelInfo(config)).toEqual({
+			id: "gpt-4o",
+			provider: "openai",
+			family: "gpt-4",
+		});
+	});
+
+	it("omits family when not present in providerConfig", () => {
+		const config = makeAgentConfig();
+		expect(buildMessageModelInfo(config)).toEqual({
+			id: "claude-3-5-sonnet",
+			provider: "anthropic",
+			family: undefined,
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// resolveToolExecution
+// ---------------------------------------------------------------------------
+
+describe("resolveToolExecution", () => {
+	it("returns undefined when unset", () => {
+		expect(resolveToolExecution(undefined)).toBeUndefined();
+	});
+
+	it("returns 'sequential' for 1", () => {
+		expect(resolveToolExecution(1)).toBe("sequential");
+	});
+
+	it("returns 'parallel' for >= 2", () => {
+		expect(resolveToolExecution(2)).toBe("parallel");
+		expect(resolveToolExecution(8)).toBe("parallel");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// createAgentRuntimeConfig
+// ---------------------------------------------------------------------------
+
+describe("createAgentRuntimeConfig", () => {
+	it("produces a config with the PLAN §3.2.1 field mapping", () => {
+		const agentConfig = makeAgentConfig({
+			systemPrompt: "sp",
+			providerId: "openai",
+			modelId: "gpt-4o",
+			providerConfig: { family: "gpt-4" },
+			thinking: true,
+			reasoningEffort: "high",
+			maxIterations: 7,
+			maxParallelToolCalls: 4,
+			completionPolicy: { requireCompletionTool: true },
+			toolPolicies: { "*": { autoApprove: false } },
+			requestToolApproval: async () => ({ approved: true }),
+			consumePendingUserMessage: () => "steer",
+		});
+		const tools: AgentTool[] = [
+			{
+				name: "echo",
+				description: "e",
+				inputSchema: { type: "object" },
+				execute: async () => "x",
+			},
+		];
+		const runtimeConfig = createAgentRuntimeConfig({
+			agentConfig,
+			sessionId: "session_abc",
+			agentId: "agent_abc",
+			conversationId: "conversation_abc",
+			agentRole: "lead",
+			model: nullModel,
+			tools,
+		});
+		expect(runtimeConfig.sessionId).toBe("session_abc");
+		expect(runtimeConfig.agentId).toBe("agent_abc");
+		expect(runtimeConfig.conversationId).toBe("conversation_abc");
+		expect(runtimeConfig.agentRole).toBe("lead");
+		expect(runtimeConfig.systemPrompt).toBe("sp");
+		expect(runtimeConfig.model).toBe(nullModel);
+		expect(runtimeConfig.messageModelInfo).toEqual({
+			id: "gpt-4o",
+			provider: "openai",
+			family: "gpt-4",
+		});
+		expect(runtimeConfig.modelOptions).toEqual({
+			thinking: true,
+			reasoningEffort: "high",
+		});
+		expect(runtimeConfig.tools).toBe(tools);
+		expect(runtimeConfig.maxIterations).toBe(7);
+		expect(runtimeConfig.toolExecution).toBe("parallel");
+		expect(runtimeConfig.completionPolicy).toEqual({
+			requireCompletionTool: true,
+		});
+		expect(runtimeConfig.toolPolicies).toEqual({
+			"*": { autoApprove: false },
+		});
+		expect(runtimeConfig.requestToolApproval).toBe(
+			agentConfig.requestToolApproval,
+		);
+		expect(runtimeConfig.consumePendingUserMessage).toBe(
+			agentConfig.consumePendingUserMessage,
+		);
+	});
+
+	it("uses the override systemPrompt when provided", () => {
+		const runtimeConfig = createAgentRuntimeConfig({
+			agentConfig: makeAgentConfig({ systemPrompt: "default" }),
+			agentId: "a",
+			model: nullModel,
+			systemPrompt: "override",
+		});
+		expect(runtimeConfig.systemPrompt).toBe("override");
+	});
+
+	it("populates hooks when provided", () => {
+		const beforeRun = vi.fn();
+		const runtimeConfig = createAgentRuntimeConfig({
+			agentConfig: makeAgentConfig(),
+			agentId: "a",
+			model: nullModel,
+			hooks: { beforeRun },
+		});
+		expect(runtimeConfig.hooks?.beforeRun).toBe(beforeRun);
+	});
+
+	it("omits hooks when none are provided", () => {
+		const runtimeConfig = createAgentRuntimeConfig({
+			agentConfig: makeAgentConfig(),
+			agentId: "a",
+			model: nullModel,
+		});
+		expect(runtimeConfig.hooks).toBeUndefined();
+	});
+
+	it("passes through plugins/initialMessages/logger/telemetry", () => {
+		const logger = {
+			log: vi.fn(),
+			debug: vi.fn(),
+			info: vi.fn(),
+			warn: vi.fn(),
+			error: vi.fn(),
+		};
+		const telemetryCapture = vi.fn();
+		const telemetry = {
+			capture: telemetryCapture,
+			captureRequired: vi.fn(),
+			setDistinctId: vi.fn(),
+			setMetadata: vi.fn(),
+			updateMetadata: vi.fn(),
+			setCommonProperties: vi.fn(),
+			updateCommonProperties: vi.fn(),
+			isEnabled: () => true,
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: vi.fn(async () => undefined),
+			dispose: vi.fn(async () => undefined),
+		} as unknown as ITelemetryService;
+		const runtimeConfig = createAgentRuntimeConfig({
+			agentConfig: makeAgentConfig(),
+			agentId: "a",
+			model: nullModel,
+			logger,
+			telemetry,
+			plugins: [{ name: "p1" }],
+			initialMessages: [
+				{
+					id: "m1",
+					role: "user",
+					content: [{ type: "text", text: "hi" }],
+					createdAt: 1,
+				},
+			],
+		});
+		expect(runtimeConfig.logger).toBe(logger);
+		expect(runtimeConfig.telemetry).toBe(telemetry);
+		expect(runtimeConfig.plugins).toHaveLength(1);
+		expect(runtimeConfig.initialMessages).toHaveLength(1);
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/runtime/config/agent-runtime-config-builder.ts

@@ -0,0 +1,181 @@
+/**
+ * Build an `AgentRuntimeConfig` from an `AgentConfig` plus session-owned
+ * supporting objects (model handler, tools, hooks, plugins, telemetry).
+ *
+ * The function is intentionally **pure**: it does not create handlers or tools
+ * itself; it receives them already resolved from the caller (`SessionRuntime`)
+ * and wires them into an `AgentRuntimeConfig`.
+ *
+ * Fields that do **not** round-trip into `AgentRuntimeConfig`
+ * (e.g. `execution.maxConsecutiveMistakes`, `execution.loopDetection`) are
+ * consumed by `SessionRuntime` / `MistakeTracker` /
+ * `LoopDetectionTracker` — not passed through here.
+ */
+
+import type {
+	AgentConfig,
+	AgentMessage,
+	AgentModel,
+	AgentRuntimeConfig,
+	AgentRuntimeHooks,
+	AgentRuntimePlugin,
+	AgentRuntimePrepareTurnContext,
+	AgentRuntimePrepareTurnResult,
+	AgentTool,
+	BasicLogger,
+	ITelemetryService,
+} from "@cline/shared";
+
+/**
+ * Inputs required to assemble an `AgentRuntimeConfig`. Distinct from
+ * `AgentConfig` because some of these (the model adapter, the hook
+ * bridge's runtime-hooks bag, a resolved plugin list) can only be
+ * produced inside `SessionRuntime`.
+ */
+export interface CreateAgentRuntimeConfigInput {
+	readonly agentConfig: AgentConfig;
+	/**
+	 * Core/hub runtime session identifier used for host lifecycle operations,
+	 * event routing, persistence, and approval delivery.
+	 */
+	readonly sessionId?: string;
+	readonly agentId: string;
+	/**
+	 * Agent conversation/transcript identifier used by tools, hooks, telemetry,
+	 * and model history correlation.
+	 */
+	readonly conversationId?: string;
+	readonly parentAgentId?: string;
+	/** The role label for teammates (`AgentConfig.role` in sub-agent configs). */
+	readonly agentRole?: string;
+	/** Pre-built model adapter (produced by `apiHandlerToAgentModel`). */
+	readonly model: AgentModel;
+	readonly logger?: BasicLogger;
+	readonly telemetry?: ITelemetryService;
+	/** Pre-built tool array (builtins + plugin-contributed + session extras). */
+	readonly tools?: readonly AgentTool<unknown, unknown>[];
+	readonly toolContextMetadata?: Record<string, unknown>;
+	/** Pre-resolved plugin list from the plugin loader. */
+	readonly plugins?: readonly AgentRuntimePlugin[];
+	/** Runtime hooks supplied by the session/runtime builder. */
+	readonly hooks?: Partial<AgentRuntimeHooks>;
+	/** Host-owned context pipeline invoked before runtime model hooks. */
+	readonly prepareTurn?: (
+		context: AgentRuntimePrepareTurnContext,
+	) =>
+		| Promise<AgentRuntimePrepareTurnResult | undefined>
+		| AgentRuntimePrepareTurnResult
+		| undefined;
+	/** Seed messages (usually `session.conversation.getMessages()`). */
+	readonly initialMessages?: readonly AgentMessage[];
+	/**
+	 * Override for `AgentRuntimeConfig.systemPrompt` — useful when
+	 * the caller has composed additional guidance (e.g. via
+	 * `LocalRuntimeHost.composeSystemPrompt`). Defaults to
+	 * `agentConfig.systemPrompt`.
+	 */
+	readonly systemPrompt?: string;
+}
+
+/**
+ * Produce an `AgentRuntimeConfig` from session-owned runtime inputs.
+ */
+export function createAgentRuntimeConfig(
+	input: CreateAgentRuntimeConfigInput,
+): AgentRuntimeConfig {
+	const { agentConfig } = input;
+
+	const modelOptions = buildModelOptions(agentConfig);
+	const messageModelInfo = buildMessageModelInfo(agentConfig);
+	const hooks = input.hooks;
+	const toolExecution = resolveToolExecution(agentConfig.maxParallelToolCalls);
+
+	const config: AgentRuntimeConfig = {
+		sessionId: input.sessionId ?? agentConfig.sessionId,
+		agentId: input.agentId,
+		conversationId: input.conversationId,
+		parentAgentId: input.parentAgentId,
+		agentRole: input.agentRole,
+		systemPrompt: input.systemPrompt ?? agentConfig.systemPrompt,
+		messageModelInfo,
+		model: input.model,
+		modelOptions,
+		tools: input.tools,
+		hooks,
+		prepareTurn: input.prepareTurn,
+		consumePendingUserMessage: agentConfig.consumePendingUserMessage,
+		plugins: input.plugins,
+		logger: input.logger ?? agentConfig.logger,
+		telemetry: input.telemetry ?? agentConfig.telemetry,
+		initialMessages: input.initialMessages,
+		completionPolicy: agentConfig.completionPolicy,
+		maxIterations: agentConfig.maxIterations,
+		toolExecution,
+		toolPolicies: agentConfig.toolPolicies,
+		toolContextMetadata: input.toolContextMetadata,
+		requestToolApproval: agentConfig.requestToolApproval,
+	};
+
+	return config;
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+/**
+ * Collect the provider-/reasoning-related fields from `AgentConfig`
+ * into `AgentRuntimeConfig.modelOptions`. Kept undefined when every
+ * field is undefined so the runtime does not receive an empty object.
+ */
+export function buildModelOptions(
+	config: AgentConfig,
+): Record<string, unknown> | undefined {
+	const options: Record<string, unknown> = {};
+	if (config.thinking !== undefined) {
+		options.thinking = config.thinking;
+	}
+	if (config.reasoningEffort !== undefined) {
+		options.reasoningEffort = config.reasoningEffort;
+	}
+	if (config.thinkingBudgetTokens !== undefined) {
+		options.thinkingBudgetTokens = config.thinkingBudgetTokens;
+	}
+	if (config.maxTokensPerTurn !== undefined) {
+		options.maxTokensPerTurn = config.maxTokensPerTurn;
+	}
+	if (config.apiTimeoutMs !== undefined) {
+		options.apiTimeoutMs = config.apiTimeoutMs;
+	}
+	return Object.keys(options).length > 0 ? options : undefined;
+}
+
+/**
+ * Compose `messageModelInfo` from the provider-related fields per
+ * §3.2.1: `{ id: modelId, provider: providerId, family:
+ * providerConfig?.family }`.
+ */
+export function buildMessageModelInfo(
+	config: AgentConfig,
+): AgentMessage["modelInfo"] {
+	const family = (config.providerConfig as { family?: string } | undefined)
+		?.family;
+	return {
+		id: config.modelId,
+		provider: config.providerId,
+		family,
+	};
+}
+
+/**
+ * `"parallel"` when `maxParallelToolCalls ≥ 2`, `"sequential"` when
+ * `1`, `undefined` when the caller did not specify.
+ */
+export function resolveToolExecution(
+	maxParallelToolCalls: number | undefined,
+): "sequential" | "parallel" | undefined {
+	if (maxParallelToolCalls === undefined) {
+		return undefined;
+	}
+	return maxParallelToolCalls >= 2 ? "parallel" : "sequential";
+}