@langchain/xai 1.2.2 → 1.3.1

package/dist/tools/code_execution.cjs

@@ -0,0 +1,52 @@
+
+//#region src/tools/code_execution.ts
+/**
+* xAI Code Execution tool type constant.
+* Note: The Responses API uses "code_interpreter" as the type name.
+*/
+const XAI_CODE_EXECUTION_TOOL_TYPE = "code_interpreter";
+/**
+* Creates an xAI code execution tool.
+* Enables the model to write and execute Python code in real-time for
+* calculations, data analysis, and complex computations.
+*
+* This tool is executed server-side by the xAI API in a secure, sandboxed
+* Python environment with common libraries pre-installed (NumPy, Pandas,
+* Matplotlib, SciPy).
+*
+* @returns An XAICodeExecutionTool object to pass to the model
+*
+* @example Basic usage
+* ```typescript
+* import { ChatXAIResponses, tools } from "@langchain/xai";
+*
+* const llm = new ChatXAIResponses({
+*   model: "grok-4-1-fast",
+* });
+*
+* const codeExecution = tools.xaiCodeExecution();
+* const result = await llm.invoke(
+*   "Calculate the compound interest for $10,000 at 5% annually for 10 years",
+*   { tools: [codeExecution] }
+* );
+* ```
+*
+* @example Combining with search tools
+* ```typescript
+* const webSearch = tools.xaiWebSearch();
+* const codeExecution = tools.xaiCodeExecution();
+*
+* const result = await llm.invoke(
+*   "Find the current stock price of AAPL and calculate what it would be worth with 10% annual growth over 5 years",
+*   { tools: [webSearch, codeExecution] }
+* );
+* ```
+*/
+function xaiCodeExecution() {
+	return { type: XAI_CODE_EXECUTION_TOOL_TYPE };
+}
+
+//#endregion
+exports.XAI_CODE_EXECUTION_TOOL_TYPE = XAI_CODE_EXECUTION_TOOL_TYPE;
+exports.xaiCodeExecution = xaiCodeExecution;
+//# sourceMappingURL=code_execution.cjs.map

package/dist/tools/code_execution.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"code_execution.cjs","names":[],"sources":["../../src/tools/code_execution.ts"],"sourcesContent":["/**\n * xAI Code Execution tool type constant.\n * Note: The Responses API uses \"code_interpreter\" as the type name.\n */\nexport const XAI_CODE_EXECUTION_TOOL_TYPE = \"code_interpreter\";\n\n/**\n * xAI's built-in code execution tool interface.\n * Enables the model to write and execute Python code in real-time.\n *\n * This tool is part of xAI's agentic tool calling API and allows for:\n * - Mathematical computations\n * - Data analysis\n * - Financial modeling\n * - Scientific computing\n * - Code generation and testing\n */\nexport interface XAICodeExecutionTool {\n  /**\n   * The type of the tool. Must be \"code_interpreter\".\n   */\n  type: typeof XAI_CODE_EXECUTION_TOOL_TYPE;\n}\n\n/**\n * Creates an xAI code execution tool.\n * Enables the model to write and execute Python code in real-time for\n * calculations, data analysis, and complex computations.\n *\n * This tool is executed server-side by the xAI API in a secure, sandboxed\n * Python environment with common libraries pre-installed (NumPy, Pandas,\n * Matplotlib, SciPy).\n *\n * @returns An XAICodeExecutionTool object to pass to the model\n *\n * @example Basic usage\n * ```typescript\n * import { ChatXAIResponses, tools } from \"@langchain/xai\";\n *\n * const llm = new ChatXAIResponses({\n *   model: \"grok-4-1-fast\",\n * });\n *\n * const codeExecution = tools.xaiCodeExecution();\n * const result = await llm.invoke(\n *   \"Calculate the compound interest for $10,000 at 5% annually for 10 years\",\n *   { tools: [codeExecution] }\n * );\n * ```\n *\n * @example Combining with search tools\n * ```typescript\n * const webSearch = tools.xaiWebSearch();\n * const codeExecution = tools.xaiCodeExecution();\n *\n * const result = await llm.invoke(\n *   \"Find the current stock price of AAPL and calculate what it would be worth with 10% annual growth over 5 years\",\n *   { tools: [webSearch, codeExecution] }\n * );\n * ```\n */\nexport function xaiCodeExecution(): XAICodeExecutionTool {\n  return {\n    type: XAI_CODE_EXECUTION_TOOL_TYPE,\n  };\n}\n"],"mappings":";;;;;;AAIA,MAAa,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyD5C,SAAgB,mBAAyC;AACvD,QAAO,EACL,MAAM,6BACP;AACF"}

package/dist/tools/code_execution.d.cts

@@ -0,0 +1,64 @@
+//#region src/tools/code_execution.d.ts
+/**
+ * xAI Code Execution tool type constant.
+ * Note: The Responses API uses "code_interpreter" as the type name.
+ */
+declare const XAI_CODE_EXECUTION_TOOL_TYPE = "code_interpreter";
+/**
+ * xAI's built-in code execution tool interface.
+ * Enables the model to write and execute Python code in real-time.
+ *
+ * This tool is part of xAI's agentic tool calling API and allows for:
+ * - Mathematical computations
+ * - Data analysis
+ * - Financial modeling
+ * - Scientific computing
+ * - Code generation and testing
+ */
+interface XAICodeExecutionTool {
+  /**
+   * The type of the tool. Must be "code_interpreter".
+   */
+  type: typeof XAI_CODE_EXECUTION_TOOL_TYPE;
+}
+/**
+ * Creates an xAI code execution tool.
+ * Enables the model to write and execute Python code in real-time for
+ * calculations, data analysis, and complex computations.
+ *
+ * This tool is executed server-side by the xAI API in a secure, sandboxed
+ * Python environment with common libraries pre-installed (NumPy, Pandas,
+ * Matplotlib, SciPy).
+ *
+ * @returns An XAICodeExecutionTool object to pass to the model
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { ChatXAIResponses, tools } from "@langchain/xai";
+ *
+ * const llm = new ChatXAIResponses({
+ *   model: "grok-4-1-fast",
+ * });
+ *
+ * const codeExecution = tools.xaiCodeExecution();
+ * const result = await llm.invoke(
+ *   "Calculate the compound interest for $10,000 at 5% annually for 10 years",
+ *   { tools: [codeExecution] }
+ * );
+ * ```
+ *
+ * @example Combining with search tools
+ * ```typescript
+ * const webSearch = tools.xaiWebSearch();
+ * const codeExecution = tools.xaiCodeExecution();
+ *
+ * const result = await llm.invoke(
+ *   "Find the current stock price of AAPL and calculate what it would be worth with 10% annual growth over 5 years",
+ *   { tools: [webSearch, codeExecution] }
+ * );
+ * ```
+ */
+declare function xaiCodeExecution(): XAICodeExecutionTool;
+//#endregion
+export { XAICodeExecutionTool, XAI_CODE_EXECUTION_TOOL_TYPE, xaiCodeExecution };
+//# sourceMappingURL=code_execution.d.cts.map

