@clinebot/core 0.0.35 → 0.0.37

package/src/runtime/session-runtime.ts

@@ -1,11 +1,10 @@
-import type { Agent } from "@clinebot/agents";
 import type {
 	AgentConfig,
 	AgentHooks,
 	AgentResult,
 	BasicLogger,
 	ITelemetryService,
-	TeamTeammateSpec,
+	RuntimeConfigExtensionKind,
 	Tool,
 } from "@clinebot/shared";
 import type { UserInstructionConfigWatcher } from "../extensions/config";
@@ -17,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;
@@ -26,32 +38,10 @@ export interface BuiltRuntime {
 	teamRestoredFromPersistence?: boolean;
 	delegatedAgentConfigProvider?: DelegatedAgentConfigProvider;
 	completionGuard?: () => string | undefined;
-	registerLeadAgent?: (agent: Agent) => void;
+	registerLeadAgent?: (agent: LeadAgentHandle) => void;
 	shutdown: (reason: string) => Promise<void> | void;
 }
 
-export interface TeamToolsFactoryOptions {
-	runtime: AgentTeamsRuntime;
-	teammateConfigProvider: DelegatedAgentConfigProvider;
-	createBaseTools?: () => Tool[];
-	leadAgentId?: string;
-	restoredTeammates?: TeamTeammateSpec[];
-	restoredFromPersistence?: boolean;
-	includeLeadSpawnTool?: boolean;
-	includeLeadManagementTools?: boolean;
-	onLeadToolsUnlocked?: (tools: Tool[]) => void;
-}
-
-export interface TeamToolsFactoryResult {
-	tools: Tool[];
-	restoredFromPersistence: boolean;
-	restoredTeammates: string[];
-}
-
-export type TeamToolsFactory = (
-	options: TeamToolsFactoryOptions,
-) => TeamToolsFactoryResult;
-
 export interface RuntimeBuilderInput {
 	config: CoreSessionConfig;
 	hooks?: AgentHooks;
@@ -60,10 +50,10 @@ export interface RuntimeBuilderInput {
 	createSpawnTool?: () => Tool;
 	onTeamRestored?: () => void;
 	userInstructionWatcher?: UserInstructionConfigWatcher;
+	configExtensions?: RuntimeConfigExtensionKind[];
 	defaultToolExecutors?: Partial<ToolExecutors>;
 	logger?: BasicLogger;
 	telemetry?: ITelemetryService;
-	teamToolsFactory?: TeamToolsFactory;
 }
 
 export interface RuntimeBuilder {

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/global-settings.ts

@@ -0,0 +1,122 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import type { AgentConfig, Tool } from "@clinebot/shared";
+import { resolveGlobalSettingsPath } from "@clinebot/shared/storage";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentExtensionApi = Parameters<NonNullable<AgentExtension["setup"]>>[0];
+
+export interface GlobalSettings {
+	disabledTools?: string[];
+}
+
+function normalizeDisabledTools(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) {
+		return undefined;
+	}
+
+	const normalized = [
+		...new Set(
+			value
+				.filter((entry): entry is string => typeof entry === "string")
+				.map((entry) => entry.trim())
+				.filter(Boolean),
+		),
+	].sort((left, right) => left.localeCompare(right));
+
+	return normalized.length > 0 ? normalized : undefined;
+}
+
+export function readGlobalSettings(): GlobalSettings {
+	const filePath = resolveGlobalSettingsPath();
+	try {
+		const parsed = JSON.parse(readFileSync(filePath, "utf8")) as GlobalSettings;
+		return {
+			disabledTools: normalizeDisabledTools(parsed.disabledTools),
+		};
+	} catch {
+		return {};
+	}
+}
+
+export function writeGlobalSettings(settings: GlobalSettings): void {
+	const filePath = resolveGlobalSettingsPath();
+	mkdirSync(dirname(filePath), { recursive: true });
+	const normalizedDisabledTools = normalizeDisabledTools(
+		settings.disabledTools,
+	);
+	const normalized: GlobalSettings = normalizedDisabledTools
+		? { disabledTools: normalizedDisabledTools }
+		: {};
+	writeFileSync(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+}
+
+export function resolveDisabledToolNames(
+	disabledToolNames?: ReadonlyArray<string>,
+): Set<string> {
+	return new Set(disabledToolNames ?? readGlobalSettings().disabledTools ?? []);
+}
+
+export function isToolDisabledGlobally(toolName: string): boolean {
+	return resolveDisabledToolNames().has(toolName);
+}
+
+export function toggleDisabledTool(toolName: string): boolean {
+	const disabled = resolveDisabledToolNames();
+	if (disabled.has(toolName)) {
+		disabled.delete(toolName);
+		writeGlobalSettings({ disabledTools: [...disabled] });
+		return false;
+	}
+
+	disabled.add(toolName);
+	writeGlobalSettings({ disabledTools: [...disabled] });
+	return true;
+}
+
+export function filterDisabledTools<T extends Pick<Tool, "name">>(
+	tools: ReadonlyArray<T>,
+	disabledToolNames?: ReadonlyArray<string>,
+): T[] {
+	const disabled = resolveDisabledToolNames(disabledToolNames);
+	if (disabled.size === 0) {
+		return [...tools];
+	}
+	return tools.filter((tool) => !disabled.has(tool.name));
+}
+
+export function filterExtensionToolRegistrations(
+	extensions: AgentConfig["extensions"],
+	disabledToolNames?: ReadonlyArray<string>,
+): AgentConfig["extensions"] {
+	if (!extensions || extensions.length === 0) {
+		return extensions;
+	}
+
+	const disabled = resolveDisabledToolNames(disabledToolNames);
+	if (disabled.size === 0) {
+		return extensions;
+	}
+
+	return extensions.map((extension) => {
+		if (!extension.setup) {
+			return extension;
+		}
+
+		return {
+			...extension,
+			setup: (api: AgentExtensionApi, ctx) =>
+				extension.setup?.(
+					{
+						...api,
+						registerTool: (tool) => {
+							if (!disabled.has(tool.name)) {
+								api.registerTool(tool);
+							}
+						},
+					},
+					ctx,
+				),
+		};
+	});
+}