@clinebot/core 0.0.0 → 0.0.2

package/src/default-tools/model-tool-routing.ts

@@ -0,0 +1,132 @@
+import type { CoreAgentMode } from "../types/config";
+import type { DefaultToolName, DefaultToolsConfig } from "./types.js";
+
+export interface ToolRoutingRule {
+	/**
+	 * Optional rule label for debugging and logs.
+	 */
+	name?: string;
+	/**
+	 * Which mode the rule applies to.
+	 * @default "any"
+	 */
+	mode?: CoreAgentMode | "any";
+	/**
+	 * Case-insensitive substrings that must match the model ID.
+	 * When omitted/empty, the rule is not constrained by model ID.
+	 */
+	modelIdIncludes?: string[];
+	/**
+	 * Case-insensitive substrings that must match the provider ID.
+	 * When omitted/empty, the rule is not constrained by provider ID.
+	 */
+	providerIdIncludes?: string[];
+	/**
+	 * Enable these tools when the rule matches.
+	 */
+	enableTools?: DefaultToolName[];
+	/**
+	 * Disable these tools when the rule matches.
+	 */
+	disableTools?: DefaultToolName[];
+}
+
+const TOOL_NAME_TO_FLAG: Record<
+	DefaultToolName,
+	keyof Pick<
+		DefaultToolsConfig,
+		| "enableReadFiles"
+		| "enableSearch"
+		| "enableBash"
+		| "enableWebFetch"
+		| "enableApplyPatch"
+		| "enableEditor"
+		| "enableSkills"
+		| "enableAskQuestion"
+	>
+> = {
+	read_files: "enableReadFiles",
+	search_codebase: "enableSearch",
+	run_commands: "enableBash",
+	fetch_web_content: "enableWebFetch",
+	apply_patch: "enableApplyPatch",
+	editor: "enableEditor",
+	skills: "enableSkills",
+	ask_question: "enableAskQuestion",
+};
+
+export const DEFAULT_MODEL_TOOL_ROUTING_RULES: ToolRoutingRule[] = [
+	{
+		name: "openai-native-use-apply-patch",
+		mode: "act",
+		providerIdIncludes: ["openai-native"],
+		enableTools: ["apply_patch"],
+		disableTools: ["editor"],
+	},
+	{
+		name: "codex-and-gpt-use-apply-patch",
+		mode: "act",
+		modelIdIncludes: ["codex", "gpt"],
+		enableTools: ["apply_patch"],
+		disableTools: ["editor"],
+	},
+];
+
+function matchesModelId(
+	modelId: string,
+	includes: string[] | undefined,
+): boolean {
+	if (!includes || includes.length === 0) {
+		return true;
+	}
+	const normalizedModelId = modelId.toLowerCase();
+	return includes.some((value) =>
+		normalizedModelId.includes(value.toLowerCase()),
+	);
+}
+
+function matchesRule(
+	rule: ToolRoutingRule,
+	providerId: string,
+	modelId: string,
+	mode: CoreAgentMode,
+): boolean {
+	if (rule.mode && rule.mode !== "any" && rule.mode !== mode) {
+		return false;
+	}
+	return (
+		matchesModelId(providerId, rule.providerIdIncludes) &&
+		matchesModelId(modelId, rule.modelIdIncludes)
+	);
+}
+
+export function resolveToolRoutingConfig(
+	providerId: string,
+	modelId: string,
+	mode: CoreAgentMode,
+	rules: ToolRoutingRule[] | undefined,
+): Partial<DefaultToolsConfig> {
+	if (!rules || rules.length === 0) {
+		return {};
+	}
+
+	const toggles = new Map<DefaultToolName, boolean>();
+
+	for (const rule of rules) {
+		if (!matchesRule(rule, providerId, modelId, mode)) {
+			continue;
+		}
+		for (const toolName of rule.disableTools ?? []) {
+			toggles.set(toolName, false);
+		}
+		for (const toolName of rule.enableTools ?? []) {
+			toggles.set(toolName, true);
+		}
+	}
+
+	const config: Partial<DefaultToolsConfig> = {};
+	for (const [toolName, enabled] of toggles.entries()) {
+		config[TOOL_NAME_TO_FLAG[toolName]] = enabled;
+	}
+	return config;
+}

package/src/default-tools/schemas.ts