package/dist/tools/code_execution.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code_execution.d.cts","names":["XAI_CODE_EXECUTION_TOOL_TYPE","XAICodeExecutionTool","xaiCodeExecution"],"sources":["../../src/tools/code_execution.d.ts"],"sourcesContent":["/**\n * xAI Code Execution tool type constant.\n * Note: The Responses API uses \"code_interpreter\" as the type name.\n */\nexport declare const XAI_CODE_EXECUTION_TOOL_TYPE = \"code_interpreter\";\n/**\n * xAI's built-in code execution tool interface.\n * Enables the model to write and execute Python code in real-time.\n *\n * This tool is part of xAI's agentic tool calling API and allows for:\n * - Mathematical computations\n * - Data analysis\n * - Financial modeling\n * - Scientific computing\n * - Code generation and testing\n */\nexport interface XAICodeExecutionTool {\n    /**\n     * The type of the tool. Must be \"code_interpreter\".\n     */\n    type: typeof XAI_CODE_EXECUTION_TOOL_TYPE;\n}\n/**\n * Creates an xAI code execution tool.\n * Enables the model to write and execute Python code in real-time for\n * calculations, data analysis, and complex computations.\n *\n * This tool is executed server-side by the xAI API in a secure, sandboxed\n * Python environment with common libraries pre-installed (NumPy, Pandas,\n * Matplotlib, SciPy).\n *\n * @returns An XAICodeExecutionTool object to pass to the model\n *\n * @example Basic usage\n * ```typescript\n * import { ChatXAIResponses, tools } from \"@langchain/xai\";\n *\n * const llm = new ChatXAIResponses({\n *   model: \"grok-4-1-fast\",\n * });\n *\n * const codeExecution = tools.xaiCodeExecution();\n * const result = await llm.invoke(\n *   \"Calculate the compound interest for $10,000 at 5% annually for 10 years\",\n *   { tools: [codeExecution] }\n * );\n * ```\n *\n * @example Combining with search tools\n * ```typescript\n * const webSearch = tools.xaiWebSearch();\n * const codeExecution = tools.xaiCodeExecution();\n *\n * const result = await llm.invoke(\n *   \"Find the current stock price of AAPL and calculate what it would be worth with 10% annual growth over 5 years\",\n *   { tools: [webSearch, codeExecution] }\n * );\n * ```\n */\nexport declare function xaiCodeExecution(): XAICodeExecutionTool;\n//# sourceMappingURL=code_execution.d.ts.map"],"mappings":";;AAIA;AAYA;AA2CA;cAvDqBA,4BAAAA;;;;;;;;;;;;UAYJC,oBAAAA;;;;eAIAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCOE,gBAAAA,CAAAA,GAAoBD"}

package/dist/tools/code_execution.d.ts

@@ -0,0 +1,64 @@
+//#region src/tools/code_execution.d.ts
+/**
+ * xAI Code Execution tool type constant.
+ * Note: The Responses API uses "code_interpreter" as the type name.
+ */
+declare const XAI_CODE_EXECUTION_TOOL_TYPE = "code_interpreter";
+/**
+ * xAI's built-in code execution tool interface.
+ * Enables the model to write and execute Python code in real-time.
+ *
+ * This tool is part of xAI's agentic tool calling API and allows for:
+ * - Mathematical computations
+ * - Data analysis
+ * - Financial modeling
+ * - Scientific computing
+ * - Code generation and testing
+ */
+interface XAICodeExecutionTool {
+  /**
+   * The type of the tool. Must be "code_interpreter".
+   */
+  type: typeof XAI_CODE_EXECUTION_TOOL_TYPE;
+}
+/**
+ * Creates an xAI code execution tool.
+ * Enables the model to write and execute Python code in real-time for
+ * calculations, data analysis, and complex computations.
+ *
+ * This tool is executed server-side by the xAI API in a secure, sandboxed
+ * Python environment with common libraries pre-installed (NumPy, Pandas,
+ * Matplotlib, SciPy).
+ *
+ * @returns An XAICodeExecutionTool object to pass to the model
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { ChatXAIResponses, tools } from "@langchain/xai";
+ *
+ * const llm = new ChatXAIResponses({
+ *   model: "grok-4-1-fast",
+ * });
+ *
+ * const codeExecution = tools.xaiCodeExecution();
+ * const result = await llm.invoke(
+ *   "Calculate the compound interest for $10,000 at 5% annually for 10 years",
+ *   { tools: [codeExecution] }
+ * );
+ * ```
+ *
+ * @example Combining with search tools
+ * ```typescript
+ * const webSearch = tools.xaiWebSearch();
+ * const codeExecution = tools.xaiCodeExecution();
+ *
+ * const result = await llm.invoke(
+ *   "Find the current stock price of AAPL and calculate what it would be worth with 10% annual growth over 5 years",
+ *   { tools: [webSearch, codeExecution] }
+ * );
+ * ```
+ */
+declare function xaiCodeExecution(): XAICodeExecutionTool;
+//#endregion
+export { XAICodeExecutionTool, XAI_CODE_EXECUTION_TOOL_TYPE, xaiCodeExecution };
+//# sourceMappingURL=code_execution.d.ts.map

