Port the search execute changes to the node

Author: shashi-stackone

examples/search-tools.ts

@@ -59,8 +59,8 @@ const searchToolsWithAISDK = async (): Promise<void> => {
 const searchToolWithAgentLoop = async (): Promise<void> => {
 	console.log('\nExample 2: SearchTool for agent loops\n');
 
-	// Default constructor — search enabled with method: 'auto'
-	const toolset = new StackOneToolSet();
+	// Enable search with default method: 'auto'
+	const toolset = new StackOneToolSet({ search: {} });
 
 	// Per-call options override constructor defaults when needed
 	const searchTool = toolset.getSearchTool({ search: 'auto' });
@@ -81,7 +81,7 @@ const searchToolWithAgentLoop = async (): Promise<void> => {
 const searchActionNames = async (): Promise<void> => {
 	console.log('\nExample 3: Lightweight action name search\n');
 
-	const toolset = new StackOneToolSet();
+	const toolset = new StackOneToolSet({ search: {} });
 
 	// Search for action names without fetching full tool definitions
 	const results = await toolset.searchActionNames('manage employees', {

src/index.ts

@@ -16,6 +16,7 @@ export {
 	ToolSetLoadError,
 	type AuthenticationConfig,
 	type BaseToolSetConfig,
+	type ExecuteToolsConfig,
 	type SearchMode,
 	type SearchToolsOptions,
 	type SearchActionNamesOptions,

src/meta-tools.test.ts

@@ -262,3 +262,119 @@ describe('createExecuteTool', () => {
 		expect(result).toEqual({ ok: true });
 	});
 });
+
+describe('StackOneToolSet.openai()', () => {
+	function createMockToolSetInstance(options?: {
+		executeConfig?: { accountIds?: string[] };
+		searchConfig?: Record<string, unknown>;
+	}): {
+		toolset: {
+			fetchTools: ReturnType<typeof vi.fn>;
+			getMetaTools: ReturnType<typeof vi.fn>;
+			openai: (opts?: { mode?: 'search_and_execute'; accountIds?: string[] }) => Promise<unknown[]>;
+		};
+	} {
+		const mockTool = new BaseTool(
+			'test_tool',
+			'A test tool',
+			{ type: 'object', properties: {} } satisfies ToolParameters,
+			{ kind: 'local', identifier: 'test:mock' },
+		);
+		const tools = new Tools([mockTool]);
+
+		const metaSearchTool = new BaseTool(
+			'tool_search',
+			'Search for tools',
+			{ type: 'object', properties: { query: { type: 'string' } } } satisfies ToolParameters,
+			{ kind: 'local', identifier: 'meta:search' },
+		);
+		const metaExecuteTool = new BaseTool(
+			'tool_execute',
+			'Execute a tool',
+			{ type: 'object', properties: { tool_name: { type: 'string' } } } satisfies ToolParameters,
+			{ kind: 'local', identifier: 'meta:execute' },
+		);
+		const metaTools = new Tools([metaSearchTool, metaExecuteTool]);
+
+		const fetchTools = vi.fn().mockResolvedValue(tools);
+		const getMetaTools = vi.fn().mockReturnValue(metaTools);
+
+		const executeConfig = options?.executeConfig;
+
+		const toolset = {
+			fetchTools,
+			getMetaTools,
+			async openai(opts?: { mode?: 'search_and_execute'; accountIds?: string[] }): Promise<unknown[]> {
+				const effectiveAccountIds = opts?.accountIds ?? executeConfig?.accountIds;
+
+				if (opts?.mode === 'search_and_execute') {
+					return getMetaTools({ accountIds: effectiveAccountIds }).toOpenAI();
+				}
+
+				const fetchedTools = await fetchTools({ accountIds: effectiveAccountIds });
+				return fetchedTools.toOpenAI();
+			},
+		};
+
+		return { toolset };
+	}
+
+	it('default fetches all tools', async () => {
+		const { toolset } = createMockToolSetInstance();
+
+		const result = await toolset.openai();
+
+		expect(toolset.fetchTools).toHaveBeenCalledOnce();
+		expect(toolset.fetchTools).toHaveBeenCalledWith({ accountIds: undefined });
+		expect(result).toHaveLength(1);
+		expect(result[0]).toHaveProperty('type', 'function');
+	});
+
+	it('search_and_execute returns meta tools', async () => {
+		const { toolset } = createMockToolSetInstance();
+
+		const result = await toolset.openai({ mode: 'search_and_execute' });
+
+		expect(toolset.getMetaTools).toHaveBeenCalledOnce();
+		expect(toolset.fetchTools).not.toHaveBeenCalled();
+		expect(result).toHaveLength(2);
+	});
+
+	it('passes accountIds to fetchTools', async () => {
+		const { toolset } = createMockToolSetInstance();
+
+		await toolset.openai({ accountIds: ['acc-1'] });
+
+		expect(toolset.fetchTools).toHaveBeenCalledWith({ accountIds: ['acc-1'] });
+	});
+
+	it('uses executeConfig.accountIds as fallback', async () => {
+		const { toolset } = createMockToolSetInstance({
+			executeConfig: { accountIds: ['default-acc'] },
+		});
+
+		await toolset.openai();
+
+		expect(toolset.fetchTools).toHaveBeenCalledWith({ accountIds: ['default-acc'] });
+	});
+
+	it('accountIds overrides executeConfig', async () => {
+		const { toolset } = createMockToolSetInstance({
+			executeConfig: { accountIds: ['default-acc'] },
+		});
+
+		await toolset.openai({ accountIds: ['override-acc'] });
+
+		expect(toolset.fetchTools).toHaveBeenCalledWith({ accountIds: ['override-acc'] });
+	});
+
+	it('search_and_execute with executeConfig passes accountIds to getMetaTools', async () => {
+		const { toolset } = createMockToolSetInstance({
+			executeConfig: { accountIds: ['meta-acc'] },
+		});
+
+		await toolset.openai({ mode: 'search_and_execute' });
+
+		expect(toolset.getMetaTools).toHaveBeenCalledWith({ accountIds: ['meta-acc'] });
+	});
+});

src/toolsets.test.ts

@@ -719,6 +719,7 @@ describe('StackOneToolSet', () => {
 				baseUrl: TEST_BASE_URL,
 				apiKey: 'test-key',
 				accountId: 'mixed',
+				search: {},
 			});
 
 			// Mock the semantic search endpoint
@@ -763,6 +764,7 @@ describe('StackOneToolSet', () => {
 				baseUrl: TEST_BASE_URL,
 				apiKey: 'test-key',
 				accountId: 'mixed',
+				search: {},
 			});
 
 			// Mock semantic search to fail
@@ -787,6 +789,7 @@ describe('StackOneToolSet', () => {
 				baseUrl: TEST_BASE_URL,
 				apiKey: 'test-key',
 				accountId: 'mixed',
+				search: {},
 			});
 
 			// Mock semantic search to fail
@@ -806,6 +809,7 @@ describe('StackOneToolSet', () => {
 				baseUrl: TEST_BASE_URL,
 				apiKey: 'test-key',
 				accountId: 'mixed',
+				search: {},
 			});
 
 			const tools = await toolset.searchTools('list employees', {
@@ -827,6 +831,7 @@ describe('StackOneToolSet', () => {
 				baseUrl: TEST_BASE_URL,
 				apiKey: 'test-key',
 				accountId: 'test-account',
+				search: {},
 			});
 
 			// test-account only has dummy_action which has a connector prefix "dummy"
@@ -854,6 +859,7 @@ describe('StackOneToolSet', () => {
 				baseUrl: TEST_BASE_URL,
 				apiKey: 'test-key',
 				accountId: 'mixed',
+				search: {},
 			});
 
 			server.use(
@@ -886,6 +892,7 @@ describe('StackOneToolSet', () => {
 				baseUrl: TEST_BASE_URL,
 				apiKey: 'test-key',
 				accountId: 'mixed',
+				search: {},
 			});
 
 			server.use(
@@ -904,6 +911,7 @@ describe('StackOneToolSet', () => {
 			const toolset = new StackOneToolSet({
 				baseUrl: TEST_BASE_URL,
 				apiKey: 'test-key',
+				search: {},
 			});
 
 			const searchTool = toolset.getSearchTool();
@@ -915,6 +923,7 @@ describe('StackOneToolSet', () => {
 				baseUrl: TEST_BASE_URL,
 				apiKey: 'test-key',
 				accountId: 'mixed',
+				search: {},
 			});
 
 			server.use(
@@ -947,6 +956,7 @@ describe('StackOneToolSet', () => {
 				baseUrl: TEST_BASE_URL,
 				apiKey: 'test-key',
 				accountId: 'mixed',
+				search: {},
 			});
 
 			// Create search tool with local mode

src/toolsets.ts

@@ -125,6 +125,15 @@ interface MultipleAccountsConfig {
  */
 type AccountConfig = SimplifyDeep<MergeExclusive<SingleAccountConfig, MultipleAccountsConfig>>;
 
+/**
+ * Execution configuration for the StackOneToolSet constructor.
+ * Controls default account scoping for tool execution in meta tools.
+ */
+export interface ExecuteToolsConfig {
+	/** Account IDs to scope tool discovery and execution. */
+	accountIds?: string[];
+}
+
 /**
  * Base configuration for StackOne toolset (without account options)
  */
@@ -135,13 +144,19 @@ interface StackOneToolSetBaseConfig extends BaseToolSetConfig {
 	 * Search configuration. Controls default search behavior for `searchTools()`,
 	 * `getSearchTool()`, and `searchActionNames()`.
 	 *
-	 * - Omit or pass `undefined` → search enabled with defaults (`method: 'auto'`)
+	 * - Omit or pass `undefined` → search disabled (`null`)
 	 * - Pass `null` → search disabled
+	 * - Pass `{}` or `{ method: 'auto' }` → search enabled with defaults
 	 * - Pass `{ method, topK, minSimilarity }` → search enabled with custom defaults
 	 *
 	 * Per-call options always override these defaults.
 	 */
 	search?: SearchConfig | null;
+	/**
+	 * Execution configuration. Controls default account scoping for tool execution.
+	 * Pass `{ accountIds: ['acc-1'] }` to scope meta tools to specific accounts.
+	 */
+	execute?: ExecuteToolsConfig;
 }
 
 /**
@@ -262,6 +277,7 @@ export class StackOneToolSet {
 	private headers: Record<string, string>;
 	private rpcClient?: RpcClient;
 	private readonly searchConfig: SearchConfig | null;
+	private readonly executeConfig: ExecuteToolsConfig | undefined;
 
 	/**
 	 * Account ID for StackOne API
@@ -318,8 +334,9 @@ export class StackOneToolSet {
 		this.accountId = accountId;
 		this.accountIds = config?.accountIds ?? [];
 
-		// Resolve search config: undefined → defaults, null → disabled, object → custom
-		this.searchConfig = config?.search === null ? null : { method: 'auto', ...config?.search };
+		// Resolve search config: undefined/null → disabled, object → custom with defaults
+		this.searchConfig = config?.search != null ? { method: 'auto', ...config.search } : null;
+		this.executeConfig = config?.execute;
 
 		// Set Authentication headers if provided
 		if (this.authentication) {
@@ -467,6 +484,43 @@ export class StackOneToolSet {
 		return new Tools([searchTool, executeTool]);
 	}
 
+	/**
+	 * Get tools in OpenAI function calling format.
+	 *
+	 * @param options - Options
+	 * @param options.mode - Tool mode.
+	 *   `undefined` (default): fetch all tools and convert to OpenAI format.
+	 *   `"search_and_execute"`: return two meta tools (tool_search + tool_execute)
+	 *   that let the LLM discover and execute tools on-demand.
+	 * @param options.accountIds - Account IDs to scope tools. Overrides the `execute`
+	 *   config from the constructor.
+	 * @returns List of tool definitions in OpenAI function format.
+	 *
+	 * @example
+	 * ```typescript
+	 * // All tools
+	 * const toolset = new StackOneToolSet();
+	 * const tools = await toolset.openai();
+	 *
+	 * // Meta tools for agent-driven discovery
+	 * const toolset = new StackOneToolSet({ search: {} });
+	 * const tools = await toolset.openai({ mode: 'search_and_execute' });
+	 * ```
+	 */
+	async openai(options?: {
+		mode?: 'search_and_execute';
+		accountIds?: string[];
+	}): Promise<ReturnType<Tools['toOpenAI']>> {
+		const effectiveAccountIds = options?.accountIds ?? this.executeConfig?.accountIds;
+
+		if (options?.mode === 'search_and_execute') {
+			return this.getMetaTools({ accountIds: effectiveAccountIds }).toOpenAI();
+		}
+
+		const tools = await this.fetchTools({ accountIds: effectiveAccountIds });
+		return tools.toOpenAI();
+	}
+
 	/**
 	 * Search for and fetch tools using semantic or local search.
 	 *