test: improve test coverage from 85% to 93%

- Add comprehensive tests for StackOneError and StackOneAPIError
- Add tests for BaseTool RPC/local config and error handling
- Add tests for StackOneToolSet dryRun mode and parameter extraction
- Exclude type-only files from coverage (index.ts, type.ts)

Coverage improvements:
- Statements: 85.29% → 92.50%
- Branch: 70.61% → 84.05%
- Lines: 85.95% → 93.51%

Author: ryoppippi

src/feedback.test.ts

@@ -1,6 +1,6 @@
 import { http, HttpResponse } from 'msw';
 import { server } from '../mocks/node';
-import { StackOneError } from './utils/errors';
+import { StackOneError } from './utils/error-stackone';
 import { createFeedbackTool } from './feedback';
 
 interface FeedbackResultItem {

src/requestBuilder.test.ts

@@ -1,7 +1,7 @@
 import { http, HttpResponse } from 'msw';
 import { server } from '../mocks/node';
 import { type HttpExecuteConfig, type JsonObject, ParameterLocation } from './types';
-import { StackOneAPIError } from './utils/errors';
+import { StackOneAPIError } from './utils/error-stackone-api';
 import { RequestBuilder } from './requestBuilder';
 
 describe('RequestBuilder', () => {

src/rpc-client.test.ts

@@ -1,6 +1,6 @@
 import { RpcClient } from './rpc-client';
 import { stackOneHeadersSchema } from './headers';
-import { StackOneAPIError } from './utils/errors';
+import { StackOneAPIError } from './utils/error-stackone-api';
 
 test('should successfully execute an RPC action', async () => {
 	const client = new RpcClient({

src/tool.test.ts

@@ -33,7 +33,7 @@ import {
 	ParameterLocation,
 	type ToolParameters,
 } from './types';
-import { StackOneAPIError } from './utils/errors';
+import { StackOneAPIError } from './utils/error-stackone-api';
 
 // Create a mock tool for testing
 const createMockTool = (headers?: Record<string, string>): BaseTool => {
@@ -328,6 +328,157 @@ describe('StackOneTool', () => {
 	});
 });
 
+describe('BaseTool - additional coverage', () => {
+	it('should throw error when execute is called on non-HTTP tool', async () => {
+		const rpcTool = new BaseTool(
+			'rpc_tool',
+			'RPC tool',
+			{ type: 'object', properties: {} },
+			{
+				kind: 'rpc',
+				method: 'test_method',
+				url: 'https://api.example.com/rpc',
+				payloadKeys: { action: 'action', body: 'body' },
+			},
+		);
+
+		await expect(rpcTool.execute({})).rejects.toThrow(
+			'BaseTool.execute is only available for HTTP-backed tools',
+		);
+	});
+
+	it('should throw error for invalid parameter type', async () => {
+		const tool = createMockTool();
+
+		// @ts-expect-error - intentionally passing invalid type
+		await expect(tool.execute(12345)).rejects.toThrow('Invalid parameters type');
+	});
+
+	it('should create execution metadata for RPC config in toAISDK', async () => {
+		const rpcTool = new BaseTool(
+			'rpc_tool',
+			'RPC tool',
+			{ type: 'object', properties: {} },
+			{
+				kind: 'rpc',
+				method: 'test_method',
+				url: 'https://api.example.com/rpc',
+				payloadKeys: { action: 'action', body: 'body', headers: 'headers' },
+			},
+		);
+
+		const aiSdkTool = await rpcTool.toAISDK({ executable: false });
+		const execution = aiSdkTool.rpc_tool.execution;
+
+		expect(execution).toBeDefined();
+		expect(execution?.config.kind).toBe('rpc');
+		if (execution?.config.kind === 'rpc') {
+			expect(execution.config.method).toBe('test_method');
+			expect(execution.config.url).toBe('https://api.example.com/rpc');
+			expect(execution.config.payloadKeys).toEqual({
+				action: 'action',
+				body: 'body',
+				headers: 'headers',
+			});
+		}
+	});
+
+	it('should create execution metadata for local config in toAISDK', async () => {
+		const localTool = new BaseTool(
+			'local_tool',
+			'Local tool',
+			{ type: 'object', properties: {} },
+			{
+				kind: 'local',
+				identifier: 'local_test',
+				description: 'local://test',
+			},
+		);
+
+		const aiSdkTool = await localTool.toAISDK({ executable: false });
+		const execution = aiSdkTool.local_tool.execution;
+
+		expect(execution).toBeDefined();
+		expect(execution?.config.kind).toBe('local');
+		if (execution?.config.kind === 'local') {
+			expect(execution.config.identifier).toBe('local_test');
+			expect(execution.config.description).toBe('local://test');
+		}
+	});
+
+	it('should allow providing custom execution metadata in toAISDK', async () => {
+		const tool = createMockTool();
+		const customExecution = {
+			config: {
+				kind: 'http' as const,
+				method: 'POST' as const,
+				url: 'https://custom.example.com',
+				bodyType: 'json' as const,
+				params: [],
+			},
+			headers: { 'X-Custom': 'value' },
+		};
+
+		const aiSdkTool = await tool.toAISDK({ execution: customExecution });
+		const execution = aiSdkTool.test_tool.execution;
+
+		expect(execution).toBeDefined();
+		expect(execution?.config.kind).toBe('http');
+		if (execution?.config.kind === 'http') {
+			expect(execution.config.url).toBe('https://custom.example.com');
+		}
+		expect(execution?.headers).toEqual({ 'X-Custom': 'value' });
+	});
+
+	it('should return undefined execution when execution option is false', async () => {
+		const tool = createMockTool();
+
+		const aiSdkTool = await tool.toAISDK({ execution: false });
+		expect(aiSdkTool.test_tool.execution).toBeUndefined();
+	});
+
+	it('should return undefined execute when executable option is false', async () => {
+		const tool = createMockTool();
+
+		const aiSdkTool = await tool.toAISDK({ executable: false });
+		expect(aiSdkTool.test_tool.execute).toBeUndefined();
+	});
+
+	it('should get headers from tool without requestBuilder', () => {
+		const rpcTool = new BaseTool(
+			'rpc_tool',
+			'RPC tool',
+			{ type: 'object', properties: {} },
+			{
+				kind: 'rpc',
+				method: 'test_method',
+				url: 'https://api.example.com/rpc',
+				payloadKeys: { action: 'action', body: 'body' },
+			},
+			{ 'X-Custom': 'value' },
+		);
+
+		expect(rpcTool.getHeaders()).toEqual({ 'X-Custom': 'value' });
+	});
+
+	it('should set headers on tool without requestBuilder', () => {
+		const rpcTool = new BaseTool(
+			'rpc_tool',
+			'RPC tool',
+			{ type: 'object', properties: {} },
+			{
+				kind: 'rpc',
+				method: 'test_method',
+				url: 'https://api.example.com/rpc',
+				payloadKeys: { action: 'action', body: 'body' },
+			},
+		);
+
+		rpcTool.setHeaders({ 'X-New-Header': 'new-value' });
+		expect(rpcTool.getHeaders()).toEqual({ 'X-New-Header': 'new-value' });
+	});
+});
+
 describe('Tools', () => {
 	it('should get tool by name', () => {
 		const tool = createMockTool();
@@ -952,6 +1103,40 @@ describe('Meta Search Tools', () => {
 		});
 	});
 
+	describe('Error handling', () => {
+		it('should wrap non-StackOneError in meta_search_tools execute', async () => {
+			const filterTool = metaTools.getTool('meta_search_tools');
+			assert(filterTool, 'filterTool should be defined');
+
+			// Pass invalid params type to trigger JSON.parse error on non-JSON string
+			await expect(filterTool.execute('not valid json')).rejects.toThrow('Error executing tool:');
+		});
+
+		it('should wrap non-StackOneError in meta_execute_tool execute', async () => {
+			const executeTool = metaTools.getTool('meta_execute_tool');
+			assert(executeTool, 'executeTool should be defined');
+
+			// Pass invalid JSON string to trigger JSON.parse error
+			await expect(executeTool.execute('not valid json')).rejects.toThrow('Error executing tool:');
+		});
+
+		it('should throw StackOneError for invalid params type in meta_search_tools', async () => {
+			const filterTool = metaTools.getTool('meta_search_tools');
+			assert(filterTool, 'filterTool should be defined');
+
+			// @ts-expect-error - intentionally passing invalid type
+			await expect(filterTool.execute(123)).rejects.toThrow('Invalid parameters type');
+		});
+
+		it('should throw StackOneError for invalid params type in meta_execute_tool', async () => {
+			const executeTool = metaTools.getTool('meta_execute_tool');
+			assert(executeTool, 'executeTool should be defined');
+
+			// @ts-expect-error - intentionally passing invalid type
+			await expect(executeTool.execute(true)).rejects.toThrow('Invalid parameters type');
+		});
+	});
+
 	describe('Integration: meta tools workflow', () => {
 		it('should discover and execute tools in sequence', async () => {
 			const filterTool = metaTools.getTool('meta_search_tools');

src/toolsets.test.ts

@@ -383,6 +383,134 @@ describe('StackOneToolSet', () => {
 		});
 	});
 
+	describe('tool execution', () => {
+		it('should execute tool with dryRun option', async () => {
+			const toolset = new StackOneToolSet({
+				baseUrl: 'https://api.stackone-dev.com',
+				apiKey: 'test-key',
+				accountId: 'test-account',
+			});
+
+			const tools = await toolset.fetchTools();
+			const tool = tools.toArray().find((t) => t.name === 'dummy_action');
+			assert(tool, 'tool should be defined');
+
+			const result = await tool.execute({ body: { name: 'test' } }, { dryRun: true });
+
+			expect(result.url).toBe('https://api.stackone-dev.com/actions/rpc');
+			expect(result.method).toBe('POST');
+			expect(result.headers).toBeDefined();
+			expect(result.body).toBeDefined();
+			expect(result.mappedParams).toEqual({ body: { name: 'test' } });
+		});
+
+		it('should execute tool with path, query, and headers params', async () => {
+			const toolset = new StackOneToolSet({
+				baseUrl: 'https://api.stackone-dev.com',
+				apiKey: 'test-key',
+				accountId: 'test-account',
+			});
+
+			const tools = await toolset.fetchTools();
+			const tool = tools.toArray().find((t) => t.name === 'dummy_action');
+			assert(tool, 'tool should be defined');
+
+			const result = await tool.execute(
+				{
+					body: { name: 'test' },
+					path: { id: '123' },
+					query: { limit: 10 },
+					headers: { 'x-custom': 'value' },
+				},
+				{ dryRun: true },
+			);
+
+			expect(result.mappedParams).toEqual({
+				body: { name: 'test' },
+				path: { id: '123' },
+				query: { limit: 10 },
+				headers: { 'x-custom': 'value' },
+			});
+		});
+
+		it('should execute tool with string parameters', async () => {
+			const toolset = new StackOneToolSet({
+				baseUrl: 'https://api.stackone-dev.com',
+				apiKey: 'test-key',
+				accountId: 'test-account',
+			});
+
+			const tools = await toolset.fetchTools();
+			const tool = tools.toArray().find((t) => t.name === 'dummy_action');
+			assert(tool, 'tool should be defined');
+
+			const result = await tool.execute(JSON.stringify({ body: { name: 'test' } }), {
+				dryRun: true,
+			});
+
+			expect(result.mappedParams).toEqual({ body: { name: 'test' } });
+		});
+
+		it('should throw StackOneError for invalid parameter type', async () => {
+			const toolset = new StackOneToolSet({
+				baseUrl: 'https://api.stackone-dev.com',
+				apiKey: 'test-key',
+				accountId: 'test-account',
+			});
+
+			const tools = await toolset.fetchTools();
+			const tool = tools.toArray().find((t) => t.name === 'dummy_action');
+			assert(tool, 'tool should be defined');
+
+			// @ts-expect-error - intentionally passing invalid type
+			await expect(tool.execute(12345)).rejects.toThrow('Invalid parameters type');
+		});
+
+		it('should wrap non-StackOneError in execute', async () => {
+			const toolset = new StackOneToolSet({
+				baseUrl: 'https://api.stackone-dev.com',
+				apiKey: 'test-key',
+				accountId: 'test-account',
+			});
+
+			const tools = await toolset.fetchTools();
+			const tool = tools.toArray().find((t) => t.name === 'dummy_action');
+			assert(tool, 'tool should be defined');
+
+			// Pass invalid JSON string to trigger JSON.parse error
+			await expect(tool.execute('not valid json')).rejects.toThrow('Error executing RPC action');
+		});
+
+		it('should include extra params in rpcBody', async () => {
+			const toolset = new StackOneToolSet({
+				baseUrl: 'https://api.stackone-dev.com',
+				apiKey: 'test-key',
+				accountId: 'test-account',
+			});
+
+			const tools = await toolset.fetchTools();
+			const tool = tools.toArray().find((t) => t.name === 'dummy_action');
+			assert(tool, 'tool should be defined');
+
+			const result = await tool.execute(
+				{
+					body: { nested: 'value' },
+					extraParam: 'extra-value',
+					anotherParam: 123,
+				},
+				{ dryRun: true },
+			);
+
+			// The body should include both the nested body and extra params
+			const parsedBody = JSON.parse(result.body as string);
+			expect(parsedBody.body).toEqual({
+				nested: 'value',
+				extraParam: 'extra-value',
+				anotherParam: 123,
+			});
+		});
+	});
+
 	describe('provider and action filtering', () => {
 		it('filters tools by providers', async () => {
 			const toolset = new StackOneToolSet({