package/dist/tools/code_execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code_execution.d.ts","names":["XAI_CODE_EXECUTION_TOOL_TYPE","XAICodeExecutionTool","xaiCodeExecution"],"sources":["../../src/tools/code_execution.d.ts"],"sourcesContent":["/**\n * xAI Code Execution tool type constant.\n * Note: The Responses API uses \"code_interpreter\" as the type name.\n */\nexport declare const XAI_CODE_EXECUTION_TOOL_TYPE = \"code_interpreter\";\n/**\n * xAI's built-in code execution tool interface.\n * Enables the model to write and execute Python code in real-time.\n *\n * This tool is part of xAI's agentic tool calling API and allows for:\n * - Mathematical computations\n * - Data analysis\n * - Financial modeling\n * - Scientific computing\n * - Code generation and testing\n */\nexport interface XAICodeExecutionTool {\n    /**\n     * The type of the tool. Must be \"code_interpreter\".\n     */\n    type: typeof XAI_CODE_EXECUTION_TOOL_TYPE;\n}\n/**\n * Creates an xAI code execution tool.\n * Enables the model to write and execute Python code in real-time for\n * calculations, data analysis, and complex computations.\n *\n * This tool is executed server-side by the xAI API in a secure, sandboxed\n * Python environment with common libraries pre-installed (NumPy, Pandas,\n * Matplotlib, SciPy).\n *\n * @returns An XAICodeExecutionTool object to pass to the model\n *\n * @example Basic usage\n * ```typescript\n * import { ChatXAIResponses, tools } from \"@langchain/xai\";\n *\n * const llm = new ChatXAIResponses({\n *   model: \"grok-4-1-fast\",\n * });\n *\n * const codeExecution = tools.xaiCodeExecution();\n * const result = await llm.invoke(\n *   \"Calculate the compound interest for $10,000 at 5% annually for 10 years\",\n *   { tools: [codeExecution] }\n * );\n * ```\n *\n * @example Combining with search tools\n * ```typescript\n * const webSearch = tools.xaiWebSearch();\n * const codeExecution = tools.xaiCodeExecution();\n *\n * const result = await llm.invoke(\n *   \"Find the current stock price of AAPL and calculate what it would be worth with 10% annual growth over 5 years\",\n *   { tools: [webSearch, codeExecution] }\n * );\n * ```\n */\nexport declare function xaiCodeExecution(): XAICodeExecutionTool;\n//# sourceMappingURL=code_execution.d.ts.map"],"mappings":";;AAIA;AAYA;AA2CA;cAvDqBA,4BAAAA;;;;;;;;;;;;UAYJC,oBAAAA;;;;eAIAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCOE,gBAAAA,CAAAA,GAAoBD"}

package/dist/tools/code_execution.js

@@ -0,0 +1,50 @@
+//#region src/tools/code_execution.ts
+/**
+* xAI Code Execution tool type constant.
+* Note: The Responses API uses "code_interpreter" as the type name.
+*/
+const XAI_CODE_EXECUTION_TOOL_TYPE = "code_interpreter";
+/**
+* Creates an xAI code execution tool.
+* Enables the model to write and execute Python code in real-time for
+* calculations, data analysis, and complex computations.
+*
+* This tool is executed server-side by the xAI API in a secure, sandboxed
+* Python environment with common libraries pre-installed (NumPy, Pandas,
+* Matplotlib, SciPy).
+*
+* @returns An XAICodeExecutionTool object to pass to the model
+*
+* @example Basic usage
+* ```typescript
+* import { ChatXAIResponses, tools } from "@langchain/xai";
+*
+* const llm = new ChatXAIResponses({
+*   model: "grok-4-1-fast",
+* });
+*
+* const codeExecution = tools.xaiCodeExecution();
+* const result = await llm.invoke(
+*   "Calculate the compound interest for $10,000 at 5% annually for 10 years",
+*   { tools: [codeExecution] }
+* );
+* ```
+*
+* @example Combining with search tools
+* ```typescript
+* const webSearch = tools.xaiWebSearch();
+* const codeExecution = tools.xaiCodeExecution();
+*
+* const result = await llm.invoke(
+*   "Find the current stock price of AAPL and calculate what it would be worth with 10% annual growth over 5 years",
+*   { tools: [webSearch, codeExecution] }
+* );
+* ```
+*/
+function xaiCodeExecution() {
+	return { type: XAI_CODE_EXECUTION_TOOL_TYPE };
+}
+
+//#endregion
+export { XAI_CODE_EXECUTION_TOOL_TYPE, xaiCodeExecution };
+//# sourceMappingURL=code_execution.js.map

package/dist/tools/code_execution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code_execution.js","names":[],"sources":["../../src/tools/code_execution.ts"],"sourcesContent":["/**\n * xAI Code Execution tool type constant.\n * Note: The Responses API uses \"code_interpreter\" as the type name.\n */\nexport const XAI_CODE_EXECUTION_TOOL_TYPE = \"code_interpreter\";\n\n/**\n * xAI's built-in code execution tool interface.\n * Enables the model to write and execute Python code in real-time.\n *\n * This tool is part of xAI's agentic tool calling API and allows for:\n * - Mathematical computations\n * - Data analysis\n * - Financial modeling\n * - Scientific computing\n * - Code generation and testing\n */\nexport interface XAICodeExecutionTool {\n  /**\n   * The type of the tool. Must be \"code_interpreter\".\n   */\n  type: typeof XAI_CODE_EXECUTION_TOOL_TYPE;\n}\n\n/**\n * Creates an xAI code execution tool.\n * Enables the model to write and execute Python code in real-time for\n * calculations, data analysis, and complex computations.\n *\n * This tool is executed server-side by the xAI API in a secure, sandboxed\n * Python environment with common libraries pre-installed (NumPy, Pandas,\n * Matplotlib, SciPy).\n *\n * @returns An XAICodeExecutionTool object to pass to the model\n *\n * @example Basic usage\n * ```typescript\n * import { ChatXAIResponses, tools } from \"@langchain/xai\";\n *\n * const llm = new ChatXAIResponses({\n *   model: \"grok-4-1-fast\",\n * });\n *\n * const codeExecution = tools.xaiCodeExecution();\n * const result = await llm.invoke(\n *   \"Calculate the compound interest for $10,000 at 5% annually for 10 years\",\n *   { tools: [codeExecution] }\n * );\n * ```\n *\n * @example Combining with search tools\n * ```typescript\n * const webSearch = tools.xaiWebSearch();\n * const codeExecution = tools.xaiCodeExecution();\n *\n * const result = await llm.invoke(\n *   \"Find the current stock price of AAPL and calculate what it would be worth with 10% annual growth over 5 years\",\n *   { tools: [webSearch, codeExecution] }\n * );\n * ```\n */\nexport function xaiCodeExecution(): XAICodeExecutionTool {\n  return {\n    type: XAI_CODE_EXECUTION_TOOL_TYPE,\n  };\n}\n"],"mappings":";;;;;AAIA,MAAa,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyD5C,SAAgB,mBAAyC;AACvD,QAAO,EACL,MAAM,6BACP;AACF"}

package/dist/tools/collections_search.cjs

