@clinebot/core 0.0.35 → 0.0.36

package/src/transports/local.ts

@@ -29,6 +29,7 @@ import type { HookEventPayload } from "../hooks";
 import { DefaultRuntimeBuilder } from "../runtime/runtime-builder";
 import type {
 	RuntimeHost,
+	RuntimeHostSubscribeOptions,
 	SendSessionInput,
 	SessionAccumulatedUsage,
 	StartSessionInput,
@@ -47,6 +48,7 @@ import {
 	handleAgentEvent,
 } from "../services/agent-events";
 import { resolveWorkspacePath } from "../services/config";
+import { filterDisabledTools } from "../services/global-settings";
 import { prepareLocalRuntimeBootstrap } from "../services/local-runtime-bootstrap";
 import { nowIso } from "../services/session-artifacts";
 import {
@@ -73,15 +75,14 @@ import {
 } from "../services/usage";
 import { enrichPromptWithMentions } from "../services/workspace";
 import type { FileSessionService } from "../session/file-session-service";
-import type { RpcCoreSessionService } from "../session/rpc-session-service";
 import {
 	type SessionManifest,
 	SessionManifestSchema,
 } from "../session/session-manifest";
+import type { SessionRow } from "../session/session-row";
 import type {
 	CoreSessionService,
 	RootSessionArtifacts,
-	SessionRow,
 } from "../session/session-service";
 import {
 	buildTeamRunContinuationPrompt,
@@ -106,10 +107,7 @@ import {
 	replaySubagentHookEvent,
 } from "./runtime-host-support";
 
-type SessionBackend =
-	| CoreSessionService
-	| RpcCoreSessionService
-	| FileSessionService;
+type SessionBackend = CoreSessionService | FileSessionService;
 
 const MAX_SCAN_LIMIT = 5000;
 const MAX_USER_FILE_BYTES = 20 * 1_000 * 1_024;
@@ -129,13 +127,57 @@ async function loadUserFileContent(path: string): Promise<string> {
 	return content;
 }
 
+function toActiveSessionRecord(session: ActiveSession): SessionRecord {
+	return {
+		sessionId: session.sessionId,
+		source: session.source,
+		pid: process.pid,
+		startedAt: session.startedAt,
+		endedAt: null,
+		exitCode: null,
+		status: "running",
+		interactive: session.interactive,
+		provider: session.config.providerId,
+		model: session.config.modelId,
+		cwd: session.config.cwd,
+		workspaceRoot: resolveWorkspacePath(session.config),
+		teamName: session.config.teamName?.trim() || undefined,
+		enableTools: session.config.enableTools,
+		enableSpawn: session.config.enableSpawnAgent,
+		enableTeams: session.config.enableAgentTeams,
+		parentSessionId:
+			typeof session.sessionMetadata?.parentSessionId === "string"
+				? session.sessionMetadata.parentSessionId
+				: undefined,
+		parentAgentId:
+			typeof session.sessionMetadata?.parentAgentId === "string"
+				? session.sessionMetadata.parentAgentId
+				: undefined,
+		agentId:
+			typeof session.sessionMetadata?.agentId === "string"
+				? session.sessionMetadata.agentId
+				: undefined,
+		conversationId:
+			typeof session.sessionMetadata?.conversationId === "string"
+				? session.sessionMetadata.conversationId
+				: undefined,
+		isSubagent:
+			typeof session.sessionMetadata?.isSubagent === "boolean"
+				? session.sessionMetadata.isSubagent
+				: false,
+		prompt: session.pendingPrompt,
+		metadata: session.sessionMetadata,
+		messagesPath: session.artifacts?.messagesPath,
+		updatedAt: session.startedAt,
+	};
+}
+
 export interface LocalRuntimeHostOptions {
 	distinctId?: string;
 	sessionService: SessionBackend;
 	runtimeBuilder?: RuntimeBuilder;
 	createAgent?: (config: AgentConfig) => Agent;
 	defaultToolExecutors?: Partial<ToolExecutors>;
-	teamToolsFactory?: import("../runtime/session-runtime").TeamToolsFactory;
 	toolPolicies?: AgentConfig["toolPolicies"];
 	providerSettingsManager?: ProviderSettingsManager;
 	oauthTokenManager?: RuntimeOAuthTokenManager;
@@ -143,6 +185,12 @@ export interface LocalRuntimeHostOptions {
 	requestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
+	/**
+	 * Default custom `fetch` implementation threaded into every
+	 * `ProviderConfig.fetch` built during local session bootstrap. Used by
+	 * the AI gateway providers when issuing HTTP requests.
+	 */
+	fetch?: typeof fetch;
 }
 
 export class LocalRuntimeHost implements RuntimeHost {
@@ -151,11 +199,11 @@ export class LocalRuntimeHost implements RuntimeHost {
 	private readonly runtimeBuilder: RuntimeBuilder;
 	private readonly createAgentInstance: (config: AgentConfig) => Agent;
 	private readonly defaultToolExecutors?: Partial<ToolExecutors>;
-	private readonly teamToolsFactory?: import("../runtime/session-runtime").TeamToolsFactory;
 	private readonly defaultToolPolicies?: AgentConfig["toolPolicies"];
 	private readonly providerSettingsManager: ProviderSettingsManager;
 	private readonly oauthTokenManager: RuntimeOAuthTokenManager;
 	private readonly defaultTelemetry?: ITelemetryService;
+	private readonly defaultFetch?: typeof fetch;
 	private readonly defaultRequestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
@@ -176,7 +224,6 @@ export class LocalRuntimeHost implements RuntimeHost {
 		this.createAgentInstance =
 			options.createAgent ?? ((config) => new Agent(config));
 		this.defaultToolExecutors = options.defaultToolExecutors;
-		this.teamToolsFactory = options.teamToolsFactory;
 		this.defaultToolPolicies = options.toolPolicies;
 		this.providerSettingsManager =
 			options.providerSettingsManager ?? new ProviderSettingsManager();
@@ -188,6 +235,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 			});
 		this.defaultTelemetry = options.telemetry;
 		this.defaultTelemetry?.setDistinctId(distinctId);
+		this.defaultFetch = options.fetch;
 		this.defaultRequestToolApproval = options.requestToolApproval;
 	}
 
@@ -198,21 +246,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 		const startedAt = nowIso();
 		const requestedSessionId = input.config.sessionId?.trim() ?? "";
 		const sessionId = requestedSessionId || createSessionId();
-		const resumedRow = requestedSessionId
-			? await this.getRow(sessionId)
-			: undefined;
-		const startInput: StartSessionInput =
-			resumedRow &&
-			!input.config.teamName?.trim() &&
-			resumedRow.teamName?.trim()
-				? {
-						...input,
-						config: {
-							...input.config,
-							teamName: resumedRow.teamName,
-						},
-					}
-				: input;
+		const startInput: StartSessionInput = input;
 		this.usageBySession.set(sessionId, createInitialAccumulatedUsage());
 
 		const sessionsDir =
@@ -250,6 +284,8 @@ export class LocalRuntimeHost implements RuntimeHost {
 			messages_path: messagesPath,
 		});
 
+		const sessionToolExecutors =
+			input.localRuntime?.defaultToolExecutors ?? this.defaultToolExecutors;
 		let bootstrap!: Awaited<ReturnType<typeof prepareLocalRuntimeBootstrap>>;
 		bootstrap = await prepareLocalRuntimeBootstrap({
 			input: startInput,
@@ -257,16 +293,17 @@ export class LocalRuntimeHost implements RuntimeHost {
 			sessionId,
 			providerSettingsManager: this.providerSettingsManager,
 			defaultTelemetry: this.defaultTelemetry,
-			defaultToolExecutors: this.defaultToolExecutors,
-			teamToolsFactory: this.teamToolsFactory,
+			defaultToolExecutors: sessionToolExecutors,
 			defaultToolPolicies: this.defaultToolPolicies,
 			defaultRequestToolApproval: this.defaultRequestToolApproval,
+			defaultFetch: this.defaultFetch,
 			onPluginEvent: (event) => void this.handlePluginEvent(sessionId, event),
 			onTeamEvent: (event: TeamEvent) => {
 				void this.handleTeamEvent(sessionId, event);
 				bootstrap.config.onTeamEvent?.(event);
 			},
-			createSpawnTool: () => this.createSpawnTool(bootstrap.config, sessionId),
+			createSpawnTool: () =>
+				this.createSpawnTool(bootstrap.config, sessionId, sessionToolExecutors),
 			readSessionMetadata: async () =>
 				(await this.get(sessionId))?.metadata as
 					| Record<string, unknown>
@@ -404,6 +441,18 @@ export class LocalRuntimeHost implements RuntimeHost {
 
 	async send(input: SendSessionInput): Promise<AgentResult | undefined> {
 		const session = this.getSessionOrThrow(input.sessionId);
+		const canStartRun =
+			typeof (session.agent as Agent & { canStartRun?: () => boolean })
+				.canStartRun === "function"
+				? (
+						session.agent as Agent & {
+							canStartRun: () => boolean;
+						}
+					).canStartRun()
+				: true;
+		const delivery =
+			input.delivery ??
+			(session.interactive && !canStartRun ? ("queue" as const) : undefined);
 		session.config.telemetry?.capture({
 			event: "session.input_sent",
 			properties: {
@@ -411,13 +460,13 @@ export class LocalRuntimeHost implements RuntimeHost {
 				promptLength: input.prompt.length,
 				userImageCount: input.userImages?.length ?? 0,
 				userFileCount: input.userFiles?.length ?? 0,
-				delivery: input.delivery ?? "immediate",
+				delivery: delivery ?? "immediate",
 			},
 		});
-		if (input.delivery === "queue" || input.delivery === "steer") {
+		if (delivery === "queue" || delivery === "steer") {
 			this.enqueuePendingPrompt(input.sessionId, {
 				prompt: input.prompt,
-				delivery: input.delivery,
+				delivery,
 				userImages: input.userImages,
 				userFiles: input.userFiles,
 			});
@@ -506,13 +555,25 @@ export class LocalRuntimeHost implements RuntimeHost {
 	}
 
 	async get(sessionId: string): Promise<SessionRecord | undefined> {
+		const active = this.sessions.get(sessionId);
+		if (active) {
+			return toActiveSessionRecord(active);
+		}
 		const row = await this.getRow(sessionId);
 		return row ? toSessionRecord(row) : undefined;
 	}
 
 	async list(limit = 200): Promise<SessionRecord[]> {
 		const rows = await this.listRows(limit);
-		return rows.map(toSessionRecord);
+		const persisted = rows.map(toSessionRecord);
+		const seen = new Set(persisted.map((row) => row.sessionId));
+		for (const active of this.sessions.values()) {
+			if (seen.has(active.sessionId)) {
+				continue;
+			}
+			persisted.unshift(toActiveSessionRecord(active));
+		}
+		return persisted.slice(0, limit);
 	}
 
 	async delete(sessionId: string): Promise<boolean> {
@@ -570,8 +631,11 @@ export class LocalRuntimeHost implements RuntimeHost {
 		});
 	}
 
-	subscribe(listener: (event: CoreSessionEvent) => void): () => void {
-		return this.events.subscribe(listener);
+	subscribe(
+		listener: (event: CoreSessionEvent) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void {
+		return this.events.subscribe(listener, options);
 	}
 
 	async updateSessionModel(sessionId: string, modelId: string): Promise<void> {
@@ -844,12 +908,39 @@ export class LocalRuntimeHost implements RuntimeHost {
 		}
 		notifyTeamRunWaiters(session);
 
+		const cleanupErrors: unknown[] = [];
+		const recordCleanupError = (stage: string, error: unknown) => {
+			cleanupErrors.push(error);
+			session.config.logger?.log("Session shutdown cleanup failed", {
+				sessionId: session.sessionId,
+				stage,
+				error,
+				severity: "warn",
+			});
+		};
+
 		if (session.artifacts) {
-			await this.updateStatus(session, input.status, input.exitCode);
-			await session.agent.shutdown(input.shutdownReason);
+			try {
+				await this.updateStatus(session, input.status, input.exitCode);
+			} catch (error) {
+				recordCleanupError("update_status", error);
+			}
+			try {
+				await session.agent.shutdown(input.shutdownReason);
+			} catch (error) {
+				recordCleanupError("agent_shutdown", error);
+			}
+		}
+		try {
+			await Promise.resolve(session.runtime.shutdown(input.shutdownReason));
+		} catch (error) {
+			recordCleanupError("runtime_shutdown", error);
+		}
+		try {
+			await session.pluginSandboxShutdown?.();
+		} catch (error) {
+			recordCleanupError("plugin_sandbox_shutdown", error);
 		}
-		await Promise.resolve(session.runtime.shutdown(input.shutdownReason));
-		await session.pluginSandboxShutdown?.();
 		this.sessions.delete(session.sessionId);
 		this.emit({
 			type: "ended",
@@ -859,6 +950,9 @@ export class LocalRuntimeHost implements RuntimeHost {
 				ts: Date.now(),
 			},
 		});
+		if (cleanupErrors.length > 0 && input.status === "failed") {
+			throw cleanupErrors[0];
+		}
 	}
 
 	private async updateStatus(
@@ -1142,6 +1236,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 	private createSpawnTool(
 		config: CoreSessionConfig,
 		rootSessionId: string,
+		toolExecutors?: Partial<ToolExecutors>,
 	): Tool {
 		const createSubAgentTools = () => {
 			const tools: Tool[] = config.enableTools
@@ -1152,13 +1247,13 @@ export class LocalRuntimeHost implements RuntimeHost {
 								mode: config.mode,
 							})
 						],
-						executors: this.defaultToolExecutors,
+						executors: toolExecutors,
 					})
 				: [];
 			if (config.enableSpawnAgent) {
-				tools.push(this.createSpawnTool(config, rootSessionId));
+				tools.push(this.createSpawnTool(config, rootSessionId, toolExecutors));
 			}
-			return tools;
+			return filterDisabledTools(tools);
 		};
 
 		return createSpawnAgentTool({

package/src/transports/remote.ts

@@ -0,0 +1,26 @@
+import { normalizeHubWebSocketUrl } from "../hub/client";
+import { HubRuntimeHost, type HubRuntimeHostOptions } from "./hub";
+
+export interface RemoteRuntimeHostOptions
+	extends Omit<HubRuntimeHostOptions, "url"> {
+	endpoint: string;
+	workspaceRoot?: string;
+	cwd?: string;
+}
+
+export class RemoteRuntimeHost extends HubRuntimeHost {
+	constructor(options: RemoteRuntimeHostOptions) {
+		super(
+			{
+				url: normalizeHubWebSocketUrl(options.endpoint),
+				authToken: options.authToken,
+				clientType: options.clientType ?? "core-remote-runtime",
+				displayName: options.displayName ?? "core remote runtime",
+			},
+			{
+				workspaceRoot: options.workspaceRoot,
+				cwd: options.cwd,
+			},
+		);
+	}
+}

package/src/transports/runtime-host-support.ts

@@ -1,23 +1,41 @@
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import type * as LlmsProviders from "@clinebot/llms";
+import { formatDisplayUserInput } from "@clinebot/shared";
 import type { HookEventPayload } from "../hooks";
-import type { SessionAccumulatedUsage } from "../runtime/runtime-host";
+import type {
+	RuntimeHostSubscribeOptions,
+	SessionAccumulatedUsage,
+} from "../runtime/runtime-host";
 import type { CoreSessionEvent } from "../types/events";
 
 export class RuntimeHostEventBus {
-	private readonly listeners = new Set<(event: CoreSessionEvent) => void>();
+	private readonly listeners = new Set<{
+		listener: (event: CoreSessionEvent) => void;
+		sessionId?: string;
+	}>();
 
-	subscribe(listener: (event: CoreSessionEvent) => void): () => void {
-		this.listeners.add(listener);
+	subscribe(
+		listener: (event: CoreSessionEvent) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void {
+		const entry = {
+			listener,
+			sessionId: options?.sessionId?.trim() || undefined,
+		};
+		this.listeners.add(entry);
 		return () => {
-			this.listeners.delete(listener);
+			this.listeners.delete(entry);
 		};
 	}
 
 	emit(event: CoreSessionEvent): void {
-		for (const listener of this.listeners) {
-			listener(event);
+		const sessionId = event.payload.sessionId?.trim();
+		for (const entry of this.listeners) {
+			if (entry.sessionId && entry.sessionId !== sessionId) {
+				continue;
+			}
+			entry.listener(event);
 		}
 	}
 
@@ -35,10 +53,14 @@ export async function readPersistedMessagesFile(
 		const raw = (await readFile(path, "utf8")).trim();
 		if (!raw) return [];
 		const parsed = JSON.parse(raw) as unknown;
-		if (Array.isArray(parsed)) return parsed as LlmsProviders.Message[];
+		if (Array.isArray(parsed)) {
+			return sanitizeDisplayMessages(parsed as LlmsProviders.Message[]);
+		}
 		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
 			const messages = (parsed as { messages?: unknown }).messages;
-			if (Array.isArray(messages)) return messages as LlmsProviders.Message[];
+			if (Array.isArray(messages)) {
+				return sanitizeDisplayMessages(messages as LlmsProviders.Message[]);
+			}
 		}
 		return [];
 	} catch {
@@ -46,6 +68,38 @@ export async function readPersistedMessagesFile(
 	}
 }
 
+function sanitizeDisplayMessage(
+	message: LlmsProviders.Message,
+): LlmsProviders.Message {
+	if (message.role !== "user") {
+		return message;
+	}
+	if (typeof message.content === "string") {
+		return {
+			...message,
+			content: formatDisplayUserInput(message.content),
+		};
+	}
+	return {
+		...message,
+		content: message.content.map((part) => {
+			if (part.type !== "text" || typeof part.text !== "string") {
+				return part;
+			}
+			return {
+				...part,
+				text: formatDisplayUserInput(part.text),
+			};
+		}),
+	};
+}
+
+export function sanitizeDisplayMessages(
+	messages: LlmsProviders.Message[],
+): LlmsProviders.Message[] {
+	return messages.map(sanitizeDisplayMessage);
+}
+
 export function cloneAccumulatedUsage(
 	usage: SessionAccumulatedUsage | undefined,
 ): SessionAccumulatedUsage | undefined {

package/src/types/chat-schema.ts

@@ -11,12 +11,11 @@ export const ChatSessionConfigSchema = z.object({
 	rules: z.string().optional(),
 	maxIterations: z.number().int().positive().optional(),
 	enableTools: z.boolean(),
-	enableSpawn: z.boolean(),
-	enableTeams: z.boolean(),
+	enableSpawn: z.boolean().optional(),
+	enableTeams: z.boolean().optional(),
 	autoApproveTools: z.boolean().optional(),
-	teamName: z.string().min(1),
-	missionStepInterval: z.number().int().positive(),
-	missionTimeIntervalMs: z.number().int().positive(),
+	missionStepInterval: z.number().int().positive().optional(),
+	missionTimeIntervalMs: z.number().int().positive().optional(),
 });
 
 export const ChatSessionStatusSchema = z.enum([

package/src/types/config.ts

@@ -1,4 +1,4 @@
-import type * as LlmsProviders from "@clinebot/llms";
+import type { ModelInfo } from "@clinebot/llms";
 import type {
 	AgentConfig,
 	AgentHooks,
@@ -17,6 +17,7 @@ import type {
 } from "@clinebot/shared";
 import type { ToolRoutingRule } from "../extensions/tools/model-tool-routing";
 import type { TeamEvent } from "../extensions/tools/team";
+import type { ProviderConfig } from "./provider-settings";
 
 export type CoreAgentMode = AgentMode;
 
@@ -26,8 +27,8 @@ export interface CoreModelConfig {
 	apiKey?: string;
 	baseUrl?: string;
 	headers?: Record<string, string>;
-	providerConfig?: LlmsProviders.ProviderConfig;
-	knownModels?: Record<string, LlmsProviders.ModelInfo>;
+	providerConfig?: ProviderConfig;
+	knownModels?: Record<string, ModelInfo>;
 	/**
 	 * Request model-side thinking/reasoning when supported.
 	 */
@@ -35,7 +36,7 @@ export interface CoreModelConfig {
 	/**
 	 * Explicit reasoning effort override for capable models.
 	 */
-	reasoningEffort?: LlmsProviders.ProviderConfig["reasoningEffort"];
+	reasoningEffort?: ProviderConfig["reasoningEffort"];
 }
 
 export interface CoreRuntimeFeatures {
@@ -55,7 +56,7 @@ export interface CoreCompactionContext {
 	model: {
 		id: string;
 		provider: string;
-		info?: LlmsProviders.ModelInfo;
+		info?: ModelInfo;
 	};
 	contextWindowTokens: number;
 	triggerTokens: number;
@@ -73,8 +74,8 @@ export interface CoreCompactionSummarizerConfig {
 	apiKey?: string;
 	baseUrl?: string;
 	headers?: Record<string, string>;
-	knownModels?: Record<string, LlmsProviders.ModelInfo>;
-	providerConfig?: LlmsProviders.ProviderConfig;
+	knownModels?: Record<string, ModelInfo>;
+	providerConfig?: ProviderConfig;
 	maxOutputTokens?: number;
 }
 

package/src/types/provider-settings.ts

@@ -1,11 +1,15 @@
-import * as LlmsProviders from "@clinebot/llms";
 import { z } from "zod";
+import {
+	type ProviderConfig,
+	type ProviderSettings,
+	ProviderSettingsSchema,
+	toProviderConfig,
+} from "../llms/provider-settings";
 
-export type ProviderConfig = LlmsProviders.ProviderConfig;
-export type ProviderSettings = LlmsProviders.ProviderSettings;
-export const ProviderSettingsSchema: z.ZodType<ProviderSettings> =
-	LlmsProviders.ProviderSettingsSchema;
-export const toProviderConfig = LlmsProviders.toProviderConfig;
+export type { ProviderConfig, ProviderSettings };
+export const ProviderSettingsSchemaTyped: z.ZodType<ProviderSettings> =
+	ProviderSettingsSchema;
+export { toProviderConfig };
 
 export type ProviderTokenSource = "manual" | "oauth" | "migration";
 
@@ -23,7 +27,7 @@ export interface StoredProviderSettings {
 
 export const StoredProviderSettingsEntrySchema: z.ZodType<StoredProviderSettingsEntry> =
 	z.object({
-		settings: LlmsProviders.ProviderSettingsSchema,
+		settings: ProviderSettingsSchema,
 		updatedAt: z.string().datetime(),
 		tokenSource: z.enum(["manual", "oauth", "migration"]).default("manual"),
 	});

package/src/types/session.ts

@@ -2,10 +2,8 @@ import type { Agent } from "@clinebot/agents";
 import type * as LlmsProviders from "@clinebot/llms";
 import type { SessionAccumulatedUsage } from "../runtime/runtime-host";
 import type { BuiltRuntime } from "../runtime/session-runtime";
-import type {
-	RootSessionArtifacts,
-	SessionRow,
-} from "../session/session-service";
+import type { SessionRow } from "../session/session-row";
+import type { RootSessionArtifacts } from "../session/session-service";
 import type { SessionSource, SessionStatus } from "./common";
 import type { CoreSessionConfig } from "./config";
 

package/src/types.ts

@@ -3,7 +3,8 @@ export {
 	ClineCore,
 	type ClineCoreOptions,
 	type ClineCoreStartInput,
-	type RpcOptions,
+	type HubOptions,
+	type RemoteOptions,
 } from "./ClineCore";
 export type {
 	LoadAgentPluginFromPathOptions,
@@ -66,6 +67,18 @@ export {
 	UnifiedConfigFileWatcher,
 	WORKFLOWS_CONFIG_DIRECTORY_NAME,
 } from "./extensions/config";
+export type {
+	BuiltinToolAvailabilityContext,
+	ToolCatalogEntry,
+} from "./extensions/tools";
+export {
+	getCoreAcpToolNames,
+	getCoreBuiltinToolCatalog,
+	getCoreDefaultEnabledToolIds,
+	getCoreHeadlessToolNames,
+	resolveCoreSelectedToolIds,
+	TEAM_TOOL_NAMES,
+} from "./extensions/tools";
 export type { SessionBackend } from "./runtime/host";
 export type {
 	RuntimeHost,
@@ -87,7 +100,20 @@ export type {
 	SubprocessSandboxOptions,
 } from "./runtime/subprocess-sandbox";
 export { SubprocessSandbox } from "./runtime/subprocess-sandbox";
+export type { GlobalSettings } from "./services/global-settings";
+export {
+	filterDisabledTools,
+	filterExtensionToolRegistrations,
+	isToolDisabledGlobally,
+	readGlobalSettings,
+	resolveDisabledToolNames,
+	toggleDisabledTool,
+	writeGlobalSettings,
+} from "./services/global-settings";
+export type { PluginToolSummary } from "./services/plugin-tools";
+export { listPluginTools } from "./services/plugin-tools";
 export type { SessionManifest } from "./session/session-manifest";
+export type { SessionRow } from "./session/session-row";
 export type {
 	CreateRootSessionWithArtifactsInput,
 	RootSessionArtifacts,