@nocobase/plugin-ai 2.1.0-beta.25 → 2.1.0-beta.26

package/dist/client/llm-providers/xai/ModelSettings.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import React from 'react';
+export declare const ModelSettingsForm: React.FC;

package/dist/client/llm-providers/xai/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { LLMProviderOptions } from '../../manager/ai-manager';
+export declare const xaiProviderOptions: LLMProviderOptions;

package/dist/externalVersion.js

@@ -8,26 +8,26 @@
  */
 
 module.exports = {
-  "@nocobase/plugin-acl": "2.1.0-beta.25",
-  "@nocobase/plugin-workflow": "2.1.0-beta.25",
-  "@nocobase/client": "2.1.0-beta.25",
-  "@nocobase/utils": "2.1.0-beta.25",
-  "@nocobase/database": "2.1.0-beta.25",
-  "@nocobase/server": "2.1.0-beta.25",
-  "@nocobase/plugin-file-manager": "2.1.0-beta.25",
-  "@nocobase/actions": "2.1.0-beta.25",
-  "@nocobase/ai": "2.1.0-beta.25",
+  "@nocobase/plugin-acl": "2.1.0-beta.26",
+  "@nocobase/plugin-workflow": "2.1.0-beta.26",
+  "@nocobase/client": "2.1.0-beta.26",
+  "@nocobase/utils": "2.1.0-beta.26",
+  "@nocobase/database": "2.1.0-beta.26",
+  "@nocobase/server": "2.1.0-beta.26",
+  "@nocobase/plugin-file-manager": "2.1.0-beta.26",
+  "@nocobase/actions": "2.1.0-beta.26",
+  "@nocobase/ai": "2.1.0-beta.26",
   "langchain": "1.2.24",
   "react": "18.2.0",
   "antd": "5.24.2",
   "@formily/core": "2.3.7",
   "@formily/react": "2.3.7",
-  "@nocobase/flow-engine": "2.1.0-beta.25",
+  "@nocobase/flow-engine": "2.1.0-beta.26",
   "@ant-design/icons": "5.6.1",
   "@formily/antd-v5": "1.2.3",
   "react-router-dom": "6.30.1",
   "@formily/shared": "2.3.7",
-  "@nocobase/client-v2": "2.1.0-beta.25",
+  "@nocobase/client-v2": "2.1.0-beta.26",
   "@formily/reactive": "2.3.7",
   "lodash": "4.18.1",
   "@langchain/core": "1.1.24",
@@ -38,14 +38,14 @@ module.exports = {
   "@langchain/deepseek": "1.0.11",
   "@langchain/google-genai": "2.1.18",
   "@langchain/ollama": "1.2.2",
-  "@nocobase/acl": "2.1.0-beta.25",
-  "@nocobase/resourcer": "2.1.0-beta.25",
+  "@nocobase/acl": "2.1.0-beta.26",
+  "@nocobase/resourcer": "2.1.0-beta.26",
   "@emotion/css": "11.13.0",
   "dayjs": "1.11.13",
   "react-i18next": "11.18.6",
-  "@nocobase/plugin-data-source-manager": "2.1.0-beta.25",
+  "@nocobase/plugin-data-source-manager": "2.1.0-beta.26",
   "ahooks": "3.7.8",
   "@langchain/langgraph-checkpoint": "1.0.0",
-  "@nocobase/data-source-manager": "2.1.0-beta.25",
+  "@nocobase/data-source-manager": "2.1.0-beta.26",
   "react-dom": "18.2.0"
 };

package/dist/node_modules/@langchain/xai/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) LangChain, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/node_modules/@langchain/xai/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,25 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/node_modules/@langchain/xai/dist/chat_models/completions.cjs