@@ -0,0 +1,60 @@
+
+//#region src/tools/collections_search.ts
+/**
+* xAI Collections Search tool type constant.
+* Note: The Responses API uses "file_search" as the type name.
+*/
+const XAI_COLLECTIONS_SEARCH_TOOL_TYPE = "file_search";
+/**
+* Creates an xAI collections search tool.
+* Enables the model to search through your uploaded knowledge bases (collections)
+* to retrieve relevant information from your documents.
+*
+* This tool is executed server-side by the xAI API as part of the agentic
+* tool calling workflow.
+*
+* @param options - Configuration options for the collections search tool
+* @returns An XAICollectionsSearchTool object to pass to the model
+*
+* @example Basic usage with collection IDs
+* ```typescript
+* import { ChatXAIResponses, tools } from "@langchain/xai";
+*
+* const llm = new ChatXAIResponses({
+*   model: "grok-4-1-fast",
+* });
+*
+* const collectionsSearch = tools.xaiCollectionsSearch({
+*   vectorStoreIds: ["collection_abc123"],
+* });
+*
+* const result = await llm.invoke(
+*   "What are the key findings in the Q3 report?",
+*   { tools: [collectionsSearch] }
+* );
+* ```
+*
+* @example Combining with other tools for hybrid analysis
+* ```typescript
+* const collectionsSearch = tools.xaiCollectionsSearch({
+*   vectorStoreIds: ["collection_sec_filings"],
+* });
+* const webSearch = tools.xaiWebSearch();
+* const codeExecution = tools.xaiCodeExecution();
+*
+* const result = await llm.invoke(
+*   "Based on our internal SEC filings, what is the market sentiment on our performance?",
+*   { tools: [collectionsSearch, webSearch, codeExecution] }
+* );
+* ```
+*/
+function xaiCollectionsSearch(options = {}) {
+	const tool = { type: XAI_COLLECTIONS_SEARCH_TOOL_TYPE };
+	if (options.vectorStoreIds !== void 0) tool.vector_store_ids = options.vectorStoreIds;
+	return tool;
+}
+
+//#endregion
+exports.XAI_COLLECTIONS_SEARCH_TOOL_TYPE = XAI_COLLECTIONS_SEARCH_TOOL_TYPE;
+exports.xaiCollectionsSearch = xaiCollectionsSearch;
+//# sourceMappingURL=collections_search.cjs.map

package/dist/tools/collections_search.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections_search.cjs","names":["options: XAICollectionsSearchToolOptions","tool: XAICollectionsSearchTool"],"sources":["../../src/tools/collections_search.ts"],"sourcesContent":["/**\n * xAI Collections Search tool type constant.\n * Note: The Responses API uses \"file_search\" as the type name.\n */\nexport const XAI_COLLECTIONS_SEARCH_TOOL_TYPE = \"file_search\";\n\n/**\n * xAI's built-in collections search tool interface.\n * Enables the model to search through uploaded knowledge bases (collections)\n * to retrieve relevant information from your documents.\n *\n * This tool is part of xAI's agentic tool calling API and is particularly\n * powerful for:\n * - Document retrieval from uploaded files\n * - Semantic search across knowledge bases\n * - RAG (Retrieval-Augmented Generation) applications\n * - Enterprise knowledge base queries\n */\nexport interface XAICollectionsSearchTool {\n  /**\n   * The type of the tool. Must be \"file_search\".\n   */\n  type: typeof XAI_COLLECTIONS_SEARCH_TOOL_TYPE;\n  /**\n   * List of vector store (collection) IDs to search.\n   * These are the IDs of collections created via the xAI Collections API.\n   */\n  vector_store_ids?: string[];\n}\n\n/**\n * Options for the xAI collections search tool (camelCase).\n * All fields are camel-cased for the TypeScript API and are mapped to the\n * corresponding snake_case fields in the API request.\n */\nexport interface XAICollectionsSearchToolOptions {\n  /**\n   * List of vector store (collection) IDs to search.\n   * These are the IDs of collections created via the xAI Collections API.\n   *\n   * @example [\"collection_abc123\", \"collection_def456\"]\n   */\n  vectorStoreIds?: string[];\n}\n\n/**\n * Creates an xAI collections search tool.\n * Enables the model to search through your uploaded knowledge bases (collections)\n * to retrieve relevant information from your documents.\n *\n * This tool is executed server-side by the xAI API as part of the agentic\n * tool calling workflow.\n *\n * @param options - Configuration options for the collections search tool\n * @returns An XAICollectionsSearchTool object to pass to the model\n *\n * @example Basic usage with collection IDs\n * ```typescript\n * import { ChatXAIResponses, tools } from \"@langchain/xai\";\n *\n * const llm = new ChatXAIResponses({\n *   model: \"grok-4-1-fast\",\n * });\n *\n * const collectionsSearch = tools.xaiCollectionsSearch({\n *   vectorStoreIds: [\"collection_abc123\"],\n * });\n *\n * const result = await llm.invoke(\n *   \"What are the key findings in the Q3 report?\",\n *   { tools: [collectionsSearch] }\n * );\n * ```\n *\n * @example Combining with other tools for hybrid analysis\n * ```typescript\n * const collectionsSearch = tools.xaiCollectionsSearch({\n *   vectorStoreIds: [\"collection_sec_filings\"],\n * });\n * const webSearch = tools.xaiWebSearch();\n * const codeExecution = tools.xaiCodeExecution();\n *\n * const result = await llm.invoke(\n *   \"Based on our internal SEC filings, what is the market sentiment on our performance?\",\n *   { tools: [collectionsSearch, webSearch, codeExecution] }\n * );\n * ```\n */\nexport function xaiCollectionsSearch(\n  options: XAICollectionsSearchToolOptions = {}\n): XAICollectionsSearchTool {\n  const tool: XAICollectionsSearchTool = {\n    type: XAI_COLLECTIONS_SEARCH_TOOL_TYPE,\n  };\n\n  if (options.vectorStoreIds !== undefined) {\n    tool.vector_store_ids = options.vectorStoreIds;\n  }\n\n  return tool;\n}\n"],"mappings":";;;;;;AAIA,MAAa,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFhD,SAAgB,qBACdA,UAA2C,CAAE,GACnB;CAC1B,MAAMC,OAAiC,EACrC,MAAM,iCACP;AAED,KAAI,QAAQ,mBAAmB,QAC7B,KAAK,mBAAmB,QAAQ;AAGlC,QAAO;AACR"}

package/dist/tools/collections_search.d.cts