@@ -18,8 +18,16 @@ const AbsolutePath = z
  * Schema for read_files tool input
  */
 export const ReadFilesInputSchema = z.object({
-	file_paths: z.array(AbsolutePath).describe("Array of absolute file paths"),
+	file_paths: z
+		.array(AbsolutePath)
+		.describe(
+			"Array of absolute file paths to get full content from. Prefer this tool over running terminal command to get file content for better performance and reliability.",
+		),
 });
+
+/**
+ * Union schema for read_files tool input, allowing either a single string, an array of strings, or the full object schema
+ */
 export const ReadFilesInputUnionSchema = z.union([
 	ReadFilesInputSchema,
 	z.array(z.string()),
@@ -42,8 +50,12 @@ const CommandInputSchema = z.string();
 export const RunCommandsInputSchema = z.object({
 	commands: z
 		.array(CommandInputSchema)
-		.describe("Array of shell commands to execute"),
+		.describe("Array of shell commands to execute."),
 });
+
+/**
+ * Union schema for run_commands tool input. More flexible.
+ */
 export const RunCommandsInputUnionSchema = z.union([
 	RunCommandsInputSchema,
 	z.array(CommandInputSchema),
@@ -54,7 +66,7 @@ export const RunCommandsInputUnionSchema = z.union([
  * Schema for a single web fetch request
  */
 export const WebFetchRequestSchema = z.object({
-	url: z.url().describe("The URL to fetch"),
+	url: z.string().describe("The URL to fetch"),
 	prompt: z.string().min(2).describe("Analysis prompt for the fetched content"),
 });
 
@@ -64,7 +76,7 @@ export const WebFetchRequestSchema = z.object({
 export const FetchWebContentInputSchema = z.object({
 	requests: z
 		.array(WebFetchRequestSchema)
-		.describe("Array of web fetch requests"),
+		.describe("Array of the URLs for the web fetch requests"),
 });
 
 /**
@@ -74,62 +86,43 @@ export const EditFileInputSchema = z
 	.object({
 		command: z
 			.enum(["create", "str_replace", "insert"])
-			.describe(
-				"Editor command to execute: create, str_replace, insert, or undo_edit",
-			),
+			.describe("Editor command to execute: create, str_replace, insert"),
 		path: z.string().min(1).describe("Absolute file path"),
 		file_text: z
 			.string()
-			.optional()
-			.describe("Full file content used with create"),
+			.nullish()
+			.describe("Full file content required for 'create' command"),
 		old_str: z
 			.string()
-			.optional()
-			.describe("Exact text to replace (must match exactly once)"),
-		new_str: z.string().optional().describe("Replacement or inserted text"),
+			.nullish()
+			.describe(
+				"Exact text to replace (must match exactly once) for 'str_replace' command",
+			),
+		new_str: z
+			.string()
+			.nullish()
+			.describe("Replacement text for 'str_replace' or 'insert' commands"),
 		insert_line: z
 			.number()
 			.int()
-			.optional()
-			.describe("Zero-based line index for insert"),
+			.nullish()
+			.describe("Optional one-based line index for 'insert' command"),
 	})
-	.superRefine((value, ctx) => {
-		switch (value.command) {
-			case "create":
-				if (value.file_text === undefined) {
-					ctx.addIssue({
-						code: z.ZodIssueCode.custom,
-						path: ["file_text"],
-						message: "file_text is required for command=create",
-					});
-				}
-				break;
-			case "str_replace":
-				if (value.old_str === undefined) {
-					ctx.addIssue({
-						code: z.ZodIssueCode.custom,
-						path: ["old_str"],
-						message: "old_str is required for command=str_replace",
-					});
-				}
-				break;
-			case "insert":
-				if (value.insert_line === undefined) {
-					ctx.addIssue({
-						code: z.ZodIssueCode.custom,
-						path: ["insert_line"],
-						message: "insert_line is required for command=insert",
-					});
-				}
-				if (value.new_str === undefined) {
-					ctx.addIssue({
-						code: z.ZodIssueCode.custom,
-						path: ["new_str"],
-						message: "new_str is required for command=insert",
-					});
-				}
-				break;
-		}
+	.refine((v) => v.command !== "create" || v.file_text != null, {
+		path: ["file_text"],
+		message: "file_text is required for command=create",
+	})
+	.refine((v) => v.command !== "str_replace" || v.old_str != null, {
+		path: ["old_str"],
+		message: "old_str is required for command=str_replace",
+	})
+	.refine((v) => v.command !== "insert" || v.insert_line != null, {
+		path: ["insert_line"],
+		message: "insert_line is required for command=insert",
+	})
+	.refine((v) => v.command !== "insert" || v.new_str != null, {
+		path: ["new_str"],
+		message: "new_str is required for command=insert",
 	});
 
 /**
@@ -156,7 +149,11 @@ export const SkillsInputSchema = z.object({
 		.describe(
 			'The skill name. E.g., "commit", "review-pr", "pdf", or "ms-office-suite:pdf"',
 		),
-	args: z.string().optional().describe("Optional arguments for the skill"),
+	args: z
+		.string()
+		.nullable()
+		.optional()
+		.describe("Arguments for the skill; use null when omitted"),
 });
 
 /**

package/src/index.browser.ts

@@ -0,0 +1 @@
+export * from "./index";

package/src/index.node.ts

@@ -0,0 +1 @@
+export * from "./index";

package/src/index.ts

@@ -4,6 +4,47 @@
  * Runtime-agnostic core contracts and shared state utilities.
  */
 
+// Shared contracts and path helpers re-exported for app consumers.
+export type {
+	AgentMode,
+	BasicLogger,
+	ConnectorHookEvent,
+	HookSessionContext,
+	RpcAddProviderActionRequest,
+	RpcChatMessage,
+	RpcChatRunTurnRequest,
+	RpcChatRuntimeConfigBase,
+	RpcChatRuntimeLoggerConfig,
+	RpcChatStartSessionArtifacts,
+	RpcChatStartSessionRequest,
+	RpcChatTurnResult,
+	RpcClineAccountActionRequest,
+	RpcOAuthProviderId,
+	RpcProviderActionRequest,
+	RpcProviderCapability,
+	RpcProviderCatalogResponse,
+	RpcProviderListItem,
+	RpcProviderModel,
+	RpcProviderOAuthLoginResponse,
+	RpcSaveProviderSettingsActionRequest,
+	SessionLineage,
+	TeamProgressProjectionEvent,
+	ToolPolicy,
+} from "@clinebot/shared";
+export {
+	normalizeUserInput,
+	RPC_TEAM_LIFECYCLE_EVENT_TYPE,
+	RPC_TEAM_PROGRESS_EVENT_TYPE,
+	resolveHookLogPath,
+} from "@clinebot/shared";
+export {
+	ensureHookLogDir,
+	ensureParentDir,
+	resolveClineDataDir,
+	resolveSessionDataDir,
+	setHomeDir,
+	setHomeDirIfUnset,
+} from "@clinebot/shared/storage";
 export {
 	type ClineAccountBalance,
 	type ClineAccountOperations,
@@ -76,7 +117,6 @@ export {
 	resolveDefaultMcpSettingsPath,
 	resolveMcpServerRegistrations,
 } from "./mcp";
-
 export { ProviderSettingsManager } from "./storage/provider-settings-manager";
 export {
 	SqliteTeamStore,
@@ -86,7 +126,6 @@ export {
 	buildTeamProgressSummary,
 	toTeamProgressLifecycleEvent,
 } from "./team";
-
 // Compatibility barrel (legacy imports).
 export type { RuntimeEnvironment, SessionEvent, StoredMessages } from "./types";
 export type { SessionStatus } from "./types/common";

package/src/input/file-indexer.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 import { isMainThread, parentPort, Worker } from "node:worker_threads";
 
 const DEFAULT_INDEX_TTL_MS = 15_000;
+const WORKER_INDEX_REQUEST_TIMEOUT_MS = 1_000;
 const DEFAULT_EXCLUDE_DIRS = new Set([
 	".git",
 	"node_modules",
@@ -196,7 +197,21 @@ class FileIndexWorkerClient {
 	requestIndex(cwd: string): Promise<string[]> {
 		const requestId = ++this.nextRequestId;
 		const result = new Promise<string[]>((resolve, reject) => {
-			this.pending.set(requestId, { resolve, reject });
+			const timeout = setTimeout(() => {
+				this.pending.delete(requestId);
+				reject(new Error("Timed out waiting for file index worker response"));
+			}, WORKER_INDEX_REQUEST_TIMEOUT_MS);
+			timeout.unref();
+			this.pending.set(requestId, {
+				resolve: (files) => {
+					clearTimeout(timeout);
+					resolve(files);
+				},
+				reject: (reason) => {
+					clearTimeout(timeout);
+					reject(reason);
+				},
+			});
 		});
 
 		const message: IndexRequestMessage = {
@@ -218,9 +233,20 @@ class FileIndexWorkerClient {
 
 startWorkerServer();
 
-const workerClient = isMainThread ? new FileIndexWorkerClient() : null;
+let workerClient: FileIndexWorkerClient | null | undefined;
+
+function getWorkerClient(): FileIndexWorkerClient | null {
+	if (!isMainThread) {
+		return null;
+	}
+	if (workerClient === undefined) {
+		workerClient = new FileIndexWorkerClient();
+	}
+	return workerClient;
+}
 
 async function buildIndexInBackground(cwd: string): Promise<Set<string>> {
+	const workerClient = getWorkerClient();
 	if (!workerClient) {
 		return buildIndex(cwd);
 	}

package/src/runtime/runtime-builder.test.ts

@@ -74,6 +74,75 @@ describe("DefaultRuntimeBuilder", () => {
 		expect(names).not.toContain("editor");
 	});
 
+	it("uses apply_patch instead of editor for codex/gpt model IDs in act mode", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "openai",
+				modelId: "openai/gpt-5.4",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				mode: "act",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("apply_patch");
+		expect(names).not.toContain("editor");
+	});
+
+	it("keeps editor for non-codex/non-gpt model IDs in act mode", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				mode: "act",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("editor");
+		expect(names).not.toContain("apply_patch");
+	});
+
+	it("applies custom tool routing rules from session config", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				mode: "act",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+				toolRoutingRules: [
+					{
+						mode: "act",
+						providerIdIncludes: ["anthropic"],
+						modelIdIncludes: ["claude"],
+						enableTools: ["apply_patch"],
+						disableTools: ["editor"],
+					},
+				],
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("apply_patch");
+		expect(names).not.toContain("editor");
+	});
+
 	it("omits builtin tools when disabled", () => {
 		const runtime = new DefaultRuntimeBuilder().build({
 			config: {

package/src/runtime/runtime-builder.ts

@@ -16,9 +16,12 @@ import {
 } from "../agents";
 import {
 	createBuiltinTools,
+	DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	resolveToolRoutingConfig,
 	type SkillsExecutor,
 	type ToolExecutors,
 	ToolPresets,
+	type ToolRoutingRule,
 } from "../default-tools";
 import { SqliteTeamStore } from "../storage/sqlite-team-store";
 import type { CoreAgentMode, CoreSessionConfig } from "../types/config";
@@ -47,15 +50,26 @@ export function createTeamName(): string {
 
 function createBuiltinToolsList(
 	cwd: string,
+	providerId: string,
 	mode: CoreAgentMode,
+	modelId: string,
+	toolRoutingRules: ToolRoutingRule[] | undefined,
 	skillsExecutor?: SkillsExecutorWithMetadata,
 	executorOverrides?: Partial<ToolExecutors>,
 ): Tool[] {
 	const preset =
 		mode === "plan" ? ToolPresets.readonly : ToolPresets.development;
+	const toolRoutingConfig = resolveToolRoutingConfig(
+		providerId,
+		modelId,
+		mode,
+		toolRoutingRules ?? DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	);
+
 	return createBuiltinTools({
 		cwd,
 		...preset,
+		...toolRoutingConfig,
 		enableSkills: !!skillsExecutor,
 		executors: {
 			...(skillsExecutor
@@ -338,7 +352,10 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			tools.push(
 				...createBuiltinToolsList(
 					config.cwd,
+					config.providerId,
 					normalized.mode,
+					config.modelId,
+					config.toolRoutingRules,
 					skillsExecutor,
 					defaultToolExecutors,
 				),
@@ -416,7 +433,10 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 						? () =>
 								createBuiltinToolsList(
 									config.cwd,
+									config.providerId,
 									normalized.mode,
+									config.modelId,
+									config.toolRoutingRules,
 									skillsExecutor,
 									defaultToolExecutors,
 								)

package/src/runtime/runtime-parity.test.ts

@@ -45,6 +45,13 @@ function legacyBuildRuntimeEnvironment(
 	return tools;
 }
 
+function normalizeParityToolNames(toolNames: string[]): string[] {
+	// Skills are discovered from user/workspace config and can appear in tests
+	// depending on the machine state. They are intentionally excluded from
+	// strict legacy parity checks.
+	return toolNames.filter((toolName) => toolName !== "skills");
+}
+
 function makeEmptyWorkspaceCwd(): string {
 	return mkdtempSync(join(tmpdir(), "runtime-parity-"));
 }
@@ -71,8 +78,10 @@ describe("runtime tool parity", () => {
 			enableAgentTeams: false,
 		};
 		const createSpawnTool = makeSpawnTool;
-		const expected = legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
-			(tool) => tool.name,
+		const expected = normalizeParityToolNames(
+			legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
+				(tool) => tool.name,
+			),
 		);
 		const actual = new DefaultRuntimeBuilder()
 			.build({
@@ -81,7 +90,7 @@ describe("runtime tool parity", () => {
 			})
 			.tools.map((tool) => tool.name);
 
-		expect(actual).toEqual(expected);
+		expect(normalizeParityToolNames(actual)).toEqual(expected);
 	});
 
 	it("matches legacy tool list when only spawn is enabled", () => {
@@ -96,8 +105,10 @@ describe("runtime tool parity", () => {
 			enableAgentTeams: false,
 		};
 		const createSpawnTool = makeSpawnTool;
-		const expected = legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
-			(tool) => tool.name,
+		const expected = normalizeParityToolNames(
+			legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
+				(tool) => tool.name,
+			),
 		);
 		const actual = new DefaultRuntimeBuilder()
 			.build({
@@ -106,7 +117,7 @@ describe("runtime tool parity", () => {
 			})
 			.tools.map((tool) => tool.name);
 
-		expect(actual).toEqual(expected);
+		expect(normalizeParityToolNames(actual)).toEqual(expected);
 	});
 
 	it("matches legacy tool list when tools+spawn are disabled", () => {
@@ -120,13 +131,13 @@ describe("runtime tool parity", () => {
 			enableSpawnAgent: false,
 			enableAgentTeams: false,
 		};
-		const expected = legacyBuildRuntimeEnvironment(config).map(
-			(tool) => tool.name,
+		const expected = normalizeParityToolNames(
+			legacyBuildRuntimeEnvironment(config).map((tool) => tool.name),
 		);
 		const actual = new DefaultRuntimeBuilder()
 			.build({ config })
 			.tools.map((tool) => tool.name);
 
-		expect(actual).toEqual(expected);
+		expect(normalizeParityToolNames(actual)).toEqual(expected);
 	});
 });

package/src/server/index.ts

@@ -2,8 +2,42 @@
  * @clinebot/core/server
  *
  * Node/runtime services for host applications (CLI, desktop runtime, servers).
+ * Includes RPC server/client bindings — requires @clinebot/rpc at runtime.
  */
 
+export {
+	getRpcServerDefaultAddress,
+	getRpcServerHealth,
+	type RpcRuntimeBridgeCommand,
+	type RpcRuntimeBridgeCommandOutputLine,
+	type RpcRuntimeBridgeControlLine,
+	type RpcRuntimeBridgeOutputLine,
+	type RpcRuntimeBridgeRequestEnvelope,
+	type RpcRuntimeBridgeResponseEnvelope,
+	RpcRuntimeChatClient,
+	type RpcRuntimeEvent,
+	type RpcRuntimeHandlers,
+	type RpcRuntimeStreamStop,
+	type RpcScheduleExecution,
+	type RpcScheduleExecutionStatus,
+	type RpcScheduleMode,
+	type RpcScheduleRecord,
+	type RpcServerHandle,
+	type RpcServerOptions,
+	type RpcSessionBackend,
+	RpcSessionClient,
+	type RpcSessionRow,
+	type RpcSessionStatus,
+	type RpcSessionUpdateInput,
+	type RpcSpawnQueueItem,
+	type RpcStreamTeamProgressHandlers,
+	registerRpcClient,
+	requestRpcServerShutdown,
+	runRpcRuntimeCommandBridge,
+	runRpcRuntimeEventBridge,
+	startRpcServer,
+	stopRpcServer,
+} from "@clinebot/rpc";
 export {
 	type ClineAccountBalance,
 	type ClineAccountOperations,
@@ -229,11 +263,16 @@ export {
 } from "../session/session-graph";
 export type {
 	CreateSessionHostOptions,
+	SessionBackend,
 	SessionHost,
 } from "../session/session-host";
-export { createSessionHost } from "../session/session-host";
+export {
+	createSessionHost,
+	resolveSessionBackend,
+} from "../session/session-host";
 export type {
 	SendSessionInput,
+	SessionAccumulatedUsage,
 	SessionManager,
 	StartSessionInput,
 	StartSessionResult,