@clinebot/core 0.0.36 → 0.0.37

package/src/runtime/session-runtime.ts

@@ -1,10 +1,10 @@
-import type { Agent } from "@clinebot/agents";
 import type {
 	AgentConfig,
 	AgentHooks,
 	AgentResult,
 	BasicLogger,
 	ITelemetryService,
+	RuntimeConfigExtensionKind,
 	Tool,
 } from "@clinebot/shared";
 import type { UserInstructionConfigWatcher } from "../extensions/config";
@@ -16,6 +16,19 @@ import type {
 } from "../extensions/tools/team";
 import type { CoreSessionConfig } from "../types/config";
 
+/**
+ * Internal structural alias for the lead-agent handle that
+ * {@link BuiltRuntime.registerLeadAgent} hands off to
+ * `runtime-builder.ts`. Narrowed to only the `.addTools()` surface the
+ * callback exercises; avoids depending on `@clinebot/agents`' `Agent`
+ * class during the PLAN.md §3.6 Step 5 type-only migration. When
+ * SessionRuntime is rebuilt in Step 6, this field is expected to be
+ * dropped entirely per §3.5 row #2.
+ */
+type LeadAgentHandle = {
+	addTools(tools: Tool[]): unknown;
+};
+
 export interface BuiltRuntime {
 	tools: Tool[];
 	hooks?: AgentHooks;
@@ -25,7 +38,7 @@ export interface BuiltRuntime {
 	teamRestoredFromPersistence?: boolean;
 	delegatedAgentConfigProvider?: DelegatedAgentConfigProvider;
 	completionGuard?: () => string | undefined;
-	registerLeadAgent?: (agent: Agent) => void;
+	registerLeadAgent?: (agent: LeadAgentHandle) => void;
 	shutdown: (reason: string) => Promise<void> | void;
 }
 
@@ -37,6 +50,7 @@ export interface RuntimeBuilderInput {
 	createSpawnTool?: () => Tool;
 	onTeamRestored?: () => void;
 	userInstructionWatcher?: UserInstructionConfigWatcher;
+	configExtensions?: RuntimeConfigExtensionKind[];
 	defaultToolExecutors?: Partial<ToolExecutors>;
 	logger?: BasicLogger;
 	telemetry?: ITelemetryService;

package/src/runtime/user-input-builder.ts

@@ -0,0 +1,167 @@
+/**
+ * User-input / first-turn content assembler.
+ *
+ * @see PLAN.md §3.1 — moved from `packages/agents/src/utils/agent-input.ts`.
+ * @see PLAN.md §3.2.4 — called from the `Agent.run/continue` facade via
+ *                      the `buildInitialUserContent` helper.
+ *
+ * Pure port. Opens the first user ContentBlock[] for a turn, loading user
+ * file contents via the injected `userFileContentLoader` (already
+ * core-owned per §3.1 notes on `packages/core/src/transports/local.ts`).
+ */
+
+import type * as LlmsProviders from "@clinebot/llms";
+
+export async function buildInitialUserContent(
+	userMessage: string,
+	userImages?: string[],
+	userFiles?: string[],
+	userFileContentLoader?: (path: string) => Promise<string>,
+): Promise<string | LlmsProviders.ContentBlock[]> {
+	const imageBlocks = buildImageBlocks(userImages);
+	const fileTextBlocks = await buildUserFileContentBlock(
+		userFiles,
+		userFileContentLoader,
+	);
+
+	if (imageBlocks.length === 0 && !fileTextBlocks) {
+		return userMessage;
+	}
+
+	const content: LlmsProviders.ContentBlock[] = [
+		{
+			type: "text",
+			text: userMessage,
+		},
+		...imageBlocks,
+	];
+	if (fileTextBlocks) {
+		content.push(...fileTextBlocks);
+	}
+	return content;
+}
+
+/**
+ * Normalize a user message shape into a plain string when possible.
+ *
+ * @see PLAN.md §3.1 — exported from the user-input-builder module so
+ *                    SessionRuntime can use it to sanitise ad-hoc input.
+ *
+ * Accepts either a string or a LlmsProviders.Message; returns the best-effort
+ * concatenated plain-text body. Non-text content is ignored.
+ */
+export function normalizeUserMessage(
+	input: string | LlmsProviders.Message | undefined,
+): string {
+	if (input == null) {
+		return "";
+	}
+	if (typeof input === "string") {
+		return input;
+	}
+	const content = input.content;
+	if (typeof content === "string") {
+		return content;
+	}
+	if (!Array.isArray(content)) {
+		return "";
+	}
+	const textParts: string[] = [];
+	for (const block of content) {
+		if (block && typeof block === "object" && block.type === "text") {
+			const text = (block as { text?: unknown }).text;
+			if (typeof text === "string") {
+				textParts.push(text);
+			}
+		}
+	}
+	return textParts.join("\n");
+}
+
+function buildImageBlocks(userImages?: string[]): LlmsProviders.ImageContent[] {
+	if (!userImages || userImages.length === 0) {
+		return [];
+	}
+
+	const blocks: LlmsProviders.ImageContent[] = [];
+	for (const image of userImages) {
+		const block = parseDataUrlImage(image);
+		if (block) {
+			blocks.push(block);
+		}
+	}
+	return blocks;
+}
+
+function parseDataUrlImage(
+	image: string,
+): LlmsProviders.ImageContent | undefined {
+	const value = image.trim();
+	if (!value) {
+		return undefined;
+	}
+
+	const dataUrlMatch = value.match(/^data:([^;,]+);base64,(.+)$/);
+	if (dataUrlMatch) {
+		const mediaType = dataUrlMatch[1];
+		const data = dataUrlMatch[2];
+		if (!mediaType || !data) {
+			return undefined;
+		}
+		return {
+			type: "image",
+			mediaType,
+			data,
+		};
+	}
+
+	// Fallback: treat as plain base64 payload.
+	return {
+		type: "image",
+		mediaType: "image/png",
+		data: value,
+	};
+}
+
+async function buildUserFileContentBlock(
+	userFiles?: string[],
+	userFileContentLoader?: (path: string) => Promise<string>,
+): Promise<LlmsProviders.FileContent[] | undefined> {
+	if (!userFiles || userFiles.length === 0) {
+		return undefined;
+	}
+
+	const loader =
+		userFileContentLoader ??
+		(async () => {
+			throw new Error(
+				"File loading is not configured in this runtime. Provide userFileContentLoader to enable userFiles support.",
+			);
+		});
+
+	const contents = await Promise.all(
+		userFiles.map(async (filePath) => {
+			const normalizedPath = filePath.replace(/\\/g, "/");
+			try {
+				const content = await loader(filePath);
+				return {
+					type: "file",
+					path: normalizedPath,
+					content,
+				} satisfies LlmsProviders.FileContent;
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return {
+					type: "file",
+					path: normalizedPath,
+					content: `Error fetching content: ${message}`,
+				} satisfies LlmsProviders.FileContent;
+			}
+		}),
+	);
+
+	if (contents.length === 0) {
+		return undefined;
+	}
+	return contents;
+}

package/src/services/local-runtime-bootstrap.ts

@@ -1,12 +1,15 @@
 import type {
 	AgentConfig,
 	AgentHooks,
+	ExtensionContext,
 	ITelemetryService,
+	RuntimeConfigExtensionKind,
 	Tool,
 	ToolApprovalRequest,
 	ToolApprovalResult,
 	WorkspaceInfo,
 } from "@clinebot/shared";
+import { decodeJwtPayload } from "../auth/utils";
 import { resolveAndLoadAgentPlugins } from "../extensions/plugin/plugin-config-loader";
 import type {
 	PluginInitializationFailure,
@@ -89,8 +92,72 @@ function resolveReasoningSettings(
 	};
 }
 
+const ALL_CONFIG_EXTENSIONS: readonly RuntimeConfigExtensionKind[] = [
+	"rules",
+	"skills",
+	"plugins",
+];
+
+function hasConfigExtension(
+	extensions: ReadonlyArray<RuntimeConfigExtensionKind> | undefined,
+	kind: RuntimeConfigExtensionKind,
+): boolean {
+	return new Set(extensions ?? ALL_CONFIG_EXTENSIONS).has(kind);
+}
+
+function buildOpenAICodexHeaders(input: {
+	sessionId: string;
+	configHeaders: CoreSessionConfig["headers"];
+	storedHeaders: ProviderSettings["headers"];
+	accountId?: string;
+	accessToken?: string;
+}): Record<string, string> | undefined {
+	const headers: Record<string, string> = {
+		...(input.storedHeaders ?? {}),
+		...(input.configHeaders ?? {}),
+	};
+	const resolvedAccountId =
+		input.accountId?.trim() || deriveOpenAICodexAccountId(input.accessToken);
+	headers.originator = "cline";
+	headers.session_id = input.sessionId;
+	headers["User-Agent"] = `Cline/${process.env.npm_package_version || "1.0.0"}`;
+	if (resolvedAccountId) {
+		headers["ChatGPT-Account-Id"] = resolvedAccountId;
+	}
+	return headers;
+}
+
+function deriveOpenAICodexAccountId(
+	accessToken: string | undefined,
+): string | undefined {
+	const trimmed = accessToken?.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	const payload = decodeJwtPayload(trimmed) as {
+		"https://api.openai.com/auth"?: { chatgpt_account_id?: string };
+		organizations?: Array<{ id?: string }>;
+		chatgpt_account_id?: string;
+	} | null;
+	const authAccountId =
+		payload?.["https://api.openai.com/auth"]?.chatgpt_account_id;
+	if (typeof authAccountId === "string" && authAccountId.length > 0) {
+		return authAccountId;
+	}
+	const orgAccountId = payload?.organizations?.[0]?.id;
+	if (typeof orgAccountId === "string" && orgAccountId.length > 0) {
+		return orgAccountId;
+	}
+	const rootAccountId = payload?.chatgpt_account_id;
+	if (typeof rootAccountId === "string" && rootAccountId.length > 0) {
+		return rootAccountId;
+	}
+	return undefined;
+}
+
 function buildProviderConfig(
 	config: CoreSessionConfig,
+	sessionId: string,
 	providerSettingsManager: ProviderSettingsManager,
 	modelCatalogDefaults?: Partial<ProviderSettings["modelCatalog"]>,
 	defaultFetch?: typeof fetch,
@@ -109,7 +176,17 @@ function buildProviderConfig(
 		model: config.modelId,
 		apiKey: config.apiKey ?? stored?.apiKey,
 		baseUrl: config.baseUrl ?? stored?.baseUrl,
-		headers: config.headers ?? stored?.headers,
+		headers:
+			config.providerId === "openai-codex"
+				? buildOpenAICodexHeaders({
+						sessionId,
+						configHeaders: config.headers,
+						storedHeaders: stored?.headers,
+						accountId: stored?.auth?.accountId,
+						accessToken:
+							config.apiKey ?? stored?.auth?.accessToken ?? stored?.apiKey,
+					})
+				: (config.headers ?? stored?.headers),
 		reasoning: resolveReasoningSettings(config, stored?.reasoning),
 		modelCatalog,
 	};
@@ -202,6 +279,23 @@ export async function prepareLocalRuntimeBootstrap(
 	// as workspaceMetadata; the structured object is kept as workspaceInfo.
 	const { workspaceInfo, workspaceMetadata } =
 		await buildWorkspaceMetadataWithInfo(input.config.cwd);
+	const configuredExtensionContext = localConfig?.extensionContext;
+	const extensionContext: ExtensionContext = {
+		...(configuredExtensionContext ?? {}),
+		workspace: {
+			...workspaceInfo,
+			...(configuredExtensionContext?.workspace ?? {}),
+		},
+		session: {
+			...(configuredExtensionContext?.session ?? {}),
+			sessionId,
+		},
+		logger: configuredExtensionContext?.logger ?? configOverrides?.logger,
+		telemetry:
+			configuredExtensionContext?.telemetry ??
+			configOverrides?.telemetry ??
+			defaultTelemetry,
+	};
 
 	const fileHooks = createHookConfigFileHooks({
 		cwd: input.config.cwd,
@@ -226,26 +320,34 @@ export async function prepareLocalRuntimeBootstrap(
 	let loadedPlugins:
 		| Awaited<ReturnType<typeof resolveAndLoadAgentPlugins>>
 		| undefined;
-	try {
-		loadedPlugins = await resolveAndLoadAgentPlugins({
-			pluginPaths: localConfig?.pluginPaths,
-			workspacePath,
-			cwd: input.config.cwd,
-			onEvent: onPluginEvent,
-			providerId: input.config.providerId,
-			modelId: input.config.modelId,
-			workspaceInfo,
-		});
-		logPluginDiagnostics(
-			loadedPlugins.failures,
-			loadedPlugins.warnings,
-			configOverrides?.logger,
-		);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		configOverrides?.logger?.log?.(
-			`plugin loading failed; continuing without plugins (${message})`,
-		);
+	if (hasConfigExtension(localRuntime?.configExtensions, "plugins")) {
+		try {
+			loadedPlugins = await resolveAndLoadAgentPlugins({
+				pluginPaths: localConfig?.pluginPaths,
+				workspacePath,
+				cwd: input.config.cwd,
+				onEvent: onPluginEvent,
+				providerId: input.config.providerId,
+				modelId: input.config.modelId,
+				workspaceInfo,
+				session: extensionContext.session,
+				client: extensionContext.client,
+				user: extensionContext.user,
+				logger: extensionContext.logger,
+				telemetry: extensionContext.telemetry,
+				automation: extensionContext.automation,
+			});
+			logPluginDiagnostics(
+				loadedPlugins.failures,
+				loadedPlugins.warnings,
+				configOverrides?.logger,
+			);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			configOverrides?.logger?.log?.(
+				`plugin loading failed; continuing without plugins (${message})`,
+			);
+		}
 	}
 
 	const extensions = mergeAgentExtensions(
@@ -255,12 +357,15 @@ export async function prepareLocalRuntimeBootstrap(
 	const baseConfig: CoreSessionConfig = {
 		...input.config,
 		...(configOverrides ?? {}),
+		sessionId,
 		hooks: baseHooks,
 		extensions,
-		telemetry: configOverrides?.telemetry ?? defaultTelemetry,
+		extensionContext,
+		telemetry: extensionContext.telemetry,
 	};
 	const providerConfig = buildProviderConfig(
 		baseConfig,
+		sessionId,
 		providerSettingsManager,
 		localRuntime?.modelCatalogDefaults,
 		defaultFetch,
@@ -310,6 +415,7 @@ export async function prepareLocalRuntimeBootstrap(
 			createSpawnTool,
 			onTeamRestored: localRuntime?.onTeamRestored,
 			userInstructionWatcher: localRuntime?.userInstructionWatcher,
+			configExtensions: localRuntime?.configExtensions,
 			defaultToolExecutors: effectiveToolExecutors,
 			logger: config.logger,
 			telemetry: config.telemetry,

package/src/services/plugin-tools.ts

@@ -29,6 +29,7 @@ function collectRegisteredTools(
 		registerCommand: () => {},
 		registerMessageBuilder: () => {},
 		registerProvider: () => {},
+		registerAutomationEventType: () => {},
 	};
 	extension.setup(api, { workspaceInfo });
 	return tools;