@@ -0,0 +1,90 @@
+//#region src/tools/collections_search.d.ts
+/**
+ * xAI Collections Search tool type constant.
+ * Note: The Responses API uses "file_search" as the type name.
+ */
+declare const XAI_COLLECTIONS_SEARCH_TOOL_TYPE = "file_search";
+/**
+ * xAI's built-in collections search tool interface.
+ * Enables the model to search through uploaded knowledge bases (collections)
+ * to retrieve relevant information from your documents.
+ *
+ * This tool is part of xAI's agentic tool calling API and is particularly
+ * powerful for:
+ * - Document retrieval from uploaded files
+ * - Semantic search across knowledge bases
+ * - RAG (Retrieval-Augmented Generation) applications
+ * - Enterprise knowledge base queries
+ */
+interface XAICollectionsSearchTool {
+  /**
+   * The type of the tool. Must be "file_search".
+   */
+  type: typeof XAI_COLLECTIONS_SEARCH_TOOL_TYPE;
+  /**
+   * List of vector store (collection) IDs to search.
+   * These are the IDs of collections created via the xAI Collections API.
+   */
+  vector_store_ids?: string[];
+}
+/**
+ * Options for the xAI collections search tool (camelCase).
+ * All fields are camel-cased for the TypeScript API and are mapped to the
+ * corresponding snake_case fields in the API request.
+ */
+interface XAICollectionsSearchToolOptions {
+  /**
+   * List of vector store (collection) IDs to search.
+   * These are the IDs of collections created via the xAI Collections API.
+   *
+   * @example ["collection_abc123", "collection_def456"]
+   */
+  vectorStoreIds?: string[];
+}
+/**
+ * Creates an xAI collections search tool.
+ * Enables the model to search through your uploaded knowledge bases (collections)
+ * to retrieve relevant information from your documents.
+ *
+ * This tool is executed server-side by the xAI API as part of the agentic
+ * tool calling workflow.
+ *
+ * @param options - Configuration options for the collections search tool
+ * @returns An XAICollectionsSearchTool object to pass to the model
+ *
+ * @example Basic usage with collection IDs
+ * ```typescript
+ * import { ChatXAIResponses, tools } from "@langchain/xai";
+ *
+ * const llm = new ChatXAIResponses({
+ *   model: "grok-4-1-fast",
+ * });
+ *
+ * const collectionsSearch = tools.xaiCollectionsSearch({
+ *   vectorStoreIds: ["collection_abc123"],
+ * });
+ *
+ * const result = await llm.invoke(
+ *   "What are the key findings in the Q3 report?",
+ *   { tools: [collectionsSearch] }
+ * );
+ * ```
+ *
+ * @example Combining with other tools for hybrid analysis
+ * ```typescript
+ * const collectionsSearch = tools.xaiCollectionsSearch({
+ *   vectorStoreIds: ["collection_sec_filings"],
+ * });
+ * const webSearch = tools.xaiWebSearch();
+ * const codeExecution = tools.xaiCodeExecution();
+ *
+ * const result = await llm.invoke(
+ *   "Based on our internal SEC filings, what is the market sentiment on our performance?",
+ *   { tools: [collectionsSearch, webSearch, codeExecution] }
+ * );
+ * ```
+ */
+declare function xaiCollectionsSearch(options?: XAICollectionsSearchToolOptions): XAICollectionsSearchTool;
+//#endregion
+export { XAICollectionsSearchTool, XAICollectionsSearchToolOptions, XAI_COLLECTIONS_SEARCH_TOOL_TYPE, xaiCollectionsSearch };
+//# sourceMappingURL=collections_search.d.cts.map

package/dist/tools/collections_search.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections_search.d.cts","names":["XAI_COLLECTIONS_SEARCH_TOOL_TYPE","XAICollectionsSearchTool","XAICollectionsSearchToolOptions","xaiCollectionsSearch"],"sources":["../../src/tools/collections_search.d.ts"],"sourcesContent":["/**\n * xAI Collections Search tool type constant.\n * Note: The Responses API uses \"file_search\" as the type name.\n */\nexport declare const XAI_COLLECTIONS_SEARCH_TOOL_TYPE = \"file_search\";\n/**\n * xAI's built-in collections search tool interface.\n * Enables the model to search through uploaded knowledge bases (collections)\n * to retrieve relevant information from your documents.\n *\n * This tool is part of xAI's agentic tool calling API and is particularly\n * powerful for:\n * - Document retrieval from uploaded files\n * - Semantic search across knowledge bases\n * - RAG (Retrieval-Augmented Generation) applications\n * - Enterprise knowledge base queries\n */\nexport interface XAICollectionsSearchTool {\n    /**\n     * The type of the tool. Must be \"file_search\".\n     */\n    type: typeof XAI_COLLECTIONS_SEARCH_TOOL_TYPE;\n    /**\n     * List of vector store (collection) IDs to search.\n     * These are the IDs of collections created via the xAI Collections API.\n     */\n    vector_store_ids?: string[];\n}\n/**\n * Options for the xAI collections search tool (camelCase).\n * All fields are camel-cased for the TypeScript API and are mapped to the\n * corresponding snake_case fields in the API request.\n */\nexport interface XAICollectionsSearchToolOptions {\n    /**\n     * List of vector store (collection) IDs to search.\n     * These are the IDs of collections created via the xAI Collections API.\n     *\n     * @example [\"collection_abc123\", \"collection_def456\"]\n     */\n    vectorStoreIds?: string[];\n}\n/**\n * Creates an xAI collections search tool.\n * Enables the model to search through your uploaded knowledge bases (collections)\n * to retrieve relevant information from your documents.\n *\n * This tool is executed server-side by the xAI API as part of the agentic\n * tool calling workflow.\n *\n * @param options - Configuration options for the collections search tool\n * @returns An XAICollectionsSearchTool object to pass to the model\n *\n * @example Basic usage with collection IDs\n * ```typescript\n * import { ChatXAIResponses, tools } from \"@langchain/xai\";\n *\n * const llm = new ChatXAIResponses({\n *   model: \"grok-4-1-fast\",\n * });\n *\n * const collectionsSearch = tools.xaiCollectionsSearch({\n *   vectorStoreIds: [\"collection_abc123\"],\n * });\n *\n * const result = await llm.invoke(\n *   \"What are the key findings in the Q3 report?\",\n *   { tools: [collectionsSearch] }\n * );\n * ```\n *\n * @example Combining with other tools for hybrid analysis\n * ```typescript\n * const collectionsSearch = tools.xaiCollectionsSearch({\n *   vectorStoreIds: [\"collection_sec_filings\"],\n * });\n * const webSearch = tools.xaiWebSearch();\n * const codeExecution = tools.xaiCodeExecution();\n *\n * const result = await llm.invoke(\n *   \"Based on our internal SEC filings, what is the market sentiment on our performance?\",\n *   { tools: [collectionsSearch, webSearch, codeExecution] }\n * );\n * ```\n */\nexport declare function xaiCollectionsSearch(options?: XAICollectionsSearchToolOptions): XAICollectionsSearchTool;\n//# sourceMappingURL=collections_search.d.ts.map"],"mappings":";;AAIA;AAaA;AAgBA;AAoDwBG,cAjFHH,gCAAAA,GAiFkCE,aAAAA;;;;;;;;;;;;;UApEtCD,wBAAAA;;;;eAIAD;;;;;;;;;;;;UAYAE,+BAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDOC,oBAAAA,WAA+BD,kCAAkCD"}

