@better-agent/providers 0.1.0-canary.0

package/dist/xai/index.mjs

@@ -0,0 +1,1277 @@
+import { n as extractPassthroughOptions, r as omitNullish, t as baFetch } from "../fetch-CW0dWlVC.mjs";
+import { Events } from "@better-agent/core/events";
+import { BetterAgentError } from "@better-agent/shared/errors";
+import { err, ok } from "@better-agent/shared/neverthrow";
+import { z } from "zod";
+import { safeJsonParse } from "@better-agent/shared/utils";
+import { TOOL_JSON_SCHEMA, isCallableToolDefinition } from "@better-agent/core";
+
+//#region src/xai/client/auth.ts
+const buildXAIHeaders = (config) => {
+	const headers = { ...config.headers ?? {} };
+	if (config.apiKey) headers.Authorization = `Bearer ${config.apiKey}`;
+	return headers;
+};
+
+//#endregion
+//#region src/xai/client/errors.ts
+const mapXAIHttpError = (httpError, ctx) => {
+	if (!httpError) return BetterAgentError.fromCode("UPSTREAM_FAILED", "xAI request failed", { context: { provider: "xai" } }).at({
+		at: ctx.at,
+		data: { path: ctx.path }
+	});
+	const { status, statusText, error } = httpError;
+	const message = error?.message ?? statusText ?? "xAI request failed";
+	const code = String(error?.code ?? error?.type ?? status);
+	return BetterAgentError.fromCode("UPSTREAM_FAILED", message, {
+		status,
+		context: {
+			provider: "xai",
+			upstreamCode: code,
+			raw: error
+		}
+	}).at({
+		at: ctx.at,
+		data: {
+			path: ctx.path,
+			status
+		}
+	});
+};
+
+//#endregion
+//#region src/xai/client/stream.ts
+const unwrapXAIStreamJson = (parsed) => {
+	if (!parsed || typeof parsed !== "object") return parsed;
+	const obj = parsed;
+	if ("data" in obj) return obj.data;
+	if ("value" in obj) return obj.value;
+	return obj;
+};
+
+//#endregion
+//#region src/xai/client/create-client.ts
+const createXAIClient = (config = {}) => {
+	const baseUrl = (config.baseURL ?? "https://api.x.ai").replace(/\/+$/, "");
+	const headers = buildXAIHeaders(config);
+	const post = async (path, body, at, options) => {
+		try {
+			const result = await baFetch(`${baseUrl}${path}`, {
+				method: "POST",
+				body: JSON.stringify(body),
+				headers: {
+					...headers,
+					"Content-Type": "application/json"
+				},
+				signal: options?.signal ?? null,
+				throw: false
+			});
+			if (result.error) return err(mapXAIHttpError(result.error, {
+				at,
+				path
+			}).at({
+				at,
+				data: { path }
+			}));
+			if (!result.data) return err(BetterAgentError.fromCode("UPSTREAM_FAILED", "xAI returned no data", { context: { provider: "xai" } }).at({
+				at,
+				data: { path }
+			}));
+			return ok(result.data);
+		} catch (e) {
+			return err(BetterAgentError.wrap({
+				err: e,
+				message: "xAI request failed",
+				opts: {
+					code: "UPSTREAM_FAILED",
+					context: { provider: "xai" }
+				}
+			}).at({
+				at,
+				data: { path }
+			}));
+		}
+	};
+	const get = async (path, at, options) => {
+		try {
+			const result = await baFetch(`${baseUrl}${path}`, {
+				method: "GET",
+				headers,
+				signal: options?.signal ?? null,
+				throw: false
+			});
+			if (result.error) return err(mapXAIHttpError(result.error, {
+				at,
+				path
+			}).at({
+				at,
+				data: { path }
+			}));
+			if (!result.data) return err(BetterAgentError.fromCode("UPSTREAM_FAILED", "xAI returned no data", { context: { provider: "xai" } }).at({
+				at,
+				data: { path }
+			}));
+			return ok(result.data);
+		} catch (e) {
+			return err(BetterAgentError.wrap({
+				err: e,
+				message: "xAI request failed",
+				opts: {
+					code: "UPSTREAM_FAILED",
+					context: { provider: "xai" }
+				}
+			}).at({
+				at,
+				data: { path }
+			}));
+		}
+	};
+	const del = async (path, at, options) => {
+		try {
+			const result = await baFetch(`${baseUrl}${path}`, {
+				method: "DELETE",
+				headers,
+				signal: options?.signal ?? null,
+				throw: false
+			});
+			if (result.error) return err(mapXAIHttpError(result.error, {
+				at,
+				path
+			}).at({
+				at,
+				data: { path }
+			}));
+			if (!result.data) return err(BetterAgentError.fromCode("UPSTREAM_FAILED", "xAI returned no data", { context: { provider: "xai" } }).at({
+				at,
+				data: { path }
+			}));
+			return ok(result.data);
+		} catch (e) {
+			return err(BetterAgentError.wrap({
+				err: e,
+				message: "xAI request failed",
+				opts: {
+					code: "UPSTREAM_FAILED",
+					context: { provider: "xai" }
+				}
+			}).at({
+				at,
+				data: { path }
+			}));
+		}
+	};
+	const uploadFile = async (path, body, at, options) => {
+		const formData = new FormData();
+		try {
+			const filename = body.filename ?? (typeof File !== "undefined" && body.file instanceof File ? body.file.name : "file");
+			const blob = body.file instanceof Blob ? body.file : new Blob([new Uint8Array(body.file)], { type: body.mimeType ?? "application/octet-stream" });
+			formData.append("purpose", body.purpose ?? "assistants");
+			formData.append("file", blob, filename);
+			const response = await fetch(`${baseUrl}${path}`, {
+				method: "POST",
+				body: formData,
+				headers,
+				signal: options?.signal ?? null
+			});
+			if (!response.ok) {
+				let xaiError;
+				try {
+					xaiError = await response.json();
+				} catch {}
+				return err(mapXAIHttpError({
+					status: response.status,
+					statusText: response.statusText,
+					error: xaiError?.error
+				}, {
+					at,
+					path
+				}));
+			}
+			const data = await response.json();
+			if (!data) return err(BetterAgentError.fromCode("UPSTREAM_FAILED", "xAI returned no data", { context: { provider: "xai" } }).at({
+				at,
+				data: { path }
+			}));
+			return ok(data);
+		} catch (e) {
+			return err(BetterAgentError.wrap({
+				err: e,
+				message: "xAI file upload failed",
+				opts: {
+					code: "UPSTREAM_FAILED",
+					context: { provider: "xai" }
+				}
+			}).at({
+				at,
+				data: { path }
+			}));
+		}
+	};
+	const getBinary = async (path, at, options) => {
+		let response;
+		try {
+			response = await fetch(`${baseUrl}${path}`, {
+				method: "GET",
+				headers,
+				signal: options?.signal ?? null
+			});
+		} catch (e) {
+			return err(BetterAgentError.wrap({
+				err: e,
+				message: "xAI request failed",
+				opts: {
+					code: "UPSTREAM_FAILED",
+					context: { provider: "xai" }
+				}
+			}).at({
+				at,
+				data: { path }
+			}));
+		}
+		if (!response.ok) {
+			let xaiError;
+			try {
+				xaiError = await response.json();
+			} catch {}
+			return err(mapXAIHttpError({
+				status: response.status,
+				statusText: response.statusText,
+				error: xaiError?.error
+			}, {
+				at,
+				path
+			}));
+		}
+		return ok(new Uint8Array(await response.arrayBuffer()));
+	};
+	const streamSSE = async (path, body, at, options) => {
+		let response;
+		try {
+			response = await fetch(`${baseUrl}${path}`, {
+				method: "POST",
+				headers: {
+					...headers,
+					Accept: "text/event-stream",
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify(body),
+				signal: options?.signal ?? null
+			});
+		} catch (e) {
+			return err(BetterAgentError.wrap({
+				err: e,
+				message: "xAI stream request failed",
+				opts: {
+					code: "UPSTREAM_FAILED",
+					context: { provider: "xai" }
+				}
+			}).at({
+				at,
+				data: { path }
+			}));
+		}
+		if (!response.ok || !response.body) {
+			let xaiError;
+			try {
+				xaiError = await response.json();
+			} catch {}
+			return err(mapXAIHttpError({
+				status: response.status,
+				statusText: response.statusText,
+				error: xaiError?.error
+			}, {
+				at,
+				path
+			}));
+		}
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		return ok((async function* () {
+			let buffer = "";
+			try {
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					const chunks = buffer.split("\n\n");
+					buffer = chunks.pop() ?? "";
+					for (const chunk of chunks) {
+						const dataLines = chunk.split("\n").map((line) => line.trim()).filter(Boolean).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+						for (const data of dataLines) {
+							if (!data || data === "[DONE]") continue;
+							const parsed = safeJsonParse(String(unwrapXAIStreamJson(data)));
+							if (parsed.isErr() || !parsed.value || typeof parsed.value !== "object") {
+								yield err(BetterAgentError.fromCode("UPSTREAM_FAILED", "xAI returned an invalid stream event", { context: {
+									provider: "xai",
+									raw: data
+								} }).at({
+									at,
+									data: { path }
+								}));
+								return;
+							}
+							yield ok(parsed.value);
+						}
+					}
+				}
+			} catch (e) {
+				yield err(BetterAgentError.wrap({
+					err: e,
+					message: "xAI stream read failed",
+					opts: {
+						code: "UPSTREAM_FAILED",
+						context: { provider: "xai" }
+					}
+				}).at({
+					at,
+					data: { path }
+				}));
+			} finally {
+				reader.releaseLock();
+			}
+		})());
+	};
+	return {
+		responses: {
+			create: (body, options) => post("/v1/responses", body, "xai.http.responses.create", options),
+			stream: (body, options) => streamSSE("/v1/responses", {
+				...body,
+				stream: true
+			}, "xai.http.responses.stream", options)
+		},
+		images: {
+			create: (body, options) => post("/v1/images/generations", body, "xai.http.images.create", options),
+			edit: (body, options) => post("/v1/images/edits", body, "xai.http.images.edit", options)
+		},
+		files: {
+			upload: (body, options) => uploadFile("/v1/files", body, "xai.http.files.upload", options),
+			list: (options) => get("/v1/files", "xai.http.files.list", options),
+			retrieve: (fileId, options) => get(`/v1/files/${encodeURIComponent(fileId)}`, "xai.http.files.retrieve", options),
+			delete: (fileId, options) => del(`/v1/files/${encodeURIComponent(fileId)}`, "xai.http.files.delete", options),
+			content: (fileId, options) => getBinary(`/v1/files/${encodeURIComponent(fileId)}/content`, "xai.http.files.content", options)
+		}
+	};
+};
+
+//#endregion
+//#region src/xai/images/mappers.ts
+/**
+* Keys explicitly handled by the xAI images mapper.
+* Everything else on the options object is passed through to the API body.
+*/
+const XAI_IMAGE_KNOWN_KEYS = new Set([
+	"input",
+	"tools",
+	"toolChoice",
+	"modalities",
+	"structured_output",
+	"n",
+	"quality",
+	"response_format",
+	"size",
+	"style",
+	"aspect_ratio",
+	"resolution",
+	"user"
+]);
+const toImageDataUrl = (source) => source.kind === "url" ? source.url : `data:${source.mimeType};base64,${source.data}`;
+const parseXAIImagePromptInput = (args) => {
+	const input = args.options.input;
+	if (Array.isArray(input) && input.length > 1) throw BetterAgentError.fromCode("VALIDATION_FAILED", "Image generation supports a single input item", { context: {
+		provider: "xai",
+		model: args.modelId
+	} }).at({ at: "xai.images.map.inputLimit" });
+	const first = Array.isArray(input) ? input[0] : input;
+	if (typeof first === "string") return {
+		prompt: first,
+		images: []
+	};
+	if (!first || typeof first !== "object" || !("type" in first) || first.type !== "message") throw BetterAgentError.fromCode("VALIDATION_FAILED", "xAI image generation requires a prompt string or a single message input.", { context: {
+		provider: "xai",
+		model: args.modelId
+	} }).at({ at: "xai.images.map.inputShape" });
+	if (typeof first.content === "string") return {
+		prompt: first.content,
+		images: []
+	};
+	const promptParts = [];
+	const images = [];
+	for (const part of first.content) {
+		if (part.type === "text") {
+			promptParts.push(part.text);
+			continue;
+		}
+		if (part.type === "image") {
+			images.push(part.source);
+			continue;
+		}
+		throw BetterAgentError.fromCode("VALIDATION_FAILED", "xAI image generation only supports text and image input parts.", { context: {
+			provider: "xai",
+			model: args.modelId
+		} }).at({ at: "xai.images.map.partType" });
+	}
+	return {
+		prompt: promptParts.join("\n"),
+		images
+	};
+};
+function mapToXAIImagesRequest(args) {
+	try {
+		const o = args.options;
+		if ("stream" in o && o.stream) return err(BetterAgentError.fromCode("VALIDATION_FAILED", "Image streaming is not supported by the xAI provider.", { context: {
+			provider: "xai",
+			model: args.modelId
+		} }).at({ at: "xai.images.map.streamUnsupported" }));
+		const parsed = parseXAIImagePromptInput(args);
+		const prompt = parsed.prompt;
+		if (!prompt || prompt.trim().length === 0) return err(BetterAgentError.fromCode("VALIDATION_FAILED", "xAI image generation requires a text prompt.", { context: {
+			provider: "xai",
+			model: args.modelId
+		} }).at({ at: "xai.images.map.prompt" }));
+		const imageOptions = o;
+		if (parsed.images.length === 0) return ok({
+			mode: "generate",
+			body: {
+				...extractPassthroughOptions(imageOptions, XAI_IMAGE_KNOWN_KEYS),
+				model: args.modelId,
+				prompt,
+				...omitNullish({
+					n: imageOptions.n,
+					quality: imageOptions.quality,
+					response_format: imageOptions.response_format,
+					size: imageOptions.size,
+					style: imageOptions.style,
+					user: imageOptions.user
+				})
+			}
+		});
+		const firstImage = parsed.images[0];
+		if (!firstImage) throw BetterAgentError.fromCode("VALIDATION_FAILED", "xAI image generation requires at least one image when editing", { context: {
+			provider: "xai",
+			model: args.modelId
+		} }).at({ at: "xai.images.map.firstImageMissing" });
+		return ok({
+			mode: "edit",
+			body: {
+				...extractPassthroughOptions(imageOptions, XAI_IMAGE_KNOWN_KEYS),
+				model: args.modelId,
+				prompt,
+				...parsed.images.length === 1 ? { image: {
+					type: "image_url",
+					image_url: toImageDataUrl(firstImage)
+				} } : { images: parsed.images.map((image) => ({
+					type: "image_url",
+					image_url: toImageDataUrl(image)
+				})) },
+				...omitNullish({
+					n: imageOptions.n,
+					quality: imageOptions.quality,
+					response_format: imageOptions.response_format,
+					size: imageOptions.size,
+					style: imageOptions.style,
+					aspect_ratio: imageOptions.aspect_ratio,
+					resolution: imageOptions.resolution,
+					user: imageOptions.user
+				})
+			}
+		});
+	} catch (e) {
+		return err(BetterAgentError.wrap({
+			err: e,
+			message: "Failed to map xAI image request",
+			opts: {
+				code: "INTERNAL",
+				context: {
+					provider: "xai",
+					model: args.modelId
+				}
+			}
+		}).at({ at: "xai.images.mapToRequest" }));
+	}
+}
+function mapFromXAIImagesResponse(raw) {
+	const output = (raw.data ?? []).map(outputMapper).filter(isDefined);
+	const usage = typeof raw.usage?.cost_in_usd_ticks === "number" ? { totalTokens: raw.usage.cost_in_usd_ticks } : {};
+	const images = (raw.data ?? []).map((item) => ({ ...omitNullish({
+		url: typeof item.url === "string" ? item.url : void 0,
+		b64_json: typeof item.b64_json === "string" ? item.b64_json : void 0,
+		mime_type: typeof item.mime_type === "string" ? item.mime_type : void 0,
+		revised_prompt: typeof item.revised_prompt === "string" ? item.revised_prompt : void 0
+	}) }));
+	return {
+		output,
+		finishReason: "stop",
+		usage,
+		response: { body: {
+			...raw,
+			normalized: {
+				images,
+				usage: raw.usage
+			}
+		} }
+	};
+}
+function outputMapper(item) {
+	if (!item || typeof item !== "object") return null;
+	const image = item;
+	const url = typeof image.url === "string" ? image.url : null;
+	const b64 = typeof image.b64_json === "string" ? image.b64_json : null;
+	const mimeType = typeof image.mime_type === "string" ? image.mime_type : void 0;
+	const revisedPrompt = typeof image.revised_prompt === "string" ? image.revised_prompt : void 0;
+	if (!url && !b64) return null;
+	if (b64) return {
+		type: "message",
+		role: "assistant",
+		content: [{
+			type: "image",
+			source: {
+				kind: "base64",
+				data: b64,
+				mimeType: mimeType ?? "image/png"
+			},
+			...revisedPrompt ? { revisedPrompt } : {}
+		}]
+	};
+	if (url == null) return null;
+	return {
+		type: "message",
+		role: "assistant",
+		content: [{
+			type: "image",
+			source: {
+				kind: "url",
+				url
+			},
+			...mimeType ? { mimeType } : {},
+			...revisedPrompt ? { revisedPrompt } : {}
+		}]
+	};
+}
+function isDefined(value) {
+	return value !== null;
+}
+
+//#endregion
+//#region src/xai/images/model.ts
+const XAI_IMAGE_CAPS = {
+	inputModalities: {
+		text: true,
+		image: true
+	},
+	inputShape: "prompt",
+	replayMode: "single_turn_persistent",
+	supportsInstruction: false,
+	outputModalities: { image: true },
+	additionalSupportedRoles: ["developer"]
+};
+const createXAIImagesModel = (modelId, client) => {
+	const doGenerate = async (options, ctx) => {
+		const requestBodyResult = mapToXAIImagesRequest({
+			modelId,
+			options
+		});
+		if (requestBodyResult.isErr()) return err(requestBodyResult.error.at({ at: "xai.images.generate.mapRequest" }));
+		const request = requestBodyResult.value;
+		const raw = request.mode === "edit" ? await client.images.edit(request.body, { signal: ctx.signal ?? null }) : await client.images.create(request.body, { signal: ctx.signal ?? null });
+		if (raw.isErr()) return err(raw.error.at({ at: "xai.images.generate.http" }));
+		return ok({ response: {
+			...mapFromXAIImagesResponse(raw.value),
+			request: { body: request.body }
+		} });
+	};
+	return {
+		providerId: "xai",
+		modelId,
+		caps: XAI_IMAGE_CAPS,
+		doGenerate
+	};
+};
+
+//#endregion
+//#region src/xai/tools/index.ts
+function createXAINativeToolBuilders() {
+	return {
+		webSearch: (config = {}) => createNativeTool("web_search", config),
+		xSearch: (config = {}) => createNativeTool("x_search", config),
+		codeExecution: (config = {}) => createNativeTool("code_execution", config),
+		codeInterpreter: (config = {}) => createNativeTool("code_interpreter", config),
+		attachmentSearch: (config = {}) => createNativeTool("attachment_search", config),
+		collectionsSearch: (config = {}) => createNativeTool("collections_search", config),
+		fileSearch: (config = {}) => createNativeTool("file_search", config),
+		mcp: (config) => createNativeTool("mcp", config)
+	};
+}
+function createNativeTool(type, config) {
+	return {
+		kind: "hosted",
+		provider: "xai",
+		type,
+		config
+	};
+}
+function isXAINativeToolDefinition(tool) {
+	if (!tool || typeof tool !== "object") return false;
+	const t = tool;
+	return t.kind === "hosted" && t.provider === "xai" && typeof t.type === "string";
+}
+function mapXAINativeToolToRequest(tool) {
+	return {
+		type: tool.type,
+		...tool.config
+	};
+}
+
+//#endregion
+//#region src/xai/responses/mappers.ts
+/**
+* Keys explicitly handled by the xAI responses mapper.
+*/
+const XAI_RESPONSE_KNOWN_KEYS = new Set([
+	"input",
+	"tools",
+	"toolChoice",
+	"modalities",
+	"structured_output",
+	"include",
+	"instructions",
+	"logprobs",
+	"max_output_tokens",
+	"metadata",
+	"parallel_tool_calls",
+	"previous_response_id",
+	"reasoning",
+	"search_parameters",
+	"service_tier",
+	"store",
+	"temperature",
+	"top_logprobs",
+	"top_p",
+	"user"
+]);
+function mapToXAIResponsesRequest(args) {
+	try {
+		const o = args.options;
+		const raw = o;
+		const input = typeof o.input === "string" ? [{
+			role: "user",
+			content: [{
+				type: "input_text",
+				text: o.input
+			}]
+		}] : o.input.flatMap((item) => {
+			if (typeof item === "string") return [{
+				role: "user",
+				content: [{
+					type: "input_text",
+					text: item
+				}]
+			}];
+			if (item.type === "message") {
+				const role = typeof item.role === "string" && (item.role === "system" || item.role === "user" || item.role === "assistant" || item.role === "developer") ? item.role : "user";
+				const isAssistant = role === "assistant";
+				return [{
+					role,
+					content: typeof item.content === "string" ? [isAssistant ? {
+						type: "output_text",
+						text: item.content
+					} : {
+						type: "input_text",
+						text: item.content
+					}] : item.content.map((part) => {
+						if (part.type === "text") return isAssistant ? {
+							type: "output_text",
+							text: part.text
+						} : {
+							type: "input_text",
+							text: part.text
+						};
+						if (isAssistant) throw BetterAgentError.fromCode("VALIDATION_FAILED", "Assistant messages do not support image or file inputs", { context: {
+							provider: "xai",
+							model: args.modelId
+						} }).at({ at: "xai.responses.map.input.assistantImage" });
+						if (part.type === "file") {
+							if (part.source.kind !== "provider-file") throw BetterAgentError.fromCode("VALIDATION_FAILED", "xAI file inputs currently require a provider-file source", { context: {
+								provider: "xai",
+								model: args.modelId,
+								sourceKind: part.source.kind
+							} }).at({ at: "xai.responses.map.input.fileSource" });
+							if (part.source.ref.provider !== "xai") throw BetterAgentError.fromCode("VALIDATION_FAILED", "xAI file inputs require a provider-file reference for provider=xai", { context: {
+								provider: "xai",
+								model: args.modelId,
+								sourceProvider: part.source.ref.provider
+							} }).at({ at: "xai.responses.map.input.fileProvider" });
+							return {
+								type: "input_file",
+								file_id: part.source.ref.id,
+								...part.source.filename != null ? { filename: part.source.filename } : {}
+							};
+						}
+						if (part.type !== "image") throw BetterAgentError.fromCode("VALIDATION_FAILED", `Unsupported message part for xAI Responses: ${part.type}`, { context: {
+							provider: "xai",
+							model: args.modelId,
+							partType: part.type
+						} }).at({ at: "xai.responses.map.input.unsupportedPart" });
+						return {
+							type: "input_image",
+							detail: "auto",
+							image_url: part.source.kind === "url" ? part.source.url : `data:${part.source.mimeType};base64,${part.source.data}`
+						};
+					})
+				}];
+			}
+			const callArguments = "arguments" in item && typeof item.arguments === "string" ? item.arguments : "{}";
+			const call = {
+				type: "function_call",
+				call_id: item.callId,
+				name: item.name,
+				arguments: callArguments
+			};
+			if (item.result == null) return [call];
+			return [call, {
+				type: "function_call_output",
+				call_id: item.callId,
+				output: typeof item.result === "string" ? item.result : JSON.stringify(item.result),
+				status: item.isError === true ? "incomplete" : "completed"
+			}];
+		});
+		let text;
+		if ("structured_output" in o && o.structured_output) {
+			const out = o.structured_output;
+			const { name, strict = true } = out;
+			if (out.schema.type !== "object") return err(BetterAgentError.fromCode("VALIDATION_FAILED", "Structured output schema must be an object", { context: {
+				provider: "xai",
+				model: args.modelId
+			} }).at({ at: "xai.responses.map.structuredOutput" }));
+			text = { format: {
+				type: "json_schema",
+				name,
+				strict,
+				schema: out.schema
+			} };
+		}
+		const xaiTools = [];
+		const tools = ("tools" in o ? o.tools : []) ?? [];
+		if (tools.length) for (const tool of tools) {
+			if (isXAINativeToolDefinition(tool)) {
+				xaiTools.push(mapXAINativeToolToRequest(tool));
+				continue;
+			}
+			const callableTool = tool;
+			if (!callableTool || !isCallableToolDefinition(callableTool)) continue;
+			const parameters = callableTool[TOOL_JSON_SCHEMA];
+			if (parameters.type !== "object") return err(BetterAgentError.fromCode("VALIDATION_FAILED", "Tool parameters schema must be an object", { context: {
+				provider: "xai",
+				model: args.modelId
+			} }).at({ at: "xai.responses.map.tools" }));
+			xaiTools.push({
+				type: "function",
+				name: String(callableTool.name ?? ""),
+				description: typeof callableTool.description === "string" ? callableTool.description : null,
+				parameters,
+				strict: typeof callableTool.strict === "boolean" ? callableTool.strict : null
+			});
+		}
+		let xaiToolChoice;
+		if ("tools" in o && o.tools && "toolChoice" in o && o.toolChoice && o.toolChoice.type !== "auto") {
+			const tc = o.toolChoice;
+			if (tc.type === "none") xaiToolChoice = "none";
+			else if (tc.type === "required") xaiToolChoice = "required";
+			else if (tc.type === "tool") {
+				if (!xaiTools.length) return err(BetterAgentError.fromCode("VALIDATION_FAILED", "toolChoice=tool requires tools[] to be provided", { context: {
+					provider: "xai",
+					model: args.modelId
+				} }).at({ at: "xai.responses.map.toolChoice" }));
+				if (!xaiTools.some((t) => typeof t === "object" && t && "type" in t && t.type === "function" && "name" in t && t.name === tc.name)) return err(BetterAgentError.fromCode("VALIDATION_FAILED", `Requested tool not found: ${tc.name}`, { context: {
+					provider: "xai",
+					model: args.modelId
+				} }).at({ at: "xai.responses.map.toolChoice" }));
+				xaiToolChoice = {
+					type: "function",
+					name: tc.name
+				};
+			}
+		}
+		const request = {
+			...extractPassthroughOptions(o, XAI_RESPONSE_KNOWN_KEYS),
+			model: args.modelId,
+			input,
+			...omitNullish({
+				text,
+				tools: xaiTools.length ? xaiTools : void 0,
+				tool_choice: xaiToolChoice,
+				include: o.include,
+				instructions: raw.instructions,
+				metadata: o.metadata,
+				parallel_tool_calls: o.parallel_tool_calls,
+				previous_response_id: o.previous_response_id,
+				reasoning: o.reasoning,
+				search_parameters: o.search_parameters,
+				service_tier: o.service_tier,
+				store: o.store,
+				user: o.user
+			})
+		};
+		const responseOpts = o;
+		if (responseOpts.modalities === void 0 || responseOpts.modalities.includes("text")) {
+			if (responseOpts.max_output_tokens != null) request.max_output_tokens = responseOpts.max_output_tokens;
+			if (responseOpts.logprobs != null) request.logprobs = responseOpts.logprobs;
+			if (responseOpts.temperature != null) request.temperature = responseOpts.temperature;
+			if (responseOpts.top_logprobs != null) request.top_logprobs = responseOpts.top_logprobs;
+			if (responseOpts.top_p != null) request.top_p = responseOpts.top_p;
+		}
+		return ok(request);
+	} catch (e) {
+		return err(BetterAgentError.wrap({
+			err: e,
+			message: "Failed to map xAI Responses request",
+			opts: {
+				code: "INTERNAL",
+				context: {
+					provider: "xai",
+					model: args.modelId
+				}
+			}
+		}).at({ at: "xai.responses.mapToRequest" }));
+	}
+}
+function mapFromXAIResponsesResponse(response) {
+	const outputItems = [];
+	for (const item of response.output ?? []) {
+		if (!item || typeof item !== "object" || !("type" in item)) continue;
+		if (item.type === "message") {
+			const parts = Array.isArray(item.content) ? item.content.flatMap((part) => {
+				if (!part || typeof part !== "object" || !("type" in part)) return [];
+				const candidate = part;
+				if (candidate.type === "output_text" && typeof candidate.text === "string") return [{
+					type: "text",
+					text: candidate.text
+				}];
+				return [];
+			}) : [];
+			if (parts.length > 0) outputItems.push({
+				type: "message",
+				role: item.role ?? "assistant",
+				content: parts
+			});
+			continue;
+		}
+		if (item.type === "function_call" && typeof item.name === "string" && typeof item.call_id === "string") {
+			outputItems.push({
+				type: "tool-call",
+				name: item.name,
+				arguments: typeof item.arguments === "string" ? item.arguments : "{}",
+				callId: item.call_id
+			});
+			continue;
+		}
+		if (typeof item.type === "string" && item.type.endsWith("_call")) {
+			if (!("id" in item) || !(typeof item.id === "string" && item.id.length > 0)) continue;
+			outputItems.push({
+				type: "provider-tool-result",
+				name: item.type.slice(0, -5),
+				callId: item.id,
+				result: item
+			});
+			continue;
+		}
+		if (typeof item.type === "string" && item.type.endsWith("_call_output")) {
+			if (!("call_id" in item) || typeof item.call_id !== "string" || item.call_id.length === 0) continue;
+			outputItems.push({
+				type: "provider-tool-result",
+				name: item.type.slice(0, -12),
+				callId: item.call_id,
+				result: item
+			});
+		}
+	}
+	const inputTokens = response.usage?.input_tokens;
+	const outputTokens = response.usage?.output_tokens;
+	const usage = omitNullish({
+		inputTokens,
+		outputTokens,
+		totalTokens: typeof inputTokens === "number" && typeof outputTokens === "number" ? inputTokens + outputTokens : void 0,
+		reasoningTokens: response.usage?.output_tokens_details?.reasoning_tokens,
+		cachedInputTokens: response.usage?.input_tokens_details?.cached_tokens
+	});
+	const hasToolCalls = outputItems.some((item) => item.type === "tool-call" && "arguments" in item);
+	let finishReason;
+	const incompleteReason = response.incomplete_details?.reason;
+	if (incompleteReason === "max_output_tokens") finishReason = "length";
+	else if (incompleteReason === "content_filter") finishReason = "content-filter";
+	else if (incompleteReason) finishReason = "other";
+	else if (hasToolCalls) finishReason = "tool-calls";
+	else finishReason = "stop";
+	return {
+		output: outputItems,
+		finishReason,
+		usage,
+		response: { body: response }
+	};
+}
+function mapFromXAIResponsesStreamEvent(event, messageId) {
+	if (event.type === "response.reasoning_summary_part.added") return ok({
+		kind: "event",
+		event: {
+			type: Events.REASONING_MESSAGE_START,
+			messageId,
+			role: "assistant",
+			visibility: "summary",
+			provider: "xai",
+			timestamp: Date.now()
+		}
+	});
+	if (event.type === "response.reasoning_summary_text.delta") return ok({
+		kind: "event",
+		event: {
+			type: Events.REASONING_MESSAGE_CONTENT,
+			messageId,
+			visibility: "summary",
+			delta: event.delta ?? "",
+			provider: "xai",
+			timestamp: Date.now()
+		}
+	});
+	if (event.type === "response.reasoning_summary_text.done") return ok({
+		kind: "event",
+		event: {
+			type: Events.REASONING_MESSAGE_END,
+			messageId,
+			visibility: "summary",
+			provider: "xai",
+			timestamp: Date.now()
+		}
+	});
+	if (event.type === "response.reasoning_text.delta") return ok({
+		kind: "event",
+		event: {
+			type: Events.REASONING_MESSAGE_CONTENT,
+			messageId,
+			visibility: "full",
+			delta: event.delta ?? "",
+			provider: "xai",
+			timestamp: Date.now()
+		}
+	});
+	if (event.type === "response.reasoning_text.done") return ok({
+		kind: "event",
+		event: {
+			type: Events.REASONING_MESSAGE_END,
+			messageId,
+			visibility: "full",
+			provider: "xai",
+			timestamp: Date.now()
+		}
+	});
+	if (event.type === "response.output_item.added") {
+		if (event.item?.type === "message") return ok({
+			kind: "event",
+			event: {
+				type: Events.TEXT_MESSAGE_START,
+				messageId,
+				role: "assistant",
+				timestamp: Date.now()
+			}
+		});
+		if (event.item?.type === "function_call") {
+			const toolCallId = typeof event.item.call_id === "string" && event.item.call_id.length > 0 ? event.item.call_id : event.item.id;
+			if (!(typeof toolCallId === "string" && toolCallId.length > 0)) return ok(null);
+			return ok({
+				kind: "event",
+				event: {
+					type: Events.TOOL_CALL_START,
+					toolCallId,
+					toolCallName: event.item.name ?? "",
+					parentMessageId: messageId,
+					timestamp: Date.now()
+				}
+			});
+		}
+		if (typeof event.item?.type === "string" && event.item.type.endsWith("_call") && event.item.type !== "function_call" && typeof event.item.id === "string" && event.item.id.length > 0) return ok({
+			kind: "event",
+			event: {
+				type: Events.TOOL_CALL_START,
+				toolCallId: event.item.id,
+				toolCallName: event.item.type.slice(0, -5),
+				parentMessageId: messageId,
+				timestamp: Date.now()
+			}
+		});
+	}
+	if (event.type === "response.output_text.delta") return ok({
+		kind: "event",
+		event: {
+			type: Events.TEXT_MESSAGE_CONTENT,
+			messageId,
+			delta: event.delta ?? "",
+			timestamp: Date.now()
+		}
+	});
+	if (event.type === "response.output_text.done") return ok({
+		kind: "event",
+		event: {
+			type: Events.TEXT_MESSAGE_END,
+			messageId,
+			timestamp: Date.now()
+		}
+	});
+	if (event.type === "response.function_call_arguments.delta") {
+		const toolCallId = typeof event.call_id === "string" && event.call_id.length > 0 ? event.call_id : event.item_id;
+		if (!(typeof toolCallId === "string" && toolCallId.length > 0)) return ok(null);
+		return ok({
+			kind: "event",
+			event: {
+				type: Events.TOOL_CALL_ARGS,
+				parentMessageId: messageId,
+				toolCallId,
+				toolCallName: "unknown",
+				delta: event.delta ?? "",
+				timestamp: Date.now()
+			}
+		});
+	}
+	if (event.type === "response.function_call_arguments.done") {
+		const toolCallId = typeof event.call_id === "string" && event.call_id.length > 0 ? event.call_id : event.item_id;
+		if (!(typeof toolCallId === "string" && toolCallId.length > 0)) return ok(null);
+		return ok({
+			kind: "event",
+			event: {
+				type: Events.TOOL_CALL_END,
+				parentMessageId: messageId,
+				toolCallId,
+				toolCallName: "unknown",
+				timestamp: Date.now()
+			}
+		});
+	}
+	if (event.type === "response.web_search_call.in_progress" || event.type === "response.web_search_call.searching" || event.type === "response.web_search_call.completed" || event.type === "response.x_search_call.in_progress" || event.type === "response.x_search_call.searching" || event.type === "response.x_search_call.completed" || event.type === "response.file_search_call.in_progress" || event.type === "response.file_search_call.searching" || event.type === "response.file_search_call.completed" || event.type === "response.code_interpreter_call.in_progress" || event.type === "response.code_interpreter_call.interpreting" || event.type === "response.code_interpreter_call.completed" || event.type === "response.code_execution_call.in_progress" || event.type === "response.code_execution_call.interpreting" || event.type === "response.code_execution_call.completed" || event.type === "response.mcp_call.in_progress" || event.type === "response.mcp_call.completed" || event.type === "response.mcp_call.failed" || event.type === "response.mcp_list_tools.in_progress" || event.type === "response.mcp_list_tools.completed" || event.type === "response.mcp_list_tools.failed") {
+		const fullType = event.type.slice(9);
+		const dotIndex = fullType.lastIndexOf(".");
+		const toolSegment = dotIndex >= 0 ? fullType.slice(0, dotIndex) : fullType;
+		const status = dotIndex >= 0 ? fullType.slice(dotIndex + 1) : "unknown";
+		const tool = toolSegment.endsWith("_call") ? toolSegment.slice(0, -5) : toolSegment;
+		return ok({
+			kind: "event",
+			event: {
+				type: Events.DATA_PART,
+				...typeof event.item_id === "string" ? { id: event.item_id } : {},
+				data: {
+					endpoint: "responses",
+					tool,
+					status,
+					raw: event
+				},
+				timestamp: Date.now()
+			}
+		});
+	}
+	if (event.type === "response.output_item.done") {
+		if (typeof event.item?.type === "string" && event.item.type.endsWith("_call") && event.item.type !== "function_call" && typeof event.item.id === "string" && event.item.id.length > 0) return ok({
+			kind: "event",
+			event: {
+				type: Events.TOOL_CALL_RESULT,
+				parentMessageId: messageId,
+				toolCallId: event.item.id,
+				toolCallName: event.item.type.slice(0, -5),
+				result: event.item,
+				timestamp: Date.now()
+			}
+		});
+	}
+	if (event.type === "response.completed") return ok({
+		kind: "final",
+		response: mapFromXAIResponsesResponse(event.response)
+	});
+	if (event.type === "error") return err(BetterAgentError.fromCode("UPSTREAM_FAILED", event.message ?? "xAI streaming error", { context: {
+		provider: "xai",
+		upstreamCode: "STREAM_ERROR",
+		raw: event
+	} }).at({ at: "xai.responses.stream.event" }));
+	return ok(null);
+}
+
+//#endregion
+//#region src/xai/responses/model.ts
+const XAI_RESPONSE_CAPS = {
+	inputModalities: {
+		text: true,
+		image: true,
+		file: true
+	},
+	inputShape: "chat",
+	replayMode: "multi_turn",
+	supportsInstruction: true,
+	outputModalities: { text: { options: {} } },
+	tools: true,
+	structured_output: true,
+	additionalSupportedRoles: ["developer"]
+};
+const createDeferred = () => {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+};
+const createXAIResponsesModel = (modelId, client) => {
+	const doGenerate = async (options, ctx) => {
+		const requestBodyResult = mapToXAIResponsesRequest({
+			modelId,
+			options
+		});
+		if (requestBodyResult.isErr()) return err(requestBodyResult.error.at({ at: "xai.generate.mapRequest" }));
+		const raw = await client.responses.create(requestBodyResult.value, { signal: ctx.signal ?? null });
+		if (raw.isErr()) return err(raw.error.at({ at: "xai.generate.http" }));
+		return ok({ response: {
+			...mapFromXAIResponsesResponse(raw.value),
+			request: { body: requestBodyResult.value }
+		} });
+	};
+	const doGenerateStream = async (options, ctx) => {
+		const requestBodyResult = mapToXAIResponsesRequest({
+			modelId,
+			options
+		});
+		if (requestBodyResult.isErr()) return err(requestBodyResult.error.at({ at: "xai.generateStream.mapRequest" }));
+		const streamResult = await client.responses.stream(requestBodyResult.value, { signal: ctx.signal ?? null });
+		if (streamResult.isErr()) return err(streamResult.error.at({ at: "xai.generateStream.http" }));
+		const { promise: final, resolve: resolveFinal, reject: rejectFinal } = createDeferred();
+		return ok({
+			events: (async function* () {
+				const messageId = ctx.generateMessageId();
+				let sawFinal = false;
+				try {
+					for await (const raw of streamResult.value) {
+						if (raw.isErr()) {
+							rejectFinal(raw.error);
+							yield err(raw.error);
+							return;
+						}
+						const mapped = mapFromXAIResponsesStreamEvent(raw.value, messageId);
+						if (mapped.isErr()) {
+							const error = mapped.error.at({ at: "xai.generateStream.mapEvent" });
+							rejectFinal(error);
+							yield err(error);
+							return;
+						}
+						const value = mapped.value;
+						if (!value) continue;
+						if (value.kind === "final") {
+							sawFinal = true;
+							resolveFinal(value.response);
+							continue;
+						}
+						yield ok(value.event);
+					}
+				} finally {
+					if (!sawFinal) rejectFinal(BetterAgentError.fromCode("UPSTREAM_FAILED", "xAI stream ended without a final response event.", { context: {
+						provider: "xai",
+						model: String(modelId)
+					} }).at({ at: "xai.generateStream.final" }));
+				}
+			})(),
+			final
+		});
+	};
+	return {
+		providerId: "xai",
+		modelId,
+		caps: XAI_RESPONSE_CAPS,
+		doGenerate,
+		doGenerateStream
+	};
+};
+
+//#endregion
+//#region src/xai/shared/schemas.ts
+const XAI_RESPONSE_MODEL_NAMES = [
+	"grok-3",
+	"grok-3-latest",
+	"grok-3-beta",
+	"grok-3-fast",
+	"grok-3-fast-latest",
+	"grok-3-fast-beta",
+	"grok-3-mini",
+	"grok-4",
+	"grok-4-1-fast-reasoning",
+	"grok-4.20-beta-latest-non-reasoning",
+	"grok-4.20-multi-agent-beta-0309",
+	"grok-code-fast-1"
+];
+const XAI_IMAGE_MODEL_NAMES = ["grok-imagine-image"];
+const XAIResponseModels = z.enum(XAI_RESPONSE_MODEL_NAMES).describe("Current documented xAI response model names. For the latest team-specific availability, also check <https://console.x.ai/team/default/models> and <https://docs.x.ai/docs/models>.");
+const XAIImageModels = z.enum(XAI_IMAGE_MODEL_NAMES).describe("Current documented xAI image model names. For the latest team-specific availability, also check <https://console.x.ai/team/default/models> and <https://docs.x.ai/docs/models>.");
+const XAI_MODEL_KINDS = {
+	"grok-3": "text",
+	"grok-3-latest": "text",
+	"grok-3-beta": "text",
+	"grok-3-fast": "text",
+	"grok-3-fast-latest": "text",
+	"grok-3-fast-beta": "text",
+	"grok-3-mini": "text",
+	"grok-4": "text",
+	"grok-4-1-fast-reasoning": "text",
+	"grok-4.20-beta-latest-non-reasoning": "text",
+	"grok-4.20-multi-agent-beta-0309": "text",
+	"grok-code-fast-1": "text",
+	"grok-imagine-image": "image"
+};
+const getXAIModelKind = (modelId) => XAI_MODEL_KINDS[modelId];
+const XAIFileObjectSchema = z.object({
+	id: z.string().describe("Unique file identifier."),
+	object: z.string().optional().describe("Object type, typically `file`."),
+	bytes: z.number().int().nonnegative().optional().describe("File size in bytes."),
+	created_at: z.number().int().optional().describe("Unix timestamp when the file was created."),
+	expires_at: z.number().int().nullish().describe("Optional expiration time."),
+	filename: z.string().optional().describe("Original file name."),
+	purpose: z.string().optional().describe("Declared file purpose."),
+	status: z.string().optional().describe("Provider-side processing status."),
+	status_details: z.any().optional().describe("Provider-side status details.")
+}).passthrough().describe("xAI file object.");
+z.object({
+	object: z.string().optional().describe("List object type."),
+	data: z.array(XAIFileObjectSchema).describe("Files returned by the provider."),
+	first_id: z.string().nullish().optional().describe("First file id in the page."),
+	last_id: z.string().nullish().optional().describe("Last file id in the page."),
+	has_more: z.boolean().optional().describe("Whether additional pages are available.")
+}).passthrough().describe("xAI files list response.");
+z.object({
+	id: z.string().describe("Deleted file identifier."),
+	object: z.string().optional().describe("Delete response object type."),
+	deleted: z.boolean().describe("Whether the file was deleted.")
+}).passthrough().describe("xAI delete file response.");
+
+//#endregion
+//#region src/xai/models/index.ts
+function createXAIModel(modelId, client) {
+	if (getXAIModelKind(modelId) === "image") return createXAIImagesModel(modelId, client);
+	return createXAIResponsesModel(modelId, client);
+}
+
+//#endregion
+//#region src/xai/provider.ts
+const createXAI = (config) => {
+	const httpClient = createXAIClient(config);
+	return {
+		id: "xai",
+		tools: createXAINativeToolBuilders(),
+		files: httpClient.files,
+		model(modelId) {
+			return createXAIModel(modelId, httpClient);
+		},
+		text(modelId) {
+			return createXAIResponsesModel(modelId, httpClient);
+		},
+		image(modelId) {
+			return createXAIImagesModel(modelId, httpClient);
+		}
+	};
+};
+
+//#endregion
+export { createXAI };
+//# sourceMappingURL=index.mjs.map