@clinebot/core 0.0.35 → 0.0.36

package/src/runtime/runtime-host.ts

@@ -4,42 +4,54 @@ import type {
 	ToolApprovalRequest,
 	ToolApprovalResult,
 } from "@clinebot/shared";
+import type { ToolExecutors } from "../extensions/tools";
 import type { HookEventPayload } from "../hooks";
+import type { ProviderSettings } from "../llms/provider-settings";
 import type { SessionManifest } from "../session/session-manifest";
 import type { SessionSource } from "../types/common";
 import type { CoreSessionConfig } from "../types/config";
 import type { CoreSessionEvent } from "../types/events";
 import type { SessionRecord } from "../types/sessions";
 
-export interface RuntimeSessionConfig {
-	sessionId?: string;
-	providerId: string;
-	modelId: string;
-	apiKey?: string;
-	cwd: string;
-	workspaceRoot?: string;
-	systemPrompt: string;
-	mode: CoreSessionConfig["mode"];
-	rules?: CoreSessionConfig["rules"];
-	maxIterations?: CoreSessionConfig["maxIterations"];
-	enableTools: boolean;
-	enableSpawnAgent: boolean;
-	enableAgentTeams: boolean;
-	disableMcpSettingsTools?: boolean;
-	teamName?: string;
-	missionLogIntervalSteps?: number;
-	missionLogIntervalMs?: number;
-}
+type LocalOnlyCoreSessionConfigKeys =
+	| "hooks"
+	| "logger"
+	| "telemetry"
+	| "extraTools"
+	| "extensions"
+	| "onTeamEvent"
+	| "onConsecutiveMistakeLimitReached";
+
+export type RuntimeSessionConfig = Omit<
+	CoreSessionConfig,
+	LocalOnlyCoreSessionConfigKeys | "checkpoint" | "compaction"
+> & {
+	checkpoint?: Omit<
+		NonNullable<CoreSessionConfig["checkpoint"]>,
+		"createCheckpoint"
+	>;
+	compaction?: Omit<NonNullable<CoreSessionConfig["compaction"]>, "compact">;
+};
 
-export type LocalRuntimeConfigOverrides = Omit<
+export type LocalRuntimeConfigOverrides = Pick<
 	CoreSessionConfig,