package/dist/tools/collections_search.d.ts

@@ -0,0 +1,90 @@
+//#region src/tools/collections_search.d.ts
+/**
+ * xAI Collections Search tool type constant.
+ * Note: The Responses API uses "file_search" as the type name.
+ */
+declare const XAI_COLLECTIONS_SEARCH_TOOL_TYPE = "file_search";
+/**
+ * xAI's built-in collections search tool interface.
+ * Enables the model to search through uploaded knowledge bases (collections)
+ * to retrieve relevant information from your documents.
+ *
+ * This tool is part of xAI's agentic tool calling API and is particularly
+ * powerful for:
+ * - Document retrieval from uploaded files
+ * - Semantic search across knowledge bases
+ * - RAG (Retrieval-Augmented Generation) applications
+ * - Enterprise knowledge base queries
+ */
+interface XAICollectionsSearchTool {
+  /**
+   * The type of the tool. Must be "file_search".
+   */
+  type: typeof XAI_COLLECTIONS_SEARCH_TOOL_TYPE;
+  /**
+   * List of vector store (collection) IDs to search.
+   * These are the IDs of collections created via the xAI Collections API.
+   */
+  vector_store_ids?: string[];
+}
+/**
+ * Options for the xAI collections search tool (camelCase).
+ * All fields are camel-cased for the TypeScript API and are mapped to the
+ * corresponding snake_case fields in the API request.
+ */
+interface XAICollectionsSearchToolOptions {
+  /**
+   * List of vector store (collection) IDs to search.
+   * These are the IDs of collections created via the xAI Collections API.
+   *
+   * @example ["collection_abc123", "collection_def456"]
+   */
+  vectorStoreIds?: string[];
+}
+/**
+ * Creates an xAI collections search tool.
+ * Enables the model to search through your uploaded knowledge bases (collections)
+ * to retrieve relevant information from your documents.
+ *
+ * This tool is executed server-side by the xAI API as part of the agentic
+ * tool calling workflow.
+ *
+ * @param options - Configuration options for the collections search tool
+ * @returns An XAICollectionsSearchTool object to pass to the model
+ *
+ * @example Basic usage with collection IDs
+ * ```typescript
+ * import { ChatXAIResponses, tools } from "@langchain/xai";
+ *
+ * const llm = new ChatXAIResponses({
+ *   model: "grok-4-1-fast",
+ * });
+ *
+ * const collectionsSearch = tools.xaiCollectionsSearch({
+ *   vectorStoreIds: ["collection_abc123"],
+ * });
+ *
+ * const result = await llm.invoke(
+ *   "What are the key findings in the Q3 report?",
+ *   { tools: [collectionsSearch] }
+ * );
+ * ```
+ *
+ * @example Combining with other tools for hybrid analysis
+ * ```typescript
+ * const collectionsSearch = tools.xaiCollectionsSearch({
+ *   vectorStoreIds: ["collection_sec_filings"],
+ * });
+ * const webSearch = tools.xaiWebSearch();
+ * const codeExecution = tools.xaiCodeExecution();
+ *
+ * const result = await llm.invoke(
+ *   "Based on our internal SEC filings, what is the market sentiment on our performance?",
+ *   { tools: [collectionsSearch, webSearch, codeExecution] }
+ * );
+ * ```
+ */
+declare function xaiCollectionsSearch(options?: XAICollectionsSearchToolOptions): XAICollectionsSearchTool;
+//#endregion
+export { XAICollectionsSearchTool, XAICollectionsSearchToolOptions, XAI_COLLECTIONS_SEARCH_TOOL_TYPE, xaiCollectionsSearch };
+//# sourceMappingURL=collections_search.d.ts.map

package/dist/tools/collections_search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections_search.d.ts","names":["XAI_COLLECTIONS_SEARCH_TOOL_TYPE","XAICollectionsSearchTool","XAICollectionsSearchToolOptions","xaiCollectionsSearch"],"sources":["../../src/tools/collections_search.d.ts"],"sourcesContent":["/**\n * xAI Collections Search tool type constant.\n * Note: The Responses API uses \"file_search\" as the type name.\n */\nexport declare const XAI_COLLECTIONS_SEARCH_TOOL_TYPE = \"file_search\";\n/**\n * xAI's built-in collections search tool interface.\n * Enables the model to search through uploaded knowledge bases (collections)\n * to retrieve relevant information from your documents.\n *\n * This tool is part of xAI's agentic tool calling API and is particularly\n * powerful for:\n * - Document retrieval from uploaded files\n * - Semantic search across knowledge bases\n * - RAG (Retrieval-Augmented Generation) applications\n * - Enterprise knowledge base queries\n */\nexport interface XAICollectionsSearchTool {\n    /**\n     * The type of the tool. Must be \"file_search\".\n     */\n    type: typeof XAI_COLLECTIONS_SEARCH_TOOL_TYPE;\n    /**\n     * List of vector store (collection) IDs to search.\n     * These are the IDs of collections created via the xAI Collections API.\n     */\n    vector_store_ids?: string[];\n}\n/**\n * Options for the xAI collections search tool (camelCase).\n * All fields are camel-cased for the TypeScript API and are mapped to the\n * corresponding snake_case fields in the API request.\n */\nexport interface XAICollectionsSearchToolOptions {\n    /**\n     * List of vector store (collection) IDs to search.\n     * These are the IDs of collections created via the xAI Collections API.\n     *\n     * @example [\"collection_abc123\", \"collection_def456\"]\n     */\n    vectorStoreIds?: string[];\n}\n/**\n * Creates an xAI collections search tool.\n * Enables the model to search through your uploaded knowledge bases (collections)\n * to retrieve relevant information from your documents.\n *\n * This tool is executed server-side by the xAI API as part of the agentic\n * tool calling workflow.\n *\n * @param options - Configuration options for the collections search tool\n * @returns An XAICollectionsSearchTool object to pass to the model\n *\n * @example Basic usage with collection IDs\n * ```typescript\n * import { ChatXAIResponses, tools } from \"@langchain/xai\";\n *\n * const llm = new ChatXAIResponses({\n *   model: \"grok-4-1-fast\",\n * });\n *\n * const collectionsSearch = tools.xaiCollectionsSearch({\n *   vectorStoreIds: [\"collection_abc123\"],\n * });\n *\n * const result = await llm.invoke(\n *   \"What are the key findings in the Q3 report?\",\n *   { tools: [collectionsSearch] }\n * );\n * ```\n *\n * @example Combining with other tools for hybrid analysis\n * ```typescript\n * const collectionsSearch = tools.xaiCollectionsSearch({\n *   vectorStoreIds: [\"collection_sec_filings\"],\n * });\n * const webSearch = tools.xaiWebSearch();\n * const codeExecution = tools.xaiCodeExecution();\n *\n * const result = await llm.invoke(\n *   \"Based on our internal SEC filings, what is the market sentiment on our performance?\",\n *   { tools: [collectionsSearch, webSearch, codeExecution] }\n * );\n * ```\n */\nexport declare function xaiCollectionsSearch(options?: XAICollectionsSearchToolOptions): XAICollectionsSearchTool;\n//# sourceMappingURL=collections_search.d.ts.map"],"mappings":";;AAIA;AAaA;AAgBA;AAoDwBG,cAjFHH,gCAAAA,GAiFkCE,aAAAA;;;;;;;;;;;;;UApEtCD,wBAAAA;;;;eAIAD;;;;;;;;;;;;UAYAE,+BAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDOC,oBAAAA,WAA+BD,kCAAkCD"}