@@ -0,0 +1,568 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_live_search = require('../live_search.cjs');
+const require_profiles = require('../profiles.cjs');
+const require_live_search$1 = require('../tools/live_search.cjs');
+const __langchain_core_utils_function_calling = require_rolldown_runtime.__toESM(require("@langchain/core/utils/function_calling"));
+const __langchain_core_utils_env = require_rolldown_runtime.__toESM(require("@langchain/core/utils/env"));
+const __langchain_openai = require_rolldown_runtime.__toESM(require("@langchain/openai"));
+
+//#region src/chat_models/completions.ts
+/**
+* Set of all supported xAI built-in server-side tool types.
+* This allows us to easily extend support for future built-in tools
+* without changing the core detection logic.
+*/
+const XAI_BUILT_IN_TOOL_TYPES = new Set([require_live_search$1.XAI_LIVE_SEARCH_TOOL_TYPE]);
+/**
+* Checks if a tool is an xAI built-in tool (like live_search).
+* Built-in tools are executed server-side by the xAI API.
+*
+* @param tool - The tool to check
+* @returns true if the tool is an xAI built-in tool
+*/
+function isXAIBuiltInTool(tool) {
+	return typeof tool === "object" && tool !== null && "type" in tool && typeof tool.type === "string" && XAI_BUILT_IN_TOOL_TYPES.has(tool.type);
+}
+/**
+* xAI chat model integration.
+*
+* The xAI API is compatible to the OpenAI API with some limitations.
+*
+* Setup:
+* Install `@langchain/xai` and set an environment variable named `XAI_API_KEY`.
+*
+* ```bash
+* npm install @langchain/xai
+* export XAI_API_KEY="your-api-key"
+* ```
+*
+* ## [Constructor args](https://api.js.langchain.com/classes/_langchain_xai.ChatXAI.html#constructor)
+*
+* ## [Runtime args](https://api.js.langchain.com/interfaces/_langchain_xai.ChatXAICallOptions.html)
+*
+* Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.
+* They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:
+*
+* ```typescript
+* // When calling `.withConfig`, call options should be passed via the first argument
+* const llmWithArgsBound = llm.withConfig({
+*   stop: ["\n"],
+*   tools: [...],
+* });
+*
+* // When calling `.bindTools`, call options should be passed via the second argument
+* const llmWithTools = llm.bindTools(
+*   [...],
+*   {
+*     tool_choice: "auto",
+*   }
+* );
+* ```
+*
+* ## Examples
+*
+* <details open>
+* <summary><strong>Instantiate</strong></summary>
+*
+* ```typescript
+* import { ChatXAI } from '@langchain/xai';
+*
+* const llm = new ChatXAI({
+*   model: "grok-beta",
+*   temperature: 0,
+*   // other params...
+* });
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Invoking</strong></summary>
+*
+* ```typescript
+* const input = `Translate "I love programming" into French.`;
+*
+* // Models also accept a list of chat messages or a formatted prompt
+* const result = await llm.invoke(input);
+* console.log(result);
+* ```
+*
+* ```txt
+* AIMessage {
+*   "content": "The French translation of \"I love programming\" is \"J'aime programmer\". In this sentence, \"J'aime\" is the first person singular conjugation of the French verb \"aimer\" which means \"to love\", and \"programmer\" is the French infinitive for \"to program\". I hope this helps! Let me know if you have any other questions.",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "tokenUsage": {
+*       "completionTokens": 82,
+*       "promptTokens": 20,
+*       "totalTokens": 102
+*     },
+*     "finish_reason": "stop"
+*   },
+*   "tool_calls": [],
+*   "invalid_tool_calls": []
+* }
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Streaming Chunks</strong></summary>
+*
+* ```typescript
+* for await (const chunk of await llm.stream(input)) {
+*   console.log(chunk);
+* }
+* ```
+*
+* ```txt
+* AIMessageChunk {
+*   "content": "",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "finishReason": null
+*   },
+*   "tool_calls": [],
+*   "tool_call_chunks": [],
+*   "invalid_tool_calls": []
+* }
+* AIMessageChunk {
+*   "content": "The",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "finishReason": null
+*   },
+*   "tool_calls": [],
+*   "tool_call_chunks": [],
+*   "invalid_tool_calls": []
+* }
+* AIMessageChunk {
+*   "content": " French",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "finishReason": null
+*   },
+*   "tool_calls": [],
+*   "tool_call_chunks": [],
+*   "invalid_tool_calls": []
+* }
+* AIMessageChunk {
+*   "content": " translation",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "finishReason": null
+*   },
+*   "tool_calls": [],
+*   "tool_call_chunks": [],
+*   "invalid_tool_calls": []
+* }
+* AIMessageChunk {
+*   "content": " of",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "finishReason": null
+*   },
+*   "tool_calls": [],
+*   "tool_call_chunks": [],
+*   "invalid_tool_calls": []
+* }
+* AIMessageChunk {
+*   "content": " \"",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "finishReason": null
+*   },
+*   "tool_calls": [],
+*   "tool_call_chunks": [],
+*   "invalid_tool_calls": []
+* }
+* AIMessageChunk {
+*   "content": "I",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "finishReason": null
+*   },
+*   "tool_calls": [],
+*   "tool_call_chunks": [],
+*   "invalid_tool_calls": []
+* }
+* AIMessageChunk {
+*   "content": " love",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "finishReason": null
+*   },
+*   "tool_calls": [],
+*   "tool_call_chunks": [],
+*   "invalid_tool_calls": []
+* }
+* ...
+* AIMessageChunk {
+*   "content": ".",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "finishReason": null
+*   },
+*   "tool_calls": [],
+*   "tool_call_chunks": [],
+*   "invalid_tool_calls": []
+* }
+* AIMessageChunk {
+*   "content": "",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "finishReason": "stop"
+*   },
+*   "tool_calls": [],
+*   "tool_call_chunks": [],
+*   "invalid_tool_calls": []
+* }
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Aggregate Streamed Chunks</strong></summary>
+*
+* ```typescript
+* import { AIMessageChunk } from '@langchain/core/messages';
+* import { concat } from '@langchain/core/utils/stream';
+*
+* const stream = await llm.stream(input);
+* let full: AIMessageChunk | undefined;
+* for await (const chunk of stream) {
+*   full = !full ? chunk : concat(full, chunk);
+* }
+* console.log(full);
+* ```
+*
+* ```txt
+* AIMessageChunk {
+*   "content": "The French translation of \"I love programming\" is \"J'aime programmer\". In this sentence, \"J'aime\" is the first person singular conjugation of the French verb \"aimer\" which means \"to love\", and \"programmer\" is the French infinitive for \"to program\". I hope this helps! Let me know if you have any other questions.",
+*   "additional_kwargs": {},
+*   "response_metadata": {
+*     "finishReason": "stop"
+*   },
+*   "tool_calls": [],
+*   "tool_call_chunks": [],
+*   "invalid_tool_calls": []
+* }
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Bind tools</strong></summary>
+*
+* ```typescript
+* import { z } from 'zod';
+*
+* const llmForToolCalling = new ChatXAI({
+*   model: "grok-beta",
+*   temperature: 0,
+*   // other params...
+* });
+*
+* const GetWeather = {
+*   name: "GetWeather",
+*   description: "Get the current weather in a given location",
+*   schema: z.object({
+*     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+*   }),
+* }
+*
+* const GetPopulation = {
+*   name: "GetPopulation",
+*   description: "Get the current population in a given location",
+*   schema: z.object({
+*     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+*   }),
+* }
+*
+* const llmWithTools = llmForToolCalling.bindTools([GetWeather, GetPopulation]);
+* const aiMsg = await llmWithTools.invoke(
+*   "Which city is hotter today and which is bigger: LA or NY?"
+* );
+* console.log(aiMsg.tool_calls);
+* ```
+*
+* ```txt
+* [
+*   {
+*     name: 'GetWeather',
+*     args: { location: 'Los Angeles, CA' },
+*     type: 'tool_call',
+*     id: 'call_cd34'
+*   },
+*   {
+*     name: 'GetWeather',
+*     args: { location: 'New York, NY' },
+*     type: 'tool_call',
+*     id: 'call_68rf'
+*   },
+*   {
+*     name: 'GetPopulation',
+*     args: { location: 'Los Angeles, CA' },
+*     type: 'tool_call',
+*     id: 'call_f81z'
+*   },
+*   {
+*     name: 'GetPopulation',
+*     args: { location: 'New York, NY' },
+*     type: 'tool_call',
+*     id: 'call_8byt'
+*   }
+* ]
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Structured Output</strong></summary>
+*
+* ```typescript
+* import { z } from 'zod';
+*
+* const Joke = z.object({
+*   setup: z.string().describe("The setup of the joke"),
+*   punchline: z.string().describe("The punchline to the joke"),
+*   rating: z.number().optional().describe("How funny the joke is, from 1 to 10")
+* }).describe('Joke to tell user.');
+*
+* const structuredLlm = llmForToolCalling.withStructuredOutput(Joke, { name: "Joke" });
+* const jokeResult = await structuredLlm.invoke("Tell me a joke about cats");
+* console.log(jokeResult);
+* ```
+*
+* ```txt
+* {
+*   setup: "Why don't cats play poker in the wild?",
+*   punchline: 'Because there are too many cheetahs.'
+* }
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Server Tool Calling (Live Search)</strong></summary>
+*
+* xAI supports server-side tools that are executed by the API rather than
+* requiring client-side execution. The `live_search` tool enables the model
+* to search the web for real-time information.
+*
+* ```typescript
+* // Method 1: Using the built-in live_search tool
+* const llm = new ChatXAI({
+*   model: "grok-beta",
+*   temperature: 0,
+* });
+*
+* const llmWithSearch = llm.bindTools([{ type: "live_search" }]);
+* const result = await llmWithSearch.invoke("What happened in tech news today?");
+* console.log(result.content);
+* // The model will search the web and include real-time information in its response
+* ```
+*
+* ```typescript
+* // Method 2: Using searchParameters for more control
+* const llm = new ChatXAI({
+*   model: "grok-beta",
+*   searchParameters: {
+*     mode: "auto", // "auto" | "on" | "off"
+*     max_search_results: 5,
+*     from_date: "2024-01-01", // ISO date string
+*     return_citations: true,
+*   }
+* });
+*
+* const result = await llm.invoke("What are the latest AI developments?");
+* ```
+*
+* ```typescript
+* // Method 3: Override search parameters per request
+* const result = await llm.invoke("Find recent news about SpaceX", {
+*   searchParameters: {
+*     mode: "on",
+*     max_search_results: 10,
+*     sources: [
+*       { type: "web", allowed_websites: ["spacex.com", "nasa.gov"] },
+*     ],
+*   }
+* });
+* ```
+* </details>
+*
+* <br />
+*/
+var ChatXAI = class extends __langchain_openai.ChatOpenAICompletions {
+	static lc_name() {
+		return "ChatXAI";
+	}
+	_llmType() {
+		return "xai";
+	}
+	get lc_secrets() {
+		return { apiKey: "XAI_API_KEY" };
+	}
+	lc_serializable = true;
+	lc_namespace = [
+		"langchain",
+		"chat_models",
+		"xai"
+	];
+	/**
+	* Default search parameters for the Live Search API.
+	*/
+	searchParameters;
+	constructor(fields) {
+		const apiKey = fields?.apiKey || (0, __langchain_core_utils_env.getEnvironmentVariable)("XAI_API_KEY");
+		if (!apiKey) throw new Error(`xAI API key not found. Please set the XAI_API_KEY environment variable or provide the key into "apiKey" field.`);
+		super({
+			...fields,
+			model: fields?.model || "grok-beta",
+			apiKey,
+			configuration: { baseURL: fields?.baseURL ?? "https://api.x.ai/v1" }
+		});
+		this.searchParameters = fields?.searchParameters;
+	}
+	toJSON() {
+		const result = super.toJSON();
+		if ("kwargs" in result && typeof result.kwargs === "object" && result.kwargs != null) {
+			delete result.kwargs.openai_api_key;
+			delete result.kwargs.configuration;
+		}
+		return result;
+	}
+	getLsParams(options) {
+		const params = super.getLsParams(options);
+		params.ls_provider = "xai";
+		return params;
+	}
+	/**
+	* Get the effective search parameters, merging defaults with call options.
+	* @param options Call options that may contain search parameters
+	* @returns Merged search parameters or undefined if none are configured
+	*/
+	_getEffectiveSearchParameters(options) {
+		return require_live_search.mergeSearchParams(this.searchParameters, options?.searchParameters);
+	}
+	/**
+	* Check if any built-in tools (like live_search) are in the tools list.
+	* @param tools List of tools to check
+	* @returns true if any built-in tools are present
+	*/
+	_hasBuiltInTools(tools) {
+		return tools?.some(isXAIBuiltInTool) ?? false;
+	}
+	/**
+	* Formats tools to xAI/OpenAI format, preserving provider-specific definitions.
+	*
+	* @param tools The tools to format
+	* @returns The formatted tools
+	*/
+	formatStructuredToolToXAI(tools) {
+		if (!tools || !tools.length) return void 0;
+		return tools.map((tool) => {
+			if ((0, __langchain_core_utils_function_calling.isLangChainTool)(tool) && tool.extras?.providerToolDefinition) return tool.extras.providerToolDefinition;
+			if (isXAIBuiltInTool(tool)) return tool;
+			return (0, __langchain_core_utils_function_calling.convertToOpenAITool)(tool);
+		});
+	}
+	bindTools(tools, kwargs) {
+		return this.withConfig({
+			tools: this.formatStructuredToolToXAI(tools),
+			...kwargs
+		});
+	}
+	/** @internal */
+	invocationParams(options, extra) {
+		const baseParams = super.invocationParams(options, extra);
+		const params = { ...baseParams };
+		const liveSearchTool = options?.tools?.find(isXAIBuiltInTool);
+		const mergedSearchParams = require_live_search.mergeSearchParams(this.searchParameters, options?.searchParameters, liveSearchTool);
+		if (mergedSearchParams) params.search_parameters = require_live_search.buildSearchParametersPayload(mergedSearchParams);
+		return params;
+	}
+	/**
+	* Calls the xAI API with retry logic in case of failures.
+	* @param request The request to send to the xAI API.
+	* @param options Optional configuration for the API call.
+	* @returns The response from the xAI API.
+	*/
+	async completionWithRetry(request, options) {
+		delete request.frequency_penalty;
+		delete request.presence_penalty;
+		delete request.logit_bias;
+		delete request.functions;
+		const newRequestMessages = request.messages.map((msg) => {
+			if (!msg.content) return {
+				...msg,
+				content: ""
+			};
+			return msg;
+		});
+		let filteredTools;
+		if (request.tools) filteredTools = require_live_search.filterXAIBuiltInTools({
+			tools: request.tools,
+			excludedTypes: [require_live_search$1.XAI_LIVE_SEARCH_TOOL_TYPE]
+		});
+		const newRequest = {
+			...request,
+			messages: newRequestMessages,
+			tools: filteredTools
+		};
+		if (newRequest.stream === true) return super.completionWithRetry(newRequest, options);
+		return super.completionWithRetry(newRequest, options);
+	}
+	_convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole) {
+		const messageChunk = super._convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole);
+		const responseMetadata = messageChunk.response_metadata;
+		if (!rawResponse.choices[0]?.finish_reason) {
+			delete responseMetadata.usage;
+			delete messageChunk.usage_metadata;
+		} else messageChunk.usage_metadata = responseMetadata.usage;
+		return messageChunk;
+	}
+	_convertCompletionsMessageToBaseMessage(message, rawResponse) {
+		const langChainMessage = super._convertCompletionsMessageToBaseMessage(message, rawResponse);
+		const additionalKwargs = langChainMessage.additional_kwargs;
+		additionalKwargs.reasoning_content = message.reasoning_content;
+		return langChainMessage;
+	}
+	/**
+	* Return profiling information for the model.
+	*
+	* Provides information about the model's capabilities and constraints,
+	* including token limits, multimodal support, and advanced features like
+	* tool calling and structured output.
+	*
+	* @returns {ModelProfile} An object describing the model's capabilities and constraints
+	*
+	* @example
+	* ```typescript
+	* const model = new ChatXAI({ model: "grok-beta" });
+	* const profile = model.profile;
+	* console.log(profile.maxInputTokens); // 128000
+	* console.log(profile.imageInputs); // true
+	* ```
+	*/
+	get profile() {
+		return require_profiles.default[this.model] ?? {};
+	}
+	withStructuredOutput(outputSchema, config) {
+		const ensuredConfig = { ...config };
+		if (ensuredConfig?.method === void 0) ensuredConfig.method = "functionCalling";
+		return super.withStructuredOutput(outputSchema, ensuredConfig);
+	}
+};
+
+//#endregion
+exports.ChatXAI = ChatXAI;
+exports.isXAIBuiltInTool = isXAIBuiltInTool;
+//# sourceMappingURL=completions.cjs.map