-	keyof RuntimeSessionConfig
->;
+	LocalOnlyCoreSessionConfigKeys
+> & {
+	checkpoint?: Pick<
+		NonNullable<CoreSessionConfig["checkpoint"]>,
+		"createCheckpoint"
+	> &
+		Partial<NonNullable<CoreSessionConfig["checkpoint"]>>;
+	compaction?: Pick<NonNullable<CoreSessionConfig["compaction"]>, "compact"> &
+		Partial<NonNullable<CoreSessionConfig["compaction"]>>;
+};
 
 export interface LocalRuntimeStartOptions {
 	configOverrides?: Partial<LocalRuntimeConfigOverrides>;
+	modelCatalogDefaults?: Partial<NonNullable<ProviderSettings["modelCatalog"]>>;
 	userInstructionWatcher?: import("../extensions/config").UserInstructionConfigWatcher;
 	onTeamRestored?: () => void;
+	defaultToolExecutors?: Partial<ToolExecutors>;
 }
 
 export interface StartSessionInput {
@@ -52,8 +64,9 @@ export interface StartSessionInput {
 	userImages?: string[];
 	userFiles?: string[];
 	/**
-	 * Local runtime bootstrap options. These are intentionally isolated under a
-	 * local-only bag so the transport-facing host contract stays transport-safe.
+	 * Host-local bootstrap options. These are intentionally isolated from the
+	 * transport-neutral runtime session config so all runtime hosts share the
+	 * same execution contract while still allowing host-specific preparation.
 	 */
 	localRuntime?: LocalRuntimeStartOptions;
 	toolPolicies?: import("@clinebot/shared").AgentConfig["toolPolicies"];
@@ -67,26 +80,36 @@ export function splitCoreSessionConfig(config: CoreSessionConfig): {
 	localRuntime?: LocalRuntimeStartOptions;
 } {
 	const {
-		sessionId,
-		providerId,
-		modelId,
-		apiKey,
-		cwd,
-		workspaceRoot,
-		systemPrompt,
-		mode,
-		rules,
-		maxIterations,
-		enableTools,
-		enableSpawnAgent,
-		enableAgentTeams,
-		disableMcpSettingsTools,
-		teamName,
-		missionLogIntervalSteps,
-		missionLogIntervalMs,
-		...localConfigOverrides
+		hooks,
+		logger,
+		telemetry,
+		extraTools,
+		extensions,
+		onTeamEvent,
+		onConsecutiveMistakeLimitReached,
+		checkpoint,
+		compaction,
+		...transportConfig
 	} = config;
 
+	const localConfigOverrides: Partial<LocalRuntimeConfigOverrides> = {};
+	if (hooks) localConfigOverrides.hooks = hooks;
+	if (logger) localConfigOverrides.logger = logger;
+	if (telemetry) localConfigOverrides.telemetry = telemetry;
+	if (extraTools) localConfigOverrides.extraTools = extraTools;
+	if (extensions) localConfigOverrides.extensions = extensions;
+	if (onTeamEvent) localConfigOverrides.onTeamEvent = onTeamEvent;
+	if (onConsecutiveMistakeLimitReached) {
+		localConfigOverrides.onConsecutiveMistakeLimitReached =
+			onConsecutiveMistakeLimitReached;
+	}
+	if (checkpoint?.createCheckpoint) {
+		localConfigOverrides.checkpoint = checkpoint;
+	}
+	if (compaction?.compact) {
+		localConfigOverrides.compaction = compaction;
+	}
+
 	const localRuntime =
 		Object.keys(localConfigOverrides).length > 0
 			? {
@@ -97,23 +120,21 @@ export function splitCoreSessionConfig(config: CoreSessionConfig): {
 
 	return {
 		config: {
-			...(sessionId ? { sessionId } : {}),
-			providerId,
-			modelId,
-			...(apiKey ? { apiKey } : {}),
-			cwd,
-			...(workspaceRoot ? { workspaceRoot } : {}),
-			systemPrompt,
-			mode,
-			rules,
-			maxIterations,
-			enableTools,
-			enableSpawnAgent,
-			enableAgentTeams,
-			disableMcpSettingsTools,
-			teamName,
-			missionLogIntervalSteps,
-			missionLogIntervalMs,
+			...transportConfig,
+			...(checkpoint ? { checkpoint: { enabled: checkpoint.enabled } } : {}),
+			...(compaction
+				? {
+						compaction: {
+							enabled: compaction.enabled,
+							strategy: compaction.strategy,
+							thresholdRatio: compaction.thresholdRatio,
+							reserveTokens: compaction.reserveTokens,
+							preserveRecentTokens: compaction.preserveRecentTokens,
+							contextWindowTokens: compaction.contextWindowTokens,
+							summarizer: compaction.summarizer,
+						},
+					}
+				: {}),
 		},
 		...(localRuntime ? { localRuntime } : {}),
 	};
@@ -143,6 +164,10 @@ export interface SessionAccumulatedUsage {
 	totalCost: number;
 }
 
+export interface RuntimeHostSubscribeOptions {
+	sessionId?: string;
+}
+
 /**
  * RuntimeHost is the transport/runtime boundary for core session execution.
  * Callers must normalize broad local config into `RuntimeSessionConfig`
@@ -171,8 +196,11 @@ export interface RuntimeHost {
 	): Promise<{ updated: boolean }>;
 	readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
 	handleHookEvent(payload: HookEventPayload): Promise<void>;
-	subscribe(listener: (event: CoreSessionEvent) => void): () => void;
+	subscribe(
+		listener: (event: CoreSessionEvent) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void;
 	updateSessionModel?(sessionId: string, modelId: string): Promise<void>;
 }
 
-export type RuntimeHostMode = "auto" | "rpc" | "local";
+export type RuntimeHostMode = "auto" | "local" | "hub" | "remote";

package/src/runtime/runtime-oauth-token-manager.ts

@@ -1,4 +1,3 @@
-import type * as LlmsProviders from "@clinebot/llms";
 import {
 	type ITelemetryService,
 	isOAuthProviderId,
@@ -12,6 +11,7 @@ import { getValidOpenAICodexCredentials } from "../auth/codex";
 import { getValidOcaCredentials } from "../auth/oca";
 import { decodeJwtPayload } from "../auth/utils";
 import { ProviderSettingsManager } from "../services/storage/provider-settings-manager";
+import type { ProviderSettings } from "../types/provider-settings";
 
 const DEFAULT_CLINE_API_BASE_URL = "https://api.cline.bot";
 const WORKOS_TOKEN_PREFIX = "workos:";
@@ -51,12 +51,12 @@ function readExpiryFromToken(accessToken: string): number | null {
 }
 
 function deriveCredentialExpiry(
-	settings: LlmsProviders.ProviderSettings,
+	settings: ProviderSettings,
 	normalizedAccessToken: string,
 ): number {
 	const explicitExpiry = (
 		settings.auth as
-			| (LlmsProviders.ProviderSettings["auth"] & { expiresAt?: number })
+			| (ProviderSettings["auth"] & { expiresAt?: number })
 			| undefined
 	)?.expiresAt;
 	if (
@@ -78,7 +78,7 @@ function deriveCredentialExpiry(
 
 function toCredentials(
 	providerId: ManagedOAuthProviderId,
-	settings: LlmsProviders.ProviderSettings,
+	settings: ProviderSettings,
 ): ClineOAuthCredentials | null {
 	const rawAccess = settings.auth?.accessToken?.trim();
 	const refreshToken = settings.auth?.refreshToken?.trim();
@@ -99,18 +99,14 @@ function toCredentials(
 }
 
 function authSettingsEqual(
-	a: LlmsProviders.ProviderSettings["auth"] | undefined,
-	b: LlmsProviders.ProviderSettings["auth"] | undefined,
+	a: ProviderSettings["auth"] | undefined,
+	b: ProviderSettings["auth"] | undefined,
 ): boolean {
 	const aExpiry = (
-		a as
-			| (LlmsProviders.ProviderSettings["auth"] & { expiresAt?: number })
-			| undefined
+		a as (ProviderSettings["auth"] & { expiresAt?: number }) | undefined
 	)?.expiresAt;
 	const bExpiry = (
-		b as
-			| (LlmsProviders.ProviderSettings["auth"] & { expiresAt?: number })
-			| undefined
+		b as (ProviderSettings["auth"] & { expiresAt?: number }) | undefined
 	)?.expiresAt;
 	return (
 		a?.accessToken === b?.accessToken &&
@@ -219,9 +215,9 @@ export class RuntimeOAuthTokenManager {
 			accessToken: persistedAccessToken,
 			refreshToken: nextCredentials.refresh,
 			accountId: nextCredentials.accountId,
-		} as LlmsProviders.ProviderSettings["auth"] & { expiresAt?: number };
+		} as ProviderSettings["auth"] & { expiresAt?: number };
 		nextAuth.expiresAt = nextCredentials.expires;
-		const nextSettings: LlmsProviders.ProviderSettings = {
+		const nextSettings: ProviderSettings = {
 			...settings,
 			auth: nextAuth,
 		};
@@ -243,7 +239,7 @@ export class RuntimeOAuthTokenManager {
 
 	private async resolveCredentials(
 		providerId: ManagedOAuthProviderId,
-		settings: LlmsProviders.ProviderSettings,
+		settings: ProviderSettings,
 		currentCredentials: ClineOAuthCredentials,
 		forceRefresh: boolean,
 	): Promise<ClineOAuthCredentials | null> {

package/src/runtime/session-runtime.ts

@@ -5,7 +5,6 @@ import type {
 	AgentResult,
 	BasicLogger,
 	ITelemetryService,
-	TeamTeammateSpec,
 	Tool,
 } from "@clinebot/shared";
 import type { UserInstructionConfigWatcher } from "../extensions/config";
@@ -30,28 +29,6 @@ export interface BuiltRuntime {
 	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;
@@ -63,7 +40,6 @@ export interface RuntimeBuilderInput {
 	defaultToolExecutors?: Partial<ToolExecutors>;
 	logger?: BasicLogger;
 	telemetry?: ITelemetryService;
-	teamToolsFactory?: TeamToolsFactory;
 }
 
 export interface RuntimeBuilder {

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,
+				),
+		};
+	});
+}

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

@@ -5,6 +5,7 @@ import type {
 	Tool,
 	ToolApprovalRequest,
 	ToolApprovalResult,
+	WorkspaceInfo,
 } from "@clinebot/shared";
 import { resolveAndLoadAgentPlugins } from "../extensions/plugin/plugin-config-loader";
 import type {
@@ -24,10 +25,7 @@ import type {
 	LocalRuntimeStartOptions,
 	StartSessionInput,
 } from "../runtime/runtime-host";
-import type {
-	RuntimeBuilderInput,
-	TeamToolsFactory,
-} from "../runtime/session-runtime";
+import type { RuntimeBuilderInput } from "../runtime/session-runtime";
 import type { CoreSessionConfig } from "../types/config";
 import {
 	type ProviderConfig,
@@ -35,9 +33,10 @@ import {
 	toProviderConfig,
 } from "../types/provider-settings";
 import { resolveWorkspacePath } from "./config";
+import { filterExtensionToolRegistrations } from "./global-settings";
 import { hasRuntimeHooks, mergeAgentExtensions } from "./session-data";
 import type { ProviderSettingsManager } from "./storage/provider-settings-manager";
-import { buildWorkspaceMetadata } from "./workspace-manifest";
+import { buildWorkspaceMetadataWithInfo } from "./workspace-manifest";
 
 function formatPluginFailure(failure: PluginInitializationFailure): string {
 	const label = failure.pluginName ?? failure.pluginPath;
@@ -93,8 +92,17 @@ function resolveReasoningSettings(
 function buildProviderConfig(
 	config: CoreSessionConfig,
 	providerSettingsManager: ProviderSettingsManager,
+	modelCatalogDefaults?: Partial<ProviderSettings["modelCatalog"]>,
+	defaultFetch?: typeof fetch,
 ): ProviderConfig {
 	const stored = providerSettingsManager.getProviderSettings(config.providerId);
+	const modelCatalog =
+		modelCatalogDefaults || stored?.modelCatalog
+			? {
+					...(modelCatalogDefaults ?? {}),
+					...(stored?.modelCatalog ?? {}),
+				}
+			: undefined;
 	const settings: ProviderSettings = {
 		...(stored ?? {}),
 		provider: config.providerId,
@@ -103,6 +111,7 @@ function buildProviderConfig(
 		baseUrl: config.baseUrl ?? stored?.baseUrl,
 		headers: config.headers ?? stored?.headers,
 		reasoning: resolveReasoningSettings(config, stored?.reasoning),
+		modelCatalog,
 	};
 	const providerConfig = toProviderConfig(settings);
 	if (config.knownModels) {
@@ -111,6 +120,13 @@ function buildProviderConfig(
 	if (config.extensionContext) {
 		providerConfig.extensionContext = config.extensionContext;
 	}
+	// Thread a host-provided custom fetch through to the AI gateway providers.
+	// Precedence: explicit per-session config > stored provider settings > host default.
+	const sessionFetch = (config as { fetch?: typeof fetch }).fetch;
+	const resolvedFetch = sessionFetch ?? providerConfig.fetch ?? defaultFetch;
+	if (resolvedFetch) {
+		providerConfig.fetch = resolvedFetch;
+	}
 	return providerConfig;
 }
 
@@ -121,11 +137,15 @@ export interface PrepareLocalRuntimeBootstrapOptions {
 	providerSettingsManager: ProviderSettingsManager;
 	defaultTelemetry?: ITelemetryService;
 	defaultToolExecutors?: Partial<ToolExecutors>;
-	teamToolsFactory?: TeamToolsFactory;
 	defaultToolPolicies?: AgentConfig["toolPolicies"];
 	defaultRequestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
+	/**
+	 * Host-level default `fetch` threaded into `ProviderConfig.fetch` so the
+	 * AI gateway providers can use a custom HTTP implementation.
+	 */
+	defaultFetch?: typeof fetch;
 	onPluginEvent: (event: { name: string; payload?: unknown }) => void;
 	onTeamEvent: (event: TeamEvent) => void;
 	createSpawnTool: () => Tool;
@@ -140,6 +160,8 @@ export interface LocalRuntimeBootstrap {
 	config: CoreSessionConfig;
 	providerConfig: ProviderConfig;
 	workspaceMetadata: string;
+	/** Structured git + path metadata generated alongside workspaceMetadata. */
+	workspaceInfo: WorkspaceInfo;
 	extensions: AgentConfig["extensions"];
 	hooks: AgentHooks | undefined;
 	toolPolicies: AgentConfig["toolPolicies"];
@@ -159,9 +181,9 @@ export async function prepareLocalRuntimeBootstrap(
 		providerSettingsManager,
 		defaultTelemetry,
 		defaultToolExecutors,
-		teamToolsFactory,
 		defaultToolPolicies,
 		defaultRequestToolApproval,
+		defaultFetch,
 		onPluginEvent,
 		onTeamEvent,
 		createSpawnTool,
@@ -173,18 +195,27 @@ export async function prepareLocalRuntimeBootstrap(
 	const configOverrides = localRuntime?.configOverrides as
 		| Partial<LocalRuntimeConfigOverrides>
 		| undefined;
+	const localConfig = configOverrides as Partial<CoreSessionConfig> | undefined;
+
+	// Generate workspace + git metadata once, early, so it can be forwarded to
+	// hooks and extensions. The serialized string goes into CoreSessionConfig
+	// as workspaceMetadata; the structured object is kept as workspaceInfo.
+	const { workspaceInfo, workspaceMetadata } =
+		await buildWorkspaceMetadataWithInfo(input.config.cwd);
 
 	const fileHooks = createHookConfigFileHooks({
 		cwd: input.config.cwd,
 		workspacePath,
 		rootSessionId: sessionId,
 		logger: configOverrides?.logger,
+		workspaceInfo,
 	});
 	const auditHooks = hasRuntimeHooks(configOverrides?.hooks)
 		? undefined
 		: createHookAuditHooks({
 				rootSessionId: sessionId,
 				workspacePath,
+				workspaceInfo,
 			});
 	const baseHooks = mergeAgentHooks([
 		configOverrides?.hooks,
@@ -197,10 +228,13 @@ export async function prepareLocalRuntimeBootstrap(
 		| undefined;
 	try {
 		loadedPlugins = await resolveAndLoadAgentPlugins({
-			pluginPaths: configOverrides?.pluginPaths,
+			pluginPaths: localConfig?.pluginPaths,
 			workspacePath,
 			cwd: input.config.cwd,
 			onEvent: onPluginEvent,
+			providerId: input.config.providerId,
+			modelId: input.config.modelId,
+			workspaceInfo,
 		});
 		logPluginDiagnostics(
 			loadedPlugins.failures,
@@ -216,9 +250,8 @@ export async function prepareLocalRuntimeBootstrap(
 
 	const extensions = mergeAgentExtensions(
 		configOverrides?.extensions,
-		loadedPlugins?.extensions,
+		filterExtensionToolRegistrations(loadedPlugins?.extensions),
 	);
-	const workspaceMetadata = await buildWorkspaceMetadata(input.config.cwd);
 	const baseConfig: CoreSessionConfig = {
 		...input.config,
 		...(configOverrides ?? {}),
@@ -229,6 +262,8 @@ export async function prepareLocalRuntimeBootstrap(
 	const providerConfig = buildProviderConfig(
 		baseConfig,
 		providerSettingsManager,
+		localRuntime?.modelCatalogDefaults,
+		defaultFetch,
 	);
 	const hooks = mergeAgentHooks([
 		baseConfig.hooks,
@@ -249,15 +284,19 @@ export async function prepareLocalRuntimeBootstrap(
 		workspaceMetadata,
 		hooks,
 	};
-	const toolPolicies = input.toolPolicies ?? defaultToolPolicies;
+	const toolPolicies =
+		input.toolPolicies ?? baseConfig.toolPolicies ?? defaultToolPolicies;
 	const requestToolApproval =
 		input.requestToolApproval ?? defaultRequestToolApproval;
+	const effectiveToolExecutors =
+		localRuntime?.defaultToolExecutors ?? defaultToolExecutors;
 
 	return {
 		effectiveInput: input,
 		config,
 		providerConfig,
 		workspaceMetadata,
+		workspaceInfo,
 		extensions,
 		hooks,
 		toolPolicies,
@@ -271,10 +310,9 @@ export async function prepareLocalRuntimeBootstrap(
 			createSpawnTool,
 			onTeamRestored: localRuntime?.onTeamRestored,
 			userInstructionWatcher: localRuntime?.userInstructionWatcher,
-			defaultToolExecutors,
+			defaultToolExecutors: effectiveToolExecutors,
 			logger: config.logger,
 			telemetry: config.telemetry,
-			teamToolsFactory,
 		},
 	};
 }