package/dist/tools/collections_search.js

@@ -0,0 +1,58 @@
+//#region src/tools/collections_search.ts
+/**
+* xAI Collections Search tool type constant.
+* Note: The Responses API uses "file_search" as the type name.
+*/
+const XAI_COLLECTIONS_SEARCH_TOOL_TYPE = "file_search";
+/**
+* Creates an xAI collections search tool.
+* Enables the model to search through your uploaded knowledge bases (collections)
+* to retrieve relevant information from your documents.
+*
+* This tool is executed server-side by the xAI API as part of the agentic
+* tool calling workflow.
+*
+* @param options - Configuration options for the collections search tool
+* @returns An XAICollectionsSearchTool object to pass to the model
+*
+* @example Basic usage with collection IDs
+* ```typescript
+* import { ChatXAIResponses, tools } from "@langchain/xai";
+*
+* const llm = new ChatXAIResponses({
+*   model: "grok-4-1-fast",
+* });
+*
+* const collectionsSearch = tools.xaiCollectionsSearch({
+*   vectorStoreIds: ["collection_abc123"],
+* });
+*
+* const result = await llm.invoke(
+*   "What are the key findings in the Q3 report?",
+*   { tools: [collectionsSearch] }
+* );
+* ```
+*
+* @example Combining with other tools for hybrid analysis
+* ```typescript
+* const collectionsSearch = tools.xaiCollectionsSearch({
+*   vectorStoreIds: ["collection_sec_filings"],
+* });
+* const webSearch = tools.xaiWebSearch();
+* const codeExecution = tools.xaiCodeExecution();
+*
+* const result = await llm.invoke(
+*   "Based on our internal SEC filings, what is the market sentiment on our performance?",
+*   { tools: [collectionsSearch, webSearch, codeExecution] }
+* );
+* ```
+*/
+function xaiCollectionsSearch(options = {}) {
+	const tool = { type: XAI_COLLECTIONS_SEARCH_TOOL_TYPE };
+	if (options.vectorStoreIds !== void 0) tool.vector_store_ids = options.vectorStoreIds;
+	return tool;
+}
+
+//#endregion
+export { XAI_COLLECTIONS_SEARCH_TOOL_TYPE, xaiCollectionsSearch };
+//# sourceMappingURL=collections_search.js.map

package/dist/tools/collections_search.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections_search.js","names":["options: XAICollectionsSearchToolOptions","tool: XAICollectionsSearchTool"],"sources":["../../src/tools/collections_search.ts"],"sourcesContent":["/**\n * xAI Collections Search tool type constant.\n * Note: The Responses API uses \"file_search\" as the type name.\n */\nexport const XAI_COLLECTIONS_SEARCH_TOOL_TYPE = \"file_search\";\n\n/**\n * xAI's built-in collections search tool interface.\n * Enables the model to search through uploaded knowledge bases (collections)\n * to retrieve relevant information from your documents.\n *\n * This tool is part of xAI's agentic tool calling API and is particularly\n * powerful for:\n * - Document retrieval from uploaded files\n * - Semantic search across knowledge bases\n * - RAG (Retrieval-Augmented Generation) applications\n * - Enterprise knowledge base queries\n */\nexport interface XAICollectionsSearchTool {\n  /**\n   * The type of the tool. Must be \"file_search\".\n   */\n  type: typeof XAI_COLLECTIONS_SEARCH_TOOL_TYPE;\n  /**\n   * List of vector store (collection) IDs to search.\n   * These are the IDs of collections created via the xAI Collections API.\n   */\n  vector_store_ids?: string[];\n}\n\n/**\n * Options for the xAI collections search tool (camelCase).\n * All fields are camel-cased for the TypeScript API and are mapped to the\n * corresponding snake_case fields in the API request.\n */\nexport interface XAICollectionsSearchToolOptions {\n  /**\n   * List of vector store (collection) IDs to search.\n   * These are the IDs of collections created via the xAI Collections API.\n   *\n   * @example [\"collection_abc123\", \"collection_def456\"]\n   */\n  vectorStoreIds?: string[];\n}\n\n/**\n * Creates an xAI collections search tool.\n * Enables the model to search through your uploaded knowledge bases (collections)\n * to retrieve relevant information from your documents.\n *\n * This tool is executed server-side by the xAI API as part of the agentic\n * tool calling workflow.\n *\n * @param options - Configuration options for the collections search tool\n * @returns An XAICollectionsSearchTool object to pass to the model\n *\n * @example Basic usage with collection IDs\n * ```typescript\n * import { ChatXAIResponses, tools } from \"@langchain/xai\";\n *\n * const llm = new ChatXAIResponses({\n *   model: \"grok-4-1-fast\",\n * });\n *\n * const collectionsSearch = tools.xaiCollectionsSearch({\n *   vectorStoreIds: [\"collection_abc123\"],\n * });\n *\n * const result = await llm.invoke(\n *   \"What are the key findings in the Q3 report?\",\n *   { tools: [collectionsSearch] }\n * );\n * ```\n *\n * @example Combining with other tools for hybrid analysis\n * ```typescript\n * const collectionsSearch = tools.xaiCollectionsSearch({\n *   vectorStoreIds: [\"collection_sec_filings\"],\n * });\n * const webSearch = tools.xaiWebSearch();\n * const codeExecution = tools.xaiCodeExecution();\n *\n * const result = await llm.invoke(\n *   \"Based on our internal SEC filings, what is the market sentiment on our performance?\",\n *   { tools: [collectionsSearch, webSearch, codeExecution] }\n * );\n * ```\n */\nexport function xaiCollectionsSearch(\n  options: XAICollectionsSearchToolOptions = {}\n): XAICollectionsSearchTool {\n  const tool: XAICollectionsSearchTool = {\n    type: XAI_COLLECTIONS_SEARCH_TOOL_TYPE,\n  };\n\n  if (options.vectorStoreIds !== undefined) {\n    tool.vector_store_ids = options.vectorStoreIds;\n  }\n\n  return tool;\n}\n"],"mappings":";;;;;AAIA,MAAa,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFhD,SAAgB,qBACdA,UAA2C,CAAE,GACnB;CAC1B,MAAMC,OAAiC,EACrC,MAAM,iCACP;AAED,KAAI,QAAQ,mBAAmB,QAC7B,KAAK,mBAAmB,QAAQ;AAGlC,QAAO;AACR"}

