@wingman-ai/gateway 0.4.2 → 0.4.4

package/README.md

@@ -222,6 +222,20 @@ cd apps/wingman
 bun run test
 ```
 
+### Terminal Bench
+
+```bash
+cd apps/wingman
+bun run bench:terminal:smoke
+bun run bench:terminal:quick
+bun run bench:terminal
+bun run bench:terminal:official
+bun run bench:terminal:official:wingman
+bun run bench:terminal:baseline
+```
+
+See `apps/wingman/docs/terminal-bench.md` for config, scoring, and artifacts.
+
 ### Config and Logs
 
 - Config: `apps/wingman/.wingman/wingman.config.json`

package/dist/agent/config/mcpClientManager.cjs

@@ -156,6 +156,56 @@ class MCPClientManager {
             return [];
         }
     }
+    async listResources(serverNames) {
+        if (!this.client) {
+            this.logger.debug("No MCP client initialized, returning empty resources map");
+            return {};
+        }
+        const targets = normalizeServerNames(serverNames);
+        try {
+            const resources = targets.length > 0 ? await this.client.listResources(...targets) : await this.client.listResources();
+            return Object.fromEntries(Object.entries(resources).map(([serverName, serverResources])=>[
+                    serverName,
+                    serverResources.map((resource)=>normalizeResource(resource))
+                ]));
+        } catch (error) {
+            this.logger.error(`Failed to list MCP resources: ${error instanceof Error ? error.message : String(error)}`);
+            return {};
+        }
+    }
+    async listResourceTemplates(serverNames) {
+        if (!this.client) {
+            this.logger.debug("No MCP client initialized, returning empty resource template map");
+            return {};
+        }
+        const targets = normalizeServerNames(serverNames);
+        try {
+            const templates = targets.length > 0 ? await this.client.listResourceTemplates(...targets) : await this.client.listResourceTemplates();
+            return Object.fromEntries(Object.entries(templates).map(([serverName, serverTemplates])=>[
+                    serverName,
+                    serverTemplates.map((template)=>normalizeResourceTemplate(template))
+                ]));
+        } catch (error) {
+            this.logger.error(`Failed to list MCP resource templates: ${error instanceof Error ? error.message : String(error)}`);
+            return {};
+        }
+    }
+    async readResource(serverName, uri) {
+        if (!this.client) {
+            this.logger.debug("No MCP client initialized, returning empty resource content");
+            return [];
+        }
+        const normalizedServer = serverName.trim();
+        const normalizedUri = uri.trim();
+        if (!normalizedServer || !normalizedUri) return [];
+        try {
+            const content = await this.client.readResource(normalizedServer, normalizedUri);
+            return content.map((block)=>normalizeResourceContent(block, normalizedUri));
+        } catch (error) {
+            this.logger.error(`Failed to read MCP resource ${normalizedUri} from ${normalizedServer}: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    }
     sanitizeToolNames(tools) {
         const used = new Map();
         const sanitize = (name)=>{
@@ -199,10 +249,12 @@ class MCPClientManager {
         if (!this.client) return;
         try {
             this.logger.debug("Cleaning up MCP client");
-            this.client = null;
+            await this.client.close();
             this.logger.debug("MCP client cleanup complete");
         } catch (error) {
             this.logger.warn(`Error during MCP cleanup: ${error instanceof Error ? error.message : String(error)}`);
+        } finally{
+            this.client = null;
         }
     }
     hasServers() {
@@ -232,6 +284,57 @@ function getDefaultToolTimeout(server) {
     if (!Number.isFinite(candidate) || candidate <= 0) return;
     return Math.floor(candidate);
 }
+function normalizeServerNames(serverNames) {
+    if (!serverNames) return [];
+    const seen = new Set();
+    const normalized = [];
+    for (const name of serverNames){
+        const trimmed = name.trim();
+        if (!(!trimmed || seen.has(trimmed))) {
+            seen.add(trimmed);
+            normalized.push(trimmed);
+        }
+    }
+    return normalized;
+}
+function normalizeResource(value) {
+    return {
+        uri: value.uri,
+        name: value.name || value.uri,
+        ...value.description ? {
+            description: value.description
+        } : {},
+        ...value.mimeType ? {
+            mimeType: value.mimeType
+        } : {}
+    };
+}
+function normalizeResourceTemplate(value) {
+    return {
+        uriTemplate: value.uriTemplate,
+        name: value.name || value.uriTemplate,
+        ...value.description ? {
+            description: value.description
+        } : {},
+        ...value.mimeType ? {
+            mimeType: value.mimeType
+        } : {}
+    };
+}
+function normalizeResourceContent(value, defaultUri) {
+    return {
+        uri: value.uri || defaultUri,
+        ...value.mimeType ? {
+            mimeType: value.mimeType
+        } : {},
+        ..."string" == typeof value.text ? {
+            text: value.text
+        } : {},
+        ..."string" == typeof value.blob ? {
+            blob: value.blob
+        } : {}
+    };
+}
 exports.MCPClientManager = __webpack_exports__.MCPClientManager;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "MCPClientManager"

package/dist/agent/config/mcpClientManager.d.ts

@@ -1,6 +1,24 @@
 import type { StructuredTool } from "@langchain/core/tools";
 import type { Logger } from "@/logger.js";
 import type { MCPServersConfig } from "@/types/mcp.js";
+export type MCPResourceDescriptor = {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+};
+export type MCPResourceTemplateDescriptor = {
+    uriTemplate: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+};
+export type MCPResourceContentDescriptor = {
+    uri: string;
+    mimeType?: string;
+    text?: string;
+    blob?: string;
+};
 export type MCPProxyConfig = {
     enabled?: boolean;
     command?: string;
@@ -44,6 +62,18 @@ export declare class MCPClientManager {
      * Returns LangChain StructuredTools ready for agent use
      */
     getTools(): Promise<StructuredTool[]>;
+    /**
+     * List MCP resources exposed by configured servers.
+     */
+    listResources(serverNames?: string[]): Promise<Record<string, MCPResourceDescriptor[]>>;
+    /**
+     * List MCP resource templates exposed by configured servers.
+     */
+    listResourceTemplates(serverNames?: string[]): Promise<Record<string, MCPResourceTemplateDescriptor[]>>;
+    /**
+     * Read a specific MCP resource from a server.
+     */
+    readResource(serverName: string, uri: string): Promise<MCPResourceContentDescriptor[]>;
     private sanitizeToolNames;
     /**
      * Cleanup MCP client resources

package/dist/agent/config/mcpClientManager.js

@@ -128,6 +128,56 @@ class MCPClientManager {
             return [];
         }
     }
+    async listResources(serverNames) {
+        if (!this.client) {
+            this.logger.debug("No MCP client initialized, returning empty resources map");
+            return {};
+        }
+        const targets = normalizeServerNames(serverNames);
+        try {
+            const resources = targets.length > 0 ? await this.client.listResources(...targets) : await this.client.listResources();
+            return Object.fromEntries(Object.entries(resources).map(([serverName, serverResources])=>[
+                    serverName,
+                    serverResources.map((resource)=>normalizeResource(resource))
+                ]));
+        } catch (error) {
+            this.logger.error(`Failed to list MCP resources: ${error instanceof Error ? error.message : String(error)}`);
+            return {};
+        }
+    }
+    async listResourceTemplates(serverNames) {
+        if (!this.client) {
+            this.logger.debug("No MCP client initialized, returning empty resource template map");
+            return {};
+        }
+        const targets = normalizeServerNames(serverNames);
+        try {
+            const templates = targets.length > 0 ? await this.client.listResourceTemplates(...targets) : await this.client.listResourceTemplates();
+            return Object.fromEntries(Object.entries(templates).map(([serverName, serverTemplates])=>[
+                    serverName,
+                    serverTemplates.map((template)=>normalizeResourceTemplate(template))
+                ]));
+        } catch (error) {
+            this.logger.error(`Failed to list MCP resource templates: ${error instanceof Error ? error.message : String(error)}`);
+            return {};
+        }
+    }
+    async readResource(serverName, uri) {
+        if (!this.client) {
+            this.logger.debug("No MCP client initialized, returning empty resource content");
+            return [];
+        }
+        const normalizedServer = serverName.trim();
+        const normalizedUri = uri.trim();
+        if (!normalizedServer || !normalizedUri) return [];
+        try {
+            const content = await this.client.readResource(normalizedServer, normalizedUri);
+            return content.map((block)=>normalizeResourceContent(block, normalizedUri));
+        } catch (error) {
+            this.logger.error(`Failed to read MCP resource ${normalizedUri} from ${normalizedServer}: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    }
     sanitizeToolNames(tools) {
         const used = new Map();
         const sanitize = (name)=>{
@@ -171,10 +221,12 @@ class MCPClientManager {
         if (!this.client) return;
         try {
             this.logger.debug("Cleaning up MCP client");
-            this.client = null;
+            await this.client.close();
             this.logger.debug("MCP client cleanup complete");
         } catch (error) {
             this.logger.warn(`Error during MCP cleanup: ${error instanceof Error ? error.message : String(error)}`);
+        } finally{
+            this.client = null;
         }
     }
     hasServers() {
@@ -204,4 +256,55 @@ function getDefaultToolTimeout(server) {
     if (!Number.isFinite(candidate) || candidate <= 0) return;
     return Math.floor(candidate);
 }
+function normalizeServerNames(serverNames) {
+    if (!serverNames) return [];
+    const seen = new Set();
+    const normalized = [];
+    for (const name of serverNames){
+        const trimmed = name.trim();
+        if (!(!trimmed || seen.has(trimmed))) {
+            seen.add(trimmed);
+            normalized.push(trimmed);
+        }
+    }
+    return normalized;
+}
+function normalizeResource(value) {
+    return {
+        uri: value.uri,
+        name: value.name || value.uri,
+        ...value.description ? {
+            description: value.description
+        } : {},
+        ...value.mimeType ? {
+            mimeType: value.mimeType
+        } : {}
+    };
+}
+function normalizeResourceTemplate(value) {
+    return {
+        uriTemplate: value.uriTemplate,
+        name: value.name || value.uriTemplate,
+        ...value.description ? {
+            description: value.description
+        } : {},
+        ...value.mimeType ? {
+            mimeType: value.mimeType
+        } : {}
+    };
+}
+function normalizeResourceContent(value, defaultUri) {
+    return {
+        uri: value.uri || defaultUri,
+        ...value.mimeType ? {
+            mimeType: value.mimeType
+        } : {},
+        ..."string" == typeof value.text ? {
+            text: value.text
+        } : {},
+        ..."string" == typeof value.blob ? {
+            blob: value.blob
+        } : {}
+    };
+}
 export { MCPClientManager };

package/dist/agent/config/modelFactory.cjs

@@ -30,6 +30,7 @@ const anthropic_namespaceObject = require("@langchain/anthropic");
 const openai_namespaceObject = require("@langchain/openai");
 const xai_namespaceObject = require("@langchain/xai");
 const codex_cjs_namespaceObject = require("../../providers/codex.cjs");
+const external_xaiImageModel_cjs_namespaceObject = require("./xaiImageModel.cjs");
 const copilot_cjs_namespaceObject = require("../../providers/copilot.cjs");
 const credentials_cjs_namespaceObject = require("../../providers/credentials.cjs");
 const registry_cjs_namespaceObject = require("../../providers/registry.cjs");
@@ -172,6 +173,15 @@ class ModelFactory {
     }
     static createXAIModel(model, options) {
         const token = (0, credentials_cjs_namespaceObject.resolveProviderToken)("xai").token;
+        const provider = (0, registry_cjs_namespaceObject.getProviderSpec)("xai");
+        if ((0, external_xaiImageModel_cjs_namespaceObject.isNativeXAIImageModel)(model)) {
+            if (options.reasoningEffort) ModelFactory.warnUnsupportedReasoningEffort("xai", model, options.reasoningEffort, options.ownerLabel);
+            return new external_xaiImageModel_cjs_namespaceObject.NativeXAIImageModel({
+                model,
+                apiKey: token,
+                baseURL: provider?.baseURL
+            });
+        }
         const params = {
             model,
             temperature: 1

package/dist/agent/config/modelFactory.js

@@ -2,6 +2,7 @@ import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatOpenAI } from "@langchain/openai";
 import { ChatXAI } from "@langchain/xai";
 import { createCodexFetch, resolveCodexAuthFromFile } from "../../providers/codex.js";
+import { NativeXAIImageModel, isNativeXAIImageModel } from "./xaiImageModel.js";
 import { createCopilotFetch } from "../../providers/copilot.js";
 import { resolveProviderToken } from "../../providers/credentials.js";
 import { getProviderSpec, listProviderSpecs, normalizeProviderName } from "../../providers/registry.js";
@@ -144,6 +145,15 @@ class ModelFactory {
     }
     static createXAIModel(model, options) {
         const token = resolveProviderToken("xai").token;
+        const provider = getProviderSpec("xai");
+        if (isNativeXAIImageModel(model)) {
+            if (options.reasoningEffort) ModelFactory.warnUnsupportedReasoningEffort("xai", model, options.reasoningEffort, options.ownerLabel);
+            return new NativeXAIImageModel({
+                model,
+                apiKey: token,
+                baseURL: provider?.baseURL
+            });
+        }
         const params = {
             model,
             temperature: 1

package/dist/agent/config/xaiImageModel.cjs

@@ -0,0 +1,242 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DEFAULT_XAI_BASE_URL: ()=>DEFAULT_XAI_BASE_URL,
+    isNativeXAIImageModel: ()=>isNativeXAIImageModel,
+    NativeXAIImageModel: ()=>NativeXAIImageModel
+});
+const chat_models_namespaceObject = require("@langchain/core/language_models/chat_models");
+const messages_namespaceObject = require("@langchain/core/messages");
+const outputs_namespaceObject = require("@langchain/core/outputs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const DEFAULT_XAI_BASE_URL = "https://api.x.ai/v1";
+const IMAGE_MODEL_NAME_PATTERN = /^grok-imagine-image(?:[-:._].*)?$/i;
+const XAI_IMAGE_PROMPT_MAX_CHARS = 7900;
+function isNativeXAIImageModel(modelName) {
+    return IMAGE_MODEL_NAME_PATTERN.test(modelName.trim());
+}
+function normalizeContentText(content) {
+    if ("string" == typeof content) return content.trim();
+    if (!Array.isArray(content)) return "";
+    const parts = content.map((part)=>{
+        if (!part || "object" != typeof part || Array.isArray(part)) return "";
+        const record = part;
+        return "text" === record.type && "string" == typeof record.text ? record.text.trim() : "";
+    }).filter(Boolean);
+    return parts.join("\n").trim();
+}
+function normalizeRole(message) {
+    const type = "string" == typeof message.type ? message.type : "function" == typeof message._getType ? String(message._getType() ?? "").toLowerCase() : "";
+    return type.toLowerCase();
+}
+function resolveAdditionalKwargs(message) {
+    const direct = message.additional_kwargs;
+    if (direct && "object" == typeof direct && !Array.isArray(direct)) return direct;
+    const kwargs = message.kwargs;
+    if (kwargs && "object" == typeof kwargs && !Array.isArray(kwargs)) {
+        const nested = kwargs.additional_kwargs;
+        if (nested && "object" == typeof nested && !Array.isArray(nested)) return nested;
+    }
+}
+function isHiddenMiddlewarePrompt(message, text) {
+    const additionalKwargs = resolveAdditionalKwargs(message);
+    const uiHidden = additionalKwargs?.ui_hidden === true || additionalKwargs?.uiHidden === true;
+    if (uiHidden) return true;
+    const source = "string" == typeof additionalKwargs?.source ? additionalKwargs.source.toLowerCase() : "";
+    if ("additional-message-middleware" === source) return true;
+    const normalized = text.toLowerCase();
+    return normalized.includes("# confidentiality (internal)") && normalized.includes("current date time (utc)");
+}
+function clampPromptLength(prompt) {
+    if (prompt.length <= XAI_IMAGE_PROMPT_MAX_CHARS) return prompt;
+    return prompt.slice(0, XAI_IMAGE_PROMPT_MAX_CHARS);
+}
+function buildPrompt(messages) {
+    const systemParts = [];
+    const visibleUserParts = [];
+    const fallbackUserParts = [];
+    for (const message of messages){
+        const text = normalizeContentText(message.content);
+        if (!text) continue;
+        const role = normalizeRole(message);
+        if ("system" === role) {
+            systemParts.push(text);
+            continue;
+        }
+        if ("human" === role || "user" === role) {
+            fallbackUserParts.push(text);
+            if (!isHiddenMiddlewarePrompt(message, text)) visibleUserParts.push(text);
+        }
+    }
+    const latestUserPrompt = visibleUserParts[visibleUserParts.length - 1] || fallbackUserParts[fallbackUserParts.length - 1];
+    if (!latestUserPrompt) throw new Error("xAI image generation requires a user prompt.");
+    const systemPrefix = systemParts.join("\n\n").trim();
+    if (!systemPrefix) return clampPromptLength(latestUserPrompt);
+    const userSection = `User request:\n${latestUserPrompt}`;
+    const withSystem = `System instructions:\n${systemPrefix}\n\n${userSection}`;
+    if (withSystem.length <= XAI_IMAGE_PROMPT_MAX_CHARS) return withSystem;
+    const systemPrefixLabel = "System instructions:\n";
+    const userSectionPrefix = `\n\n${userSection}`;
+    const availableSystemChars = XAI_IMAGE_PROMPT_MAX_CHARS - systemPrefixLabel.length - userSectionPrefix.length;
+    if (availableSystemChars <= 0) return clampPromptLength(userSection);
+    const truncatedSystem = systemPrefix.slice(0, availableSystemChars);
+    return `${systemPrefixLabel}${truncatedSystem}${userSectionPrefix}`;
+}
+async function readErrorResponse(response) {
+    const body = await response.text();
+    if (!body.trim()) return `xAI image generation request failed with status ${response.status}.`;
+    try {
+        const parsed = JSON.parse(body);
+        const errorRecord = parsed.error && "object" == typeof parsed.error ? parsed.error : void 0;
+        const message = "string" == typeof errorRecord?.message && errorRecord.message || "string" == typeof parsed.message && parsed.message || "string" == typeof parsed.error && parsed.error;
+        if (message) return `xAI image generation failed: ${message}`;
+    } catch  {}
+    return `xAI image generation failed: ${body}`;
+}
+class NativeXAIImageModel extends chat_models_namespaceObject.BaseChatModel {
+    bindTools(_tools, _options) {
+        return this;
+    }
+    _llmType() {
+        return "xai-image-native";
+    }
+    getLsParams() {
+        return {
+            ls_provider: "xai",
+            ls_model_name: this.model,
+            ls_model_type: "chat"
+        };
+    }
+    invocationParams() {
+        return {
+            provider: "xai",
+            model: this.model,
+            baseURL: this.baseURL,
+            responseFormat: this.responseFormat,
+            size: this.size
+        };
+    }
+    async _generate(messages, options, _runManager) {
+        if (!this.apiKey) throw new Error("Missing xAI credentials. Configure XAI_API_KEY before using grok-imagine-image.");
+        const prompt = buildPrompt(messages);
+        const payload = {
+            model: this.model,
+            prompt,
+            response_format: this.responseFormat
+        };
+        if (this.size) payload.size = this.size;
+        const response = await this.caller.callWithOptions({
+            signal: options.signal
+        }, async ()=>fetch(`${this.baseURL}/images/generations`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify(payload),
+                signal: options.signal
+            }));
+        if (!response.ok) throw new Error(await readErrorResponse(response));
+        const data = await response.json();
+        const first = Array.isArray(data.data) ? data.data[0] : void 0;
+        if (!first) throw new Error("xAI image generation returned no image data.");
+        const imageUrl = "string" == typeof first.url && first.url.trim() ? first.url.trim() : "string" == typeof first.b64_json && first.b64_json.trim() ? `data:${first.mime_type || "image/png"};base64,${first.b64_json.trim()}` : "";
+        if (!imageUrl) throw new Error("xAI image generation response was missing both url and b64_json.");
+        const confirmationText = "Image generated.";
+        const message = new messages_namespaceObject.AIMessage({
+            content: [
+                {
+                    type: "text",
+                    text: confirmationText
+                },
+                {
+                    type: "output_image",
+                    image_url: imageUrl
+                }
+            ],
+            response_metadata: {
+                model: this.model,
+                revised_prompt: first.revised_prompt
+            }
+        });
+        return {
+            generations: [
+                {
+                    text: confirmationText,
+                    message
+                }
+            ],
+            llmOutput: {
+                model: this.model
+            }
+        };
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        const result = await this._generate(messages, options, runManager);
+        const generation = result.generations[0];
+        if (!generation) return;
+        const aiMessage = generation.message;
+        const chunk = new messages_namespaceObject.AIMessageChunk({
+            content: aiMessage.content,
+            additional_kwargs: aiMessage.additional_kwargs,
+            response_metadata: aiMessage.response_metadata
+        });
+        if (generation.text) await runManager?.handleLLMNewToken(generation.text);
+        yield new outputs_namespaceObject.ChatGenerationChunk({
+            text: generation.text || "",
+            message: chunk,
+            generationInfo: generation.generationInfo
+        });
+    }
+    constructor(fields){
+        super(fields), _define_property(this, "model", void 0), _define_property(this, "apiKey", void 0), _define_property(this, "baseURL", void 0), _define_property(this, "size", void 0), _define_property(this, "responseFormat", void 0);
+        this.model = fields.model;
+        this.apiKey = fields.apiKey;
+        this.baseURL = (fields.baseURL || DEFAULT_XAI_BASE_URL).replace(/\/+$/, "");
+        this.size = fields.size;
+        this.responseFormat = fields.responseFormat || "url";
+    }
+}
+exports.DEFAULT_XAI_BASE_URL = __webpack_exports__.DEFAULT_XAI_BASE_URL;
+exports.NativeXAIImageModel = __webpack_exports__.NativeXAIImageModel;
+exports.isNativeXAIImageModel = __webpack_exports__.isNativeXAIImageModel;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_XAI_BASE_URL",
+    "NativeXAIImageModel",
+    "isNativeXAIImageModel"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/config/xaiImageModel.d.ts

@@ -0,0 +1,33 @@
+import type { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { BaseChatModel, type BaseChatModelCallOptions, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
+import { type BaseMessage } from "@langchain/core/messages";
+import { ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
+export declare const DEFAULT_XAI_BASE_URL = "https://api.x.ai/v1";
+type XAIImageResponseFormat = "url" | "b64_json";
+type XAIImageModelInput = BaseChatModelParams & {
+    model: string;
+    apiKey?: string;
+    baseURL?: string;
+    size?: string;
+    responseFormat?: XAIImageResponseFormat;
+};
+export declare function isNativeXAIImageModel(modelName: string): boolean;
+export declare class NativeXAIImageModel extends BaseChatModel<BaseChatModelCallOptions> {
+    model: string;
+    apiKey?: string;
+    baseURL: string;
+    size?: string;
+    responseFormat: XAIImageResponseFormat;
+    constructor(fields: XAIImageModelInput);
+    bindTools(_tools: unknown[], _options?: Record<string, unknown>): NativeXAIImageModel;
+    _llmType(): string;
+    getLsParams(): {
+        ls_provider: string;
+        ls_model_name: string;
+        ls_model_type: "chat";
+    };
+    invocationParams(): Record<string, unknown>;
+    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
+export {};