@clinebot/core 0.0.0 → 0.0.2

package/dist/session/default-session-manager.d.ts

@@ -7,7 +7,7 @@ import type { CoreSessionEvent } from "../types/events";
 import type { SessionRecord } from "../types/sessions";
 import type { RpcCoreSessionService } from "./rpc-session-service";
 import { RuntimeOAuthTokenManager } from "./runtime-oauth-token-manager";
-import type { SendSessionInput, SessionManager, StartSessionInput, StartSessionResult } from "./session-manager";
+import type { SendSessionInput, SessionAccumulatedUsage, SessionManager, StartSessionInput, StartSessionResult } from "./session-manager";
 import type { CoreSessionService } from "./session-service";
 type SessionBackend = CoreSessionService | RpcCoreSessionService;
 export interface DefaultSessionManagerOptions {
@@ -32,11 +32,13 @@ export declare class DefaultSessionManager implements SessionManager {
     private readonly defaultRequestToolApproval?;
     private readonly listeners;
     private readonly sessions;
+    private readonly usageBySession;
     constructor(options: DefaultSessionManagerOptions);
     private resolveStoredProviderSettings;
     private buildResolvedProviderConfig;
     start(input: StartSessionInput): Promise<StartSessionResult>;
     send(input: SendSessionInput): Promise<AgentResult | undefined>;
+    getAccumulatedUsage(sessionId: string): Promise<SessionAccumulatedUsage | undefined>;
     abort(sessionId: string): Promise<void>;
     stop(sessionId: string): Promise<void>;
     dispose(reason?: string): Promise<void>;

package/dist/session/session-host.d.ts

@@ -3,7 +3,7 @@ import type { ToolExecutors } from "../default-tools";
 import { RpcCoreSessionService } from "./rpc-session-service";
 import type { SessionManager } from "./session-manager";
 import { CoreSessionService } from "./session-service";
-type SessionBackend = RpcCoreSessionService | CoreSessionService;
+export type SessionBackend = RpcCoreSessionService | CoreSessionService;
 export interface CreateSessionHostOptions {
     distinctId?: string;
     sessionService?: SessionBackend;
@@ -17,5 +17,5 @@ export interface CreateSessionHostOptions {
     requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult>;
 }
 export type SessionHost = SessionManager;
+export declare function resolveSessionBackend(options: CreateSessionHostOptions): Promise<SessionBackend>;
 export declare function createSessionHost(options: CreateSessionHostOptions): Promise<SessionHost>;
-export {};

package/dist/session/session-manager.d.ts

@@ -34,9 +34,17 @@ export interface SendSessionInput {
     userImages?: string[];
     userFiles?: string[];
 }
+export interface SessionAccumulatedUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    totalCost: number;
+}
 export interface SessionManager {
     start(input: StartSessionInput): Promise<StartSessionResult>;
     send(input: SendSessionInput): Promise<AgentResult | undefined>;
+    getAccumulatedUsage(sessionId: string): Promise<SessionAccumulatedUsage | undefined>;
     abort(sessionId: string): Promise<void>;
     stop(sessionId: string): Promise<void>;
     dispose(reason?: string): Promise<void>;

package/dist/session/unified-session-persistence-service.d.ts

@@ -76,7 +76,7 @@ export declare class UnifiedSessionPersistenceService {
     upsertSubagentSessionFromHook(event: HookEventPayload): Promise<string | undefined>;
     appendSubagentHookAudit(subSessionId: string, event: HookEventPayload): Promise<void>;
     appendSubagentTranscriptLine(subSessionId: string, line: string): Promise<void>;
-    persistSessionMessages(sessionId: string, messages: LlmsProviders.Message[]): Promise<void>;
+    persistSessionMessages(sessionId: string, messages: LlmsProviders.Message[], systemPrompt?: string): Promise<void>;
     applySubagentStatus(subSessionId: string, event: HookEventPayload): Promise<void>;
     applySubagentStatusBySessionId(subSessionId: string, status: SessionStatus): Promise<void>;
     applyStatusToRunningChildSessions(parentSessionId: string, status: Exclude<SessionStatus, "running">): Promise<void>;

package/dist/session/utils/helpers.d.ts

@@ -0,0 +1,11 @@
+import type { AgentConfig, AgentEvent, AgentResult } from "@clinebot/agents";
+import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { SessionRecord } from "../../types/sessions";
+import type { SessionRowShape } from "../session-service";
+import type { StoredMessageWithMetadata } from "./types";
+export declare function extractWorkspaceMetadataFromSystemPrompt(systemPrompt: string): string | undefined;
+export declare function hasRuntimeHooks(hooks: AgentConfig["hooks"]): boolean;
+export declare function mergeAgentExtensions(explicitExtensions: AgentConfig["extensions"] | undefined, loadedExtensions: AgentConfig["extensions"] | undefined): AgentConfig["extensions"];
+export declare function serializeAgentEvent(event: AgentEvent): string;
+export declare function withLatestAssistantTurnMetadata(messages: LlmsProviders.Message[], result: AgentResult): StoredMessageWithMetadata[];
+export declare function toSessionRecord(row: SessionRowShape): SessionRecord;

package/dist/session/utils/types.d.ts

@@ -0,0 +1,42 @@
+import type { Agent } from "@clinebot/agents";
+import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { BuiltRuntime } from "../../runtime/session-runtime";
+import type { SessionSource } from "../../types/common";
+import type { CoreSessionConfig } from "../../types/config";
+import type { SessionAccumulatedUsage } from "../session-manager";
+import type { RootSessionArtifacts } from "../session-service";
+export type ActiveSession = {
+    sessionId: string;
+    config: CoreSessionConfig;
+    artifacts?: RootSessionArtifacts;
+    source: SessionSource;
+    startedAt: string;
+    pendingPrompt?: string;
+    runtime: BuiltRuntime;
+    agent: Agent;
+    started: boolean;
+    aborting: boolean;
+    interactive: boolean;
+    activeTeamRunIds: Set<string>;
+    pendingTeamRunUpdates: TeamRunUpdate[];
+    teamRunWaiters: Array<() => void>;
+    pluginSandboxShutdown?: () => Promise<void>;
+    turnUsageBaseline?: SessionAccumulatedUsage;
+};
+export type TeamRunUpdate = {
+    runId: string;
+    agentId: string;
+    taskId?: string;
+    status: "completed" | "failed" | "cancelled" | "interrupted";
+    error?: string;
+    iterations?: number;
+};
+export type StoredMessageWithMetadata = LlmsProviders.MessageWithMetadata & {
+    providerId?: string;
+    modelId?: string;
+};
+export type PreparedTurnInput = {
+    prompt: string;
+    userImages?: string[];
+    userFiles?: string[];
+};

package/dist/session/utils/usage.d.ts

@@ -0,0 +1,9 @@
+import type { SessionAccumulatedUsage } from "../session-manager";
+export declare function createInitialAccumulatedUsage(): SessionAccumulatedUsage;
+export declare function accumulateUsageTotals(baseline: SessionAccumulatedUsage, usage: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    totalCost?: number;
+}): SessionAccumulatedUsage;

package/dist/storage/provider-settings-manager.d.ts

@@ -1,6 +1,7 @@
 import { type ProviderConfig, type ProviderSettings, type ProviderTokenSource, type StoredProviderSettings } from "../types/provider-settings";
 export interface ProviderSettingsManagerOptions {
     filePath?: string;
+    dataDir?: string;
 }
 export interface SaveProviderSettingsOptions {
     setLastUsed?: boolean;
@@ -8,6 +9,7 @@ export interface SaveProviderSettingsOptions {
 }
 export declare class ProviderSettingsManager {
     private readonly filePath;
+    private readonly dataDir?;
     constructor(options?: ProviderSettingsManagerOptions);
     getFilePath(): string;
     read(): StoredProviderSettings;

package/dist/types/config.d.ts

@@ -1,6 +1,7 @@
-import type { AgentConfig, AgentHooks, HookErrorMode, TeamEvent, Tool } from "@clinebot/agents";
+import type { AgentConfig, AgentHooks, ConsecutiveMistakeLimitContext, ConsecutiveMistakeLimitDecision, HookErrorMode, TeamEvent, Tool } from "@clinebot/agents";
 import type { providers as LlmsProviders } from "@clinebot/llms";
 import type { AgentMode, BasicLogger, SessionExecutionConfig, SessionPromptConfig, SessionWorkspaceConfig } from "@clinebot/shared";
+import type { ToolRoutingRule } from "../default-tools/model-tool-routing.js";
 export type CoreAgentMode = AgentMode;
 export interface CoreModelConfig {
     providerId: string;
@@ -14,6 +15,10 @@ export interface CoreModelConfig {
      * Request model-side thinking/reasoning when supported.
      */
     thinking?: boolean;
+    /**
+     * Explicit reasoning effort override for capable models.
+     */
+    reasoningEffort?: LlmsProviders.ProviderConfig["reasoningEffort"];
 }
 export interface CoreRuntimeFeatures {
     enableTools: boolean;
@@ -34,4 +39,6 @@ export interface CoreSessionConfig extends CoreModelConfig, CoreRuntimeFeatures,
     pluginPaths?: string[];
     extensions?: AgentConfig["extensions"];
     onTeamEvent?: (event: TeamEvent) => void;
+    onConsecutiveMistakeLimitReached?: (context: ConsecutiveMistakeLimitContext) => Promise<ConsecutiveMistakeLimitDecision> | ConsecutiveMistakeLimitDecision;
+    toolRoutingRules?: ToolRoutingRule[];
 }

package/dist/types.d.ts

@@ -7,7 +7,7 @@ export type { SandboxCallOptions, SubprocessSandboxOptions, } from "./runtime/sa
 export { SubprocessSandbox } from "./runtime/sandbox/subprocess-sandbox";
 export type { BuiltRuntime as RuntimeEnvironment, RuntimeBuilder, RuntimeBuilderInput, SessionRuntime, } from "./runtime/session-runtime";
 export type { CreateSessionHostOptions, SessionHost, } from "./session/session-host";
-export type { SendSessionInput, SessionManager, StartSessionInput, StartSessionResult, } from "./session/session-manager";
+export type { SendSessionInput, SessionAccumulatedUsage, SessionManager, StartSessionInput, StartSessionResult, } from "./session/session-manager";
 export type { SessionManifest } from "./session/session-manifest";
 export type { CreateRootSessionWithArtifactsInput, RootSessionArtifacts, } from "./session/session-service";
 export type { WorkspaceManager, WorkspaceManagerEvent, } from "./session/workspace-manager";

package/package.json

@@ -1,45 +1,44 @@
 {
 	"name": "@clinebot/core",
-	"version": "0.0.0",
-	"main": "dist/index.js",
+	"version": "0.0.2",
+	"main": "dist/index.node.js",
 	"dependencies": {
-		"@clinebot/agents": "workspace:*",
-		"@clinebot/llms": "workspace:*",
-		"@clinebot/rpc": "workspace:*",
-		"@clinebot/shared": "workspace:*",
-		"nanoid": "^5.1.6",
+		"@clinebot/agents": "0.0.2",
+		"@clinebot/llms": "0.0.2",
+		"nanoid": "^5.1.7",
 		"simple-git": "^3.32.3",
 		"yaml": "^2.8.2",
 		"zod": "^4.3.6"
 	},
 	"exports": {
 		".": {
-			"development": "./src/index.ts",
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js"
+			"browser": "./dist/index.browser.js",
+			"development": "./dist/index.node.js",
+			"types": "./dist/index.node.d.ts",
+			"import": "./dist/index.node.js"
 		},
 		"./node": {
-			"development": "./src/index.ts",
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js"
+			"development": "./src/index.node.ts",
+			"types": "./dist/index.node.d.ts",
+			"import": "./dist/index.node.js"
 		},
 		"./browser": {
-			"development": "./src/index.ts",
+			"development": "./dist/index.browser.js",
 			"types": "./dist/index.browser.d.ts",
 			"import": "./dist/index.browser.js"
 		},
 		"./server": {
-			"development": "./src/server/index.ts",
+			"development": "./dist/server/index.js",
 			"types": "./dist/server/index.d.ts",
 			"import": "./dist/server/index.js"
 		},
 		"./server/node": {
-			"development": "./src/server/index.ts",
+			"development": "./dist/server/index.js",
 			"types": "./dist/server/index.d.ts",
 			"import": "./dist/server/index.js"
 		},
 		"./server/browser": {
-			"development": "./src/server/index.ts",
+			"development": "./dist/server/index.js",
 			"types": "./dist/server.browser.d.ts",
 			"import": "./dist/server.browser.js"
 		}
@@ -50,7 +49,7 @@
 		"src"
 	],
 	"scripts": {
-		"build": "bun run ./build.ts && bun tsc -p tsconfig.build.json",
+		"build": "bun run ./bun.mts && bun tsc -p tsconfig.build.json",
 		"clean": "rm -rf dist node_modules",
 		"typecheck": "bun tsc -p tsconfig.dev.json --noEmit",
 		"test": "bun run test:unit && bun run test:e2e",
@@ -59,5 +58,5 @@
 		"test:watch": "vitest --config vitest.config.ts"
 	},
 	"type": "module",
-	"types": "dist/index.d.ts"
-}
+	"types": "dist/index.node.d.ts"
+}

package/src/default-tools/definitions.test.ts

@@ -226,8 +226,137 @@ describe("zod schema conversion", () => {
 				description:
 					"The absolute file path of a text file to read content from",
 			},
-			description: "Array of absolute file paths",
+			description:
+				"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.",
 		});
 		expect(inputSchema.required).toEqual(["file_paths"]);
 	});
+
+	it("exposes skills args as optional nullable in tool schemas", () => {
+		const tools = createDefaultTools({
+			executors: {
+				skills: async () => "ok",
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableEditor: false,
+			enableApplyPatch: false,
+			enableAskQuestion: false,
+			enableSkills: true,
+		});
+		const skills = tools.find((tool) => tool.name === "skills");
+		expect(skills).toBeDefined();
+		if (!skills) {
+			throw new Error("Expected skills tool.");
+		}
+		const schema = skills.inputSchema as {
+			required?: string[];
+			properties?: Record<string, unknown>;
+		};
+		expect(schema.required).toEqual(["skill"]);
+		expect(schema.properties).toHaveProperty("args");
+	});
+});
+
+describe("default editor tool", () => {
+	it("accepts null for unused optional fields on str_replace", async () => {
+		const execute = vi.fn(async () => "patched");
+		const tools = createDefaultTools({
+			executors: {
+				editor: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableSkills: false,
+			enableAskQuestion: false,
+			enableApplyPatch: false,
+			enableEditor: true,
+		});
+		const editorTool = tools.find((tool) => tool.name === "editor");
+		expect(editorTool).toBeDefined();
+		if (!editorTool) {
+			throw new Error("Expected editor tool to be defined.");
+		}
+
+		const result = await editorTool.execute(
+			{
+				command: "str_replace",
+				path: "/tmp/example.ts",
+				old_str: "before",
+				new_str: "after",
+				file_text: null,
+				insert_line: null,
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual({
+			query: "str_replace:/tmp/example.ts",
+			result: "patched",
+			success: true,
+		});
+		expect(execute).toHaveBeenCalledWith(
+			expect.objectContaining({
+				command: "str_replace",
+				path: "/tmp/example.ts",
+				old_str: "before",
+				new_str: "after",
+				file_text: null,
+				insert_line: null,
+			}),
+			process.cwd(),
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+
+	it("still rejects null for required insert fields", async () => {
+		const execute = vi.fn(async () => "patched");
+		const tools = createDefaultTools({
+			executors: {
+				editor: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableSkills: false,
+			enableAskQuestion: false,
+			enableApplyPatch: false,
+			enableEditor: true,
+		});
+		const editorTool = tools.find((tool) => tool.name === "editor");
+		expect(editorTool).toBeDefined();
+		if (!editorTool) {
+			throw new Error("Expected editor tool to be defined.");
+		}
+
+		await expect(
+			editorTool.execute(
+				{
+					command: "insert",
+					path: "/tmp/example.ts",
+					new_str: "after",
+					insert_line: null,
+				},
+				{
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).rejects.toThrow(/insert_line is required for command=insert/);
+		expect(execute).not.toHaveBeenCalled();
+	});
 });

package/src/default-tools/definitions.ts

@@ -426,7 +426,7 @@ export function createEditorTool(
 		name: "editor",
 		description:
 			"Edit file using absolute path with create, string replacement, and line insert operations. " +
-			"Supported commands: create, str_replace, insert, undo_edit.",
+			"Supported commands: create, str_replace, insert.",
 		inputSchema: zodToJsonSchema(EditFileInputSchema),
 		timeoutMs,
 		retryable: false, // Editing operations are stateful and should not auto-retry
@@ -487,7 +487,11 @@ export function createSkillsTool(
 		execute: async (input, context) => {
 			const validatedInput = validateWithZod(SkillsInputSchema, input);
 			return withTimeout(
-				executor(validatedInput.skill, validatedInput.args, context),
+				executor(
+					validatedInput.skill,
+					validatedInput.args || undefined,
+					context,
+				),
 				timeoutMs,
 				`Skills operation timed out after ${timeoutMs}ms`,
 			);

package/src/default-tools/executors/editor.ts

@@ -116,7 +116,7 @@ async function createFile(
 async function replaceInFile(
 	filePath: string,
 	oldStr: string,
-	newStr: string | undefined,
+	newStr: string | null | undefined,
 	encoding: BufferEncoding,
 	maxDiffLines: number,
 ): Promise<string> {
@@ -142,23 +142,24 @@ async function replaceInFile(
 
 async function insertInFile(
 	filePath: string,
-	insertLine: number,
+	insertLineOneBased: number,
 	newStr: string,
 	encoding: BufferEncoding,
 ): Promise<string> {
 	const content = await fs.readFile(filePath, encoding);
 	const lines = content.split("\n");
+	const insertLine = insertLineOneBased - 1; // Convert to zero-based index
 
 	if (insertLine < 0 || insertLine > lines.length) {
 		throw new Error(
-			`Invalid line number: ${insertLine}. Valid range: 0-${lines.length}`,
+			`Invalid line number: ${insertLineOneBased}. Valid range: 1-${lines.length}`,
 		);
 	}
 
 	lines.splice(insertLine, 0, ...newStr.split("\n"));
 	await fs.writeFile(filePath, lines.join("\n"), { encoding });
 
-	return `Inserted content at line ${insertLine} in ${filePath}.`;
+	return `Inserted content at line ${insertLineOneBased} in ${filePath}.`;
 }
 
 /**
@@ -182,7 +183,7 @@ export function createEditorExecutor(
 
 		switch (input.command) {
 			case "create":
-				if (input.file_text === undefined) {
+				if (input.file_text == null) {
 					throw new Error(
 						"Parameter `file_text` is required for command: create",
 					);
@@ -190,7 +191,7 @@ export function createEditorExecutor(
 				return createFile(filePath, input.file_text, encoding);
 
 			case "str_replace":
-				if (input.old_str === undefined) {
+				if (input.old_str == null) {
 					throw new Error(
 						"Parameter `old_str` is required for command: str_replace",
 					);
@@ -204,19 +205,19 @@ export function createEditorExecutor(
 				);
 
 			case "insert":
-				if (input.insert_line === undefined) {
+				if (input.insert_line == null) {
 					throw new Error(
 						"Parameter `insert_line` is required for insert command.",
 					);
 				}
-				if (input.new_str === undefined) {
+				if (input.new_str == null) {
 					throw new Error(
 						"Parameter `new_str` is required for insert command.",
 					);
 				}
 				return insertInFile(
 					filePath,
-					input.insert_line,
+					input.insert_line, // One-based index
 					input.new_str,
 					encoding,
 				);

package/src/default-tools/executors/file-read.test.ts

@@ -17,7 +17,7 @@ describe("createFileReadExecutor", () => {
 				conversationId: "conv-1",
 				iteration: 1,
 			});
-			expect(result).toBe("hello absolute path");
+			expect(result).toBe("1 | hello absolute path");
 		} finally {
 			await fs.rm(dir, { recursive: true, force: true });
 		}

package/src/default-tools/executors/file-read.ts

@@ -32,6 +32,12 @@ export interface FileReadExecutorOptions {
 	includeLineNumbers?: boolean;
 }
 
+const DEFAULT_FILE_READ_OPTIONS: Required<FileReadExecutorOptions> = {
+	maxFileSizeBytes: 10_000_000, // 10MB default limit
+	encoding: "utf-8", // Default to UTF-8 encoding
+	includeLineNumbers: true, // Include line numbers by default
+};
+
 /**
  * Create a file read executor using Node.js fs module
  *
@@ -48,11 +54,10 @@ export interface FileReadExecutorOptions {
 export function createFileReadExecutor(
 	options: FileReadExecutorOptions = {},
 ): FileReadExecutor {
-	const {
-		maxFileSizeBytes = 10_000_000,
-		encoding = "utf-8",
-		includeLineNumbers = false,
-	} = options;
+	const { maxFileSizeBytes, encoding, includeLineNumbers } = {
+		...DEFAULT_FILE_READ_OPTIONS,
+		...options,
+	};
 
 	return async (filePath: string, _context: ToolContext): Promise<string> => {
 		const resolvedPath = path.isAbsolute(filePath)
@@ -77,7 +82,7 @@ export function createFileReadExecutor(
 		// Read file content
 		const content = await fs.readFile(resolvedPath, encoding);
 
-		// Optionally add line numbers
+		// Optionally add line numbers - one-based indexing for better readability
 		if (includeLineNumbers) {
 			const lines = content.split("\n");
 			const maxLineNumWidth = String(lines.length).length;

package/src/default-tools/index.ts

@@ -37,6 +37,11 @@ export {
 	type SearchExecutorOptions,
 	type WebFetchExecutorOptions,
 } from "./executors/index.js";
+export {
+	DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	resolveToolRoutingConfig,
+	type ToolRoutingRule,
+} from "./model-tool-routing.js";
 // Presets
 export {
 	createDefaultToolsWithPreset,

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

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import {
+	DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	resolveToolRoutingConfig,
+} from "./model-tool-routing.js";
+
+describe("model tool routing", () => {
+	it("applies default codex/gpt routing in act mode", () => {
+		const config = resolveToolRoutingConfig(
+			"openai",
+			"openai/gpt-5.4",
+			"act",
+			DEFAULT_MODEL_TOOL_ROUTING_RULES,
+		);
+
+		expect(config.enableApplyPatch).toBe(true);
+		expect(config.enableEditor).toBe(false);
+	});
+
+	it("does not apply default codex/gpt routing in plan mode", () => {
+		const config = resolveToolRoutingConfig(
+			"openai",
+			"openai/gpt-5.4",
+			"plan",
+			DEFAULT_MODEL_TOOL_ROUTING_RULES,
+		);
+
+		expect(config).toEqual({});
+	});
+
+	it("applies matching custom rules in order", () => {
+		const config = resolveToolRoutingConfig(
+			"anthropic",
+			"claude-sonnet-4-6",
+			"act",
+			[
+				{
+					name: "claude-editor-off",
+					mode: "act",
+					modelIdIncludes: ["claude"],
+					disableTools: ["editor"],
+				},
+				{
+					name: "claude-apply-patch-on",
+					mode: "act",
+					modelIdIncludes: ["claude"],
+					enableTools: ["apply_patch"],
+				},
+			],
+		);
+
+		expect(config.enableEditor).toBe(false);
+		expect(config.enableApplyPatch).toBe(true);
+	});
+
+	it("returns empty config when no rules match", () => {
+		const config = resolveToolRoutingConfig(
+			"anthropic",
+			"claude-sonnet-4-6",
+			"act",
+			[
+				{
+					mode: "act",
+					modelIdIncludes: ["gpt"],
+					enableTools: ["apply_patch"],
+				},
+			],
+		);
+
+		expect(config).toEqual({});
+	});
+
+	it("can match provider-only rules", () => {
+		const config = resolveToolRoutingConfig("openai", "o4-mini", "act", [
+			{
+				mode: "act",
+				providerIdIncludes: ["openai"],
+				enableTools: ["apply_patch"],
+				disableTools: ["editor"],
+			},
+		]);
+
+		expect(config.enableApplyPatch).toBe(true);
+		expect(config.enableEditor).toBe(false);
+	});
+});