package/dist/tools/index.cjs

@@ -1,7 +1,17 @@
 const require_live_search = require('./live_search.cjs');
+const require_web_search = require('./web_search.cjs');
+const require_x_search = require('./x_search.cjs');
+const require_code_execution = require('./code_execution.cjs');
+const require_collections_search = require('./collections_search.cjs');
 
 //#region src/tools/index.ts
-const tools = { xaiLiveSearch: require_live_search.xaiLiveSearch };
+const tools = {
+	xaiLiveSearch: require_live_search.xaiLiveSearch,
+	xaiWebSearch: require_web_search.xaiWebSearch,
+	xaiXSearch: require_x_search.xaiXSearch,
+	xaiCodeExecution: require_code_execution.xaiCodeExecution,
+	xaiCollectionsSearch: require_collections_search.xaiCollectionsSearch
+};
 
 //#endregion
 exports.tools = tools;

package/dist/tools/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/tools/index.ts"],"sourcesContent":["import { xaiLiveSearch } from \"./live_search.js\";\n\nexport const tools = {\n  xaiLiveSearch,\n};\n"],"mappings":";;;AAEA,MAAa,QAAQ,EACnB,iDACD"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/tools/index.ts"],"sourcesContent":["import { xaiLiveSearch } from \"./live_search.js\";\nimport { xaiWebSearch } from \"./web_search.js\";\nimport { xaiXSearch } from \"./x_search.js\";\nimport { xaiCodeExecution } from \"./code_execution.js\";\nimport { xaiCollectionsSearch } from \"./collections_search.js\";\n\nexport const tools = {\n  /** @deprecated Use xaiWebSearch and xaiXSearch instead */\n  xaiLiveSearch,\n  xaiWebSearch,\n  xaiXSearch,\n  xaiCodeExecution,\n  xaiCollectionsSearch,\n};\n\n// Re-export types for convenience\nexport type {\n  XAILiveSearchTool,\n  XAILiveSearchToolOptions,\n} from \"./live_search.js\";\nexport type {\n  XAIWebSearchTool,\n  XAIWebSearchToolOptions,\n} from \"./web_search.js\";\nexport type { XAIXSearchTool, XAIXSearchToolOptions } from \"./x_search.js\";\nexport type { XAICodeExecutionTool } from \"./code_execution.js\";\nexport type {\n  XAICollectionsSearchTool,\n  XAICollectionsSearchToolOptions,\n} from \"./collections_search.js\";\n\n// Re-export tool type constants\nexport {\n  XAI_LIVE_SEARCH_TOOL_TYPE,\n  XAI_LIVE_SEARCH_TOOL_NAME,\n} from \"./live_search.js\";\nexport { XAI_WEB_SEARCH_TOOL_TYPE } from \"./web_search.js\";\nexport { XAI_X_SEARCH_TOOL_TYPE } from \"./x_search.js\";\nexport { XAI_CODE_EXECUTION_TOOL_TYPE } from \"./code_execution.js\";\nexport { XAI_COLLECTIONS_SEARCH_TOOL_TYPE } from \"./collections_search.js\";\n"],"mappings":";;;;;;;AAMA,MAAa,QAAQ;CAEnB;CACA;CACA;CACA;CACA;AACD"}

package/dist/tools/index.d.cts

@@ -1,8 +1,17 @@
-import { xaiLiveSearch } from "./live_search.cjs";
+import { XAILiveSearchTool, XAILiveSearchToolOptions, XAI_LIVE_SEARCH_TOOL_NAME, XAI_LIVE_SEARCH_TOOL_TYPE, xaiLiveSearch } from "./live_search.cjs";
+import { XAIWebSearchTool, XAIWebSearchToolOptions, XAI_WEB_SEARCH_TOOL_TYPE, xaiWebSearch } from "./web_search.cjs";
+import { XAIXSearchTool, XAIXSearchToolOptions, XAI_X_SEARCH_TOOL_TYPE, xaiXSearch } from "./x_search.cjs";
+import { XAICodeExecutionTool, XAI_CODE_EXECUTION_TOOL_TYPE, xaiCodeExecution } from "./code_execution.cjs";
+import { XAICollectionsSearchTool, XAICollectionsSearchToolOptions, XAI_COLLECTIONS_SEARCH_TOOL_TYPE, xaiCollectionsSearch } from "./collections_search.cjs";
 
 //#region src/tools/index.d.ts
 declare const tools: {
+  /** @deprecated Use xaiWebSearch and xaiXSearch instead */
   xaiLiveSearch: typeof xaiLiveSearch;
+  xaiWebSearch: typeof xaiWebSearch;
+  xaiXSearch: typeof xaiXSearch;
+  xaiCodeExecution: typeof xaiCodeExecution;
+  xaiCollectionsSearch: typeof xaiCollectionsSearch;
 };
 //#endregion
 export { tools };