@amjadiqbal/tanstack-ai-sdk-bridge 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1111 @@
+import { EventType, isFileSource, normalizeSystemPrompts, requireTextOnlyEmbeddingInput, unsupportedFileSourceError } from "@tanstack/ai";
+import { tanstackMetadata, toRunErrorPayload, transformMessagesForReplay } from "@tanstack/ai/adapter-internals";
+import { BaseEmbeddingAdapter, BaseImageAdapter, BaseRerankAdapter, BaseTTSAdapter, BaseTextAdapter, BaseTranscriptionAdapter } from "@tanstack/ai/adapters";
+// src/shared.ts
+function specVersionOf(model, kind, supported) {
+	const version = model.specificationVersion;
+	if (!supported.includes(version)) throw new Error(`@amjadiqbal/tanstack-ai-sdk-bridge: ${kind} model "${model.provider}/${model.modelId}" uses AI SDK spec "${model.specificationVersion}", supported: ${supported.join(", ")}.`);
+	return version;
+}
+function adapterName(model, options) {
+	return options?.name ?? (model.provider.split(".")[0] || model.provider);
+}
+function randomId(prefix) {
+	return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function tokenUsage(input, output, total) {
+	const promptTokens = input ?? 0;
+	const completionTokens = output ?? 0;
+	return {
+		promptTokens,
+		completionTokens,
+		totalTokens: total ?? promptTokens + completionTokens
+	};
+}
+function bytesToBase64(bytes) {
+	let binary = "";
+	const chunk = 32768;
+	for (let i = 0; i < bytes.length; i += chunk) binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+	return btoa(binary);
+}
+function base64ToBytes(base64) {
+	const binary = atob(base64);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+/** Splits `data:<type>;base64,<data>` into its parts. Returns undefined for anything else. */
+function parseDataUrl(value) {
+	const match = /^data:([^;,]+)?(?:;[^,]*)?;base64,(.*)$/s.exec(value);
+	if (!match) return void 0;
+	return {
+		mediaType: match[1] ?? "application/octet-stream",
+		base64: match[2] ?? ""
+	};
+}
+/** Pass-through call fields, without keys whose value is undefined. */
+function callExtras(options, abortSignal) {
+	return {
+		...options?.providerOptions !== void 0 && { providerOptions: options.providerOptions },
+		...options?.headers !== void 0 && { headers: definedHeaders(options.headers) },
+		...abortSignal !== void 0 && { abortSignal }
+	};
+}
+function definedHeaders(headers) {
+	return Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] !== void 0));
+}
+// src/embedding.ts
+const SPECS$5 = [
+	"v2",
+	"v3",
+	"v4"
+];
+/** TanStack AI embedding adapter around an AI SDK embedding model. Splits large inputs by `maxEmbeddingsPerCall`. */
+var AiSdkEmbeddingAdapter = class extends BaseEmbeddingAdapter {
+	name;
+	embeddingModel;
+	specificationVersion;
+	constructor(model, options) {
+		super(model.modelId, {});
+		this.specificationVersion = specVersionOf(model, "embedding", SPECS$5);
+		this.embeddingModel = model;
+		this.name = adapterName(model, options);
+	}
+	async createEmbeddings(options) {
+		const { model, logger, modelOptions, dimensions } = options;
+		const values = requireTextOnlyEmbeddingInput(options.input, this.name, model);
+		if (dimensions !== void 0 && this.specificationVersion !== "v4") throw new Error(`${this.name}: \`dimensions\` needs an AI SDK v4 embedding model; set it through modelOptions.providerOptions instead.`);
+		try {
+			logger.request(`activity=embed provider=${this.name} model=${model} inputs=${values.length}`, {
+				provider: this.name,
+				model
+			});
+			const max = await this.embeddingModel.maxEmbeddingsPerCall ?? values.length;
+			const size = Math.max(1, Math.min(max, values.length || 1));
+			const vectors = [];
+			let tokens;
+			for (let start = 0; start < values.length; start += size) {
+				const batch = values.slice(start, start + size);
+				const result = await this.embeddingModel.doEmbed({
+					values: batch,
+					...dimensions !== void 0 && { dimensions },
+					...callExtras(modelOptions, void 0)
+				});
+				vectors.push(...result.embeddings);
+				if (result.usage) tokens = (tokens ?? 0) + result.usage.tokens;
+			}
+			return {
+				id: randomId(this.name),
+				model,
+				embeddings: vectors.map((vector, index) => ({
+					vector,
+					index
+				})),
+				...tokens !== void 0 && { usage: tokenUsage(tokens, 0) }
+			};
+		} catch (error) {
+			logger.errors(`${this.name}.createEmbeddings fatal`, {
+				error: toRunErrorPayload(error, `${this.name}.createEmbeddings failed`),
+				source: `${this.name}.createEmbeddings`
+			});
+			throw error;
+		}
+	}
+};
+/**
+* Wraps an AI SDK embedding model as a TanStack AI embedding adapter.
+*
+* @example
+* import { embed } from '@tanstack/ai'
+* import { openai } from '@ai-sdk/openai'
+* await embed({ adapter: aiSdkEmbedding(openai.embedding('text-embedding-3-small')), input: ['hello'] })
+*/
+function aiSdkEmbedding(model, options) {
+	return new AiSdkEmbeddingAdapter(model, options);
+}
+// src/image.ts
+const SPECS$4 = [
+	"v2",
+	"v3",
+	"v4"
+];
+/**
+* TanStack AI image adapter around an AI SDK image model.
+* Text parts of the prompt become the prompt; image parts become input files (AI SDK v3/v4 models).
+*/
+var AiSdkImageAdapter = class extends BaseImageAdapter {
+	name;
+	imageModel;
+	specificationVersion;
+	constructor(model, options) {
+		super(model.modelId, {});
+		this.specificationVersion = specVersionOf(model, "image", SPECS$4);
+		this.imageModel = model;
+		this.name = adapterName(model, options);
+	}
+	promptOf(prompt) {
+		if (typeof prompt === "string") return {
+			text: prompt,
+			files: []
+		};
+		const texts = [];
+		const files = [];
+		for (const part of prompt) {
+			if (part.type === "text") {
+				texts.push(part.content);
+				continue;
+			}
+			if (part.type !== "image") throw new Error(`${this.name}: image models take text and image prompt parts only`);
+			if (isFileSource(part.source)) throw unsupportedFileSourceError(this.name);
+			files.push(part.source.type === "url" ? {
+				type: "url",
+				url: part.source.value
+			} : {
+				type: "file",
+				mediaType: part.source.mimeType,
+				data: part.source.value
+			});
+		}
+		if (files.length > 0 && this.specificationVersion === "v2") throw new Error(`${this.name}: image inputs need an AI SDK v3 or v4 image model`);
+		return {
+			text: texts.join("\n"),
+			files
+		};
+	}
+	async generateImages(options) {
+		const { model, logger, modelOptions, abortSignal, size } = options;
+		const wanted = options.numberOfImages ?? 1;
+		try {
+			const { text, files } = this.promptOf(options.prompt);
+			const maxSetting = this.imageModel.maxImagesPerCall;
+			const max = (typeof maxSetting === "function" ? await maxSetting({ modelId: this.imageModel.modelId }) : maxSetting) ?? 1;
+			logger.request(`activity=image provider=${this.name} model=${model} n=${wanted} size=${size ?? "default"}`, {
+				provider: this.name,
+				model
+			});
+			const images = [];
+			let input = 0;
+			let output = 0;
+			let sawUsage = false;
+			while (images.length < wanted) {
+				const n = Math.min(Math.max(1, max), wanted - images.length);
+				const result = await this.imageModel.doGenerate({
+					prompt: text,
+					n,
+					size,
+					aspectRatio: modelOptions?.aspectRatio,
+					seed: modelOptions?.seed,
+					files: files.length > 0 ? files : void 0,
+					mask: void 0,
+					providerOptions: modelOptions?.providerOptions ?? {},
+					...modelOptions?.headers && { headers: modelOptions.headers },
+					...abortSignal && { abortSignal }
+				});
+				if (result.images.length === 0) break;
+				for (const image of result.images) images.push(typeof image === "string" ? image : bytesToBase64(image));
+				if (result.usage) {
+					sawUsage = true;
+					input += result.usage.inputTokens ?? 0;
+					output += result.usage.outputTokens ?? 0;
+				}
+			}
+			return {
+				id: randomId(this.name),
+				model,
+				images: images.slice(0, wanted).map((b64Json) => ({ b64Json })),
+				...sawUsage && { usage: tokenUsage(input, output) }
+			};
+		} catch (error) {
+			logger.errors(`${this.name}.generateImages fatal`, {
+				error: toRunErrorPayload(error, `${this.name}.generateImages failed`),
+				source: `${this.name}.generateImages`
+			});
+			throw error;
+		}
+	}
+};
+/**
+* Wraps an AI SDK image model as a TanStack AI image adapter.
+*
+* @example
+* import { generateImage } from '@tanstack/ai'
+* import { openai } from '@ai-sdk/openai'
+* await generateImage({ threadId, adapter: aiSdkImage(openai.image('gpt-image-1')), prompt: 'a lighthouse' })
+*/
+function aiSdkImage(model, options) {
+	return new AiSdkImageAdapter(model, options);
+}
+// src/rerank.ts
+const SPECS$3 = ["v3", "v4"];
+/** TanStack AI rerank adapter around an AI SDK reranking model. AI SDK reports no token usage for reranking. */
+var AiSdkRerankAdapter = class extends BaseRerankAdapter {
+	name;
+	rerankingModel;
+	specificationVersion;
+	constructor(model, options) {
+		super({}, model.modelId);
+		this.specificationVersion = specVersionOf(model, "reranking", SPECS$3);
+		this.rerankingModel = model;
+		this.name = adapterName(model, options);
+	}
+	async rerank(options) {
+		const { model, logger, modelOptions, abortSignal, query, documents, topN } = options;
+		try {
+			logger.request(`activity=rerank provider=${this.name} model=${model} documents=${documents.length}`, {
+				provider: this.name,
+				model
+			});
+			const result = await this.rerankingModel.doRerank({
+				query,
+				documents: {
+					type: "text",
+					values: documents
+				},
+				...topN !== void 0 && { topN },
+				...callExtras(modelOptions, abortSignal)
+			});
+			return {
+				id: result.response?.id ?? randomId(this.name),
+				ranking: result.ranking.map(({ index, relevanceScore }) => ({
+					index,
+					score: relevanceScore
+				})),
+				usage: tokenUsage(0, 0)
+			};
+		} catch (error) {
+			logger.errors(`${this.name}.rerank fatal`, {
+				error: toRunErrorPayload(error, `${this.name}.rerank failed`),
+				source: `${this.name}.rerank`
+			});
+			throw error;
+		}
+	}
+};
+/**
+* Wraps an AI SDK reranking model as a TanStack AI rerank adapter.
+*
+* @example
+* import { rerank } from '@tanstack/ai'
+* import { cohere } from '@ai-sdk/cohere'
+* await rerank({ adapter: aiSdkRerank(cohere.reranking('rerank-v3.5')), query, documents })
+*/
+function aiSdkRerank(model, options) {
+	return new AiSdkRerankAdapter(model, options);
+}
+// src/speech.ts
+const SPECS$2 = [
+	"v2",
+	"v3",
+	"v4"
+];
+const CONTENT_TYPES = {
+	mp3: "audio/mpeg",
+	opus: "audio/opus",
+	aac: "audio/aac",
+	flac: "audio/flac",
+	wav: "audio/wav",
+	pcm: "audio/pcm"
+};
+/** TanStack AI text-to-speech adapter around an AI SDK speech model. */
+var AiSdkSpeechAdapter = class extends BaseTTSAdapter {
+	name;
+	speechModel;
+	specificationVersion;
+	constructor(model, options) {
+		super(model.modelId, {});
+		this.specificationVersion = specVersionOf(model, "speech", SPECS$2);
+		this.speechModel = model;
+		this.name = adapterName(model, options);
+	}
+	async generateSpeech(options) {
+		const { model, logger, modelOptions, abortSignal, text, voice, format, speed } = options;
+		try {
+			logger.request(`activity=tts provider=${this.name} model=${model} format=${format ?? "default"} voice=${voice ?? "default"}`, {
+				provider: this.name,
+				model
+			});
+			const result = await this.speechModel.doGenerate({
+				text,
+				...voice !== void 0 && { voice },
+				...format !== void 0 && { outputFormat: format },
+				...speed !== void 0 && { speed },
+				...modelOptions?.instructions !== void 0 && { instructions: modelOptions.instructions },
+				...modelOptions?.language !== void 0 && { language: modelOptions.language },
+				...callExtras(modelOptions, abortSignal)
+			});
+			const audio = typeof result.audio === "string" ? result.audio : bytesToBase64(result.audio);
+			const outputFormat = format ?? "mp3";
+			const headerType = (result.response?.headers)?.["content-type"];
+			return {
+				id: randomId(this.name),
+				model: result.response?.modelId ?? model,
+				audio,
+				format: outputFormat,
+				contentType: headerType?.split(";")[0] || CONTENT_TYPES[outputFormat] || "application/octet-stream"
+			};
+		} catch (error) {
+			logger.errors(`${this.name}.generateSpeech fatal`, {
+				error: toRunErrorPayload(error, `${this.name}.generateSpeech failed`),
+				source: `${this.name}.generateSpeech`
+			});
+			throw error;
+		}
+	}
+};
+/**
+* Wraps an AI SDK speech model as a TanStack AI text-to-speech adapter.
+*
+* @example
+* import { generateSpeech } from '@tanstack/ai'
+* import { openai } from '@ai-sdk/openai'
+* await generateSpeech({ threadId, adapter: aiSdkSpeech(openai.speech('gpt-4o-mini-tts')), text: 'Hello', voice: 'alloy' })
+*/
+function aiSdkSpeech(model, options) {
+	return new AiSdkSpeechAdapter(model, options);
+}
+// src/messages.ts
+const DEFAULT_MEDIA_TYPE = {
+	image: "image/*",
+	audio: "audio/*",
+	video: "video/*",
+	document: "application/pdf"
+};
+function filePart(part, adapterName) {
+	const { source } = part;
+	if (isFileSource(source)) throw unsupportedFileSourceError(adapterName);
+	const mediaType = source.mimeType ?? DEFAULT_MEDIA_TYPE[part.type] ?? "application/octet-stream";
+	if (source.type === "url") return {
+		type: "file",
+		mediaType,
+		data: {
+			type: "url",
+			url: new URL(source.value)
+		}
+	};
+	return {
+		type: "file",
+		mediaType,
+		data: {
+			type: "data",
+			data: source.value
+		}
+	};
+}
+function textOf(content) {
+	if (typeof content === "string") return content;
+	if (!content) return "";
+	return content.filter((part) => part.type === "text").map((part) => part.content).join("");
+}
+function parseJson(value) {
+	if (value.trim() === "") return {};
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function toolOutput(message) {
+	if (message.error !== void 0) return {
+		type: "error-text",
+		value: message.error || textOf(message.content)
+	};
+	return {
+		type: "text",
+		value: textOf(message.content)
+	};
+}
+/**
+* Converts TanStack AI system prompts and messages into an AI SDK V4 prompt.
+* `toPromptForSpec` then adapts file parts for V2/V3 models.
+*/
+function toAiSdkPrompt(options, adapterName) {
+	const prompt = [];
+	for (const system of normalizeSystemPrompts(options.systemPrompts)) if (system.content) prompt.push({
+		role: "system",
+		content: system.content
+	});
+	const toolNames = /* @__PURE__ */ new Map();
+	for (const message of options.messages) for (const call of message.toolCalls ?? []) toolNames.set(call.id, call.function.name);
+	for (const message of options.messages) {
+		if (message.role === "user") {
+			const content = [];
+			if (typeof message.content === "string") content.push({
+				type: "text",
+				text: message.content
+			});
+			else for (const part of message.content ?? []) content.push(part.type === "text" ? {
+				type: "text",
+				text: part.content
+			} : filePart(part, adapterName));
+			if (content.length > 0) prompt.push({
+				role: "user",
+				content
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			const content = [];
+			for (const thinking of message.thinking ?? []) if (thinking.content && !thinking.redacted) content.push({
+				type: "reasoning",
+				text: thinking.content
+			});
+			const text = textOf(message.content);
+			if (text) content.push({
+				type: "text",
+				text
+			});
+			for (const call of message.toolCalls ?? []) content.push({
+				type: "tool-call",
+				toolCallId: call.id,
+				toolName: call.function.name,
+				input: parseJson(call.function.arguments)
+			});
+			if (content.length > 0) prompt.push({
+				role: "assistant",
+				content
+			});
+			continue;
+		}
+		const toolCallId = message.toolCallId ?? "";
+		const part = {
+			type: "tool-result",
+			toolCallId,
+			toolName: toolNames.get(toolCallId) ?? message.name ?? "unknown",
+			output: toolOutput(message)
+		};
+		const last = prompt[prompt.length - 1];
+		if (last?.role === "tool") last.content.push(part);
+		else prompt.push({
+			role: "tool",
+			content: [part]
+		});
+	}
+	return prompt;
+}
+/**
+* V2/V3 file parts carry raw data (base64 string, bytes or URL) instead of V4's `{ type, ... }` wrapper,
+* and V2's tool result `content` output differs. Everything else in the prompt is the same shape.
+*/
+function toPromptForSpec(prompt, version) {
+	if (version === "v4") return prompt;
+	return prompt.map((message) => {
+		if (message.role !== "user" && message.role !== "assistant") return message;
+		return {
+			...message,
+			content: message.content.map((part) => {
+				if (part.type !== "file") return part;
+				const data = part.data;
+				const raw = data.type === "url" ? data.url : data.type === "data" ? data.data : void 0;
+				if (raw === void 0) throw new Error(`File data of type "${data.type}" needs an AI SDK v4 model.`);
+				return {
+					...part,
+					data: raw
+				};
+			})
+		};
+	});
+}
+function toAiSdkTools(tools) {
+	if (!tools || tools.length === 0) return void 0;
+	return tools.map((tool) => ({
+		type: "function",
+		name: tool.name,
+		description: tool.description,
+		inputSchema: tool.inputSchema ?? {
+			type: "object",
+			properties: {}
+		}
+	}));
+}
+function toAiSdkToolChoice(choice) {
+	if (choice === void 0) return void 0;
+	if (typeof choice === "string") return { type: choice };
+	return {
+		type: "tool",
+		toolName: choice.name
+	};
+}
+// src/usage.ts
+/** Maps AI SDK language-model usage (any spec version) to TanStack AI `TokenUsage`. */
+function languageModelUsage(usage) {
+	if (!usage) return void 0;
+	let input;
+	let output;
+	let total;
+	let cached;
+	let cacheWrite;
+	let reasoning;
+	if (typeof usage.inputTokens === "object" && usage.inputTokens !== null) {
+		const v3 = usage;
+		input = v3.inputTokens.total;
+		output = v3.outputTokens.total;
+		cached = v3.inputTokens.cacheRead;
+		cacheWrite = v3.inputTokens.cacheWrite;
+		reasoning = v3.outputTokens.reasoning;
+	} else {
+		const v2 = usage;
+		input = v2.inputTokens;
+		output = v2.outputTokens;
+		total = v2.totalTokens;
+		cached = v2.cachedInputTokens;
+		reasoning = v2.reasoningTokens;
+	}
+	if (input === void 0 && output === void 0 && total === void 0) return void 0;
+	const promptTokens = input ?? 0;
+	const completionTokens = output ?? 0;
+	const result = {
+		promptTokens,
+		completionTokens,
+		totalTokens: total ?? promptTokens + completionTokens
+	};
+	if (cached !== void 0 || cacheWrite !== void 0) result.promptTokensDetails = {
+		...cached !== void 0 && { cachedTokens: cached },
+		...cacheWrite !== void 0 && { cacheWriteTokens: cacheWrite }
+	};
+	if (reasoning !== void 0) result.completionTokensDetails = { reasoningTokens: reasoning };
+	return result;
+}
+// src/text.ts
+const SPECS$1 = [
+	"v2",
+	"v3",
+	"v4"
+];
+const REASONING = {
+	off: "none",
+	minimal: "minimal",
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh",
+	max: "max"
+};
+function finishReason(reason, sawToolCalls) {
+	if (sawToolCalls) return "tool_calls";
+	switch (typeof reason === "object" && reason !== null ? reason.unified : reason) {
+		case "length": return "length";
+		case "content-filter": return "content_filter";
+		case "tool-calls": return "tool_calls";
+		default: return "stop";
+	}
+}
+function parseObject(json) {
+	try {
+		const value = JSON.parse(json || "{}");
+		return value && typeof value === "object" ? value : void 0;
+	} catch {
+		return;
+	}
+}
+/** Parses a model's JSON answer, also when the model wrapped it in a Markdown code fence. */
+function parseJsonAnswer(text) {
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(text);
+		if (fenced?.[1]) return JSON.parse(fenced[1]);
+		throw error;
+	}
+}
+/** Replay-safe tool call ids: letters, digits, `_` and `-`, at most 64 characters. */
+function cleanToolCallId(id, { attempt }) {
+	const clean = id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+	return attempt === 0 ? clean : `${clean.slice(0, 50)}_${attempt}`;
+}
+/**
+* TanStack AI text adapter around an AI SDK language model.
+* Streams text, reasoning and tool calls as AG-UI events and maps usage and finish reasons.
+*/
+var AiSdkTextAdapter = class extends BaseTextAdapter {
+	name;
+	api = "ai-sdk";
+	provider;
+	inputModalities = [
+		"text",
+		"image",
+		"audio",
+		"video",
+		"document"
+	];
+	/** The wrapped AI SDK model. */
+	languageModel;
+	/** AI SDK spec version of the wrapped model. */
+	specificationVersion;
+	constructor(model, options) {
+		super({}, model.modelId);
+		this.specificationVersion = specVersionOf(model, "language", SPECS$1);
+		this.languageModel = model;
+		this.name = adapterName(model, options);
+		this.provider = this.name;
+	}
+	callOptions(options) {
+		const { messages } = transformMessagesForReplay(options.messages, {
+			provider: this.name,
+			api: this.api,
+			model: this.model
+		}, cleanToolCallId);
+		const prompt = toAiSdkPrompt({
+			messages,
+			systemPrompts: options.systemPrompts
+		}, this.name);
+		const { providerOptions, headers, ...sampling } = options.modelOptions ?? {};
+		const tools = toAiSdkTools(options.tools);
+		const toolChoice = tools ? toAiSdkToolChoice(options.toolChoice) : void 0;
+		const abortSignal = options.abortController?.signal ?? options.request?.signal ?? void 0;
+		const call = {
+			prompt: toPromptForSpec(prompt, this.specificationVersion),
+			...sampling,
+			...tools && { tools },
+			...toolChoice && { toolChoice },
+			...abortSignal && { abortSignal },
+			...headers && { headers },
+			...providerOptions && { providerOptions }
+		};
+		if (options.reasoning && this.specificationVersion === "v4") call.reasoning = REASONING[options.reasoning.level];
+		return call;
+	}
+	async *chatStream(options) {
+		const { logger } = options;
+		const source = {
+			provider: this.name,
+			api: this.api,
+			model: options.model
+		};
+		try {
+			const call = this.callOptions(options);
+			logger.request(`activity=chat provider=${this.name} model=${this.model} messages=${options.messages.length} tools=${options.tools?.length ?? 0} stream=true`, {
+				provider: this.name,
+				model: this.model
+			});
+			const stream = (await this.languageModel.doStream(call)).stream;
+			for await (const chunk of this.mapStream(stream, options, logger, call.abortSignal)) yield {
+				...chunk,
+				metadata: {
+					...chunk.metadata,
+					tanstack: {
+						...tanstackMetadata(chunk),
+						source
+					}
+				}
+			};
+		} catch (error) {
+			logger.errors(`${this.name}.chatStream fatal`, {
+				error,
+				source: `${this.name}.chatStream`
+			});
+			yield this.runError(error, options.model, source);
+		}
+	}
+	runError(error, model, source) {
+		const payload = toRunErrorPayload(error, "An unknown error occurred during the chat stream.");
+		return {
+			type: EventType.RUN_ERROR,
+			metadata: { tanstack: { source } },
+			model,
+			timestamp: Date.now(),
+			message: payload.message,
+			code: payload.code,
+			error: {
+				message: payload.message,
+				code: payload.code
+			}
+		};
+	}
+	async *mapStream(stream, options, logger, abortSignal) {
+		const runId = options.runId ?? randomId("run");
+		const threadId = options.threadId;
+		const messageId = randomId("msg");
+		let model = options.model;
+		let text = "";
+		let textOpen = false;
+		let reasoningId;
+		let finished = false;
+		const started = /* @__PURE__ */ new Map();
+		const skipped = /* @__PURE__ */ new Set();
+		let toolCallCount = 0;
+		yield {
+			type: EventType.RUN_STARTED,
+			runId,
+			threadId,
+			model,
+			timestamp: Date.now(),
+			parentRunId: options.parentRunId
+		};
+		const closeReasoning = function* () {
+			if (!reasoningId) return;
+			yield {
+				type: EventType.REASONING_MESSAGE_END,
+				messageId: reasoningId,
+				model,
+				timestamp: Date.now()
+			};
+			yield {
+				type: EventType.REASONING_END,
+				messageId: reasoningId,
+				model,
+				timestamp: Date.now()
+			};
+			reasoningId = void 0;
+		};
+		const reader = stream.getReader();
+		const onAbort = () => void reader.cancel().catch(() => void 0);
+		if (abortSignal?.aborted) onAbort();
+		else abortSignal?.addEventListener("abort", onAbort, { once: true });
+		try {
+			while (true) {
+				const { done, value: part } = await reader.read();
+				if (done) break;
+				logger.provider(`provider=${this.name}`, { chunk: part });
+				switch (part.type) {
+					case "response-metadata":
+						if (typeof part.modelId === "string") model = part.modelId;
+						break;
+					case "text-delta": {
+						const delta = String(part.delta ?? part.textDelta ?? "");
+						if (!delta) break;
+						yield* closeReasoning();
+						if (!textOpen) {
+							textOpen = true;
+							yield {
+								type: EventType.TEXT_MESSAGE_START,
+								messageId,
+								role: "assistant",
+								model,
+								timestamp: Date.now()
+							};
+						}
+						text += delta;
+						yield {
+							type: EventType.TEXT_MESSAGE_CONTENT,
+							messageId,
+							delta,
+							content: text,
+							model,
+							timestamp: Date.now()
+						};
+						break;
+					}
+					case "reasoning-start":
+					case "reasoning-delta": {
+						if (!reasoningId) {
+							reasoningId = randomId("reasoning");
+							yield {
+								type: EventType.REASONING_START,
+								messageId: reasoningId,
+								model,
+								timestamp: Date.now()
+							};
+							yield {
+								type: EventType.REASONING_MESSAGE_START,
+								messageId: reasoningId,
+								role: "reasoning",
+								model,
+								timestamp: Date.now()
+							};
+						}
+						const delta = part.type === "reasoning-delta" ? String(part.delta ?? "") : "";
+						if (delta) yield {
+							type: EventType.REASONING_MESSAGE_CONTENT,
+							messageId: reasoningId,
+							delta,
+							model,
+							timestamp: Date.now()
+						};
+						break;
+					}
+					case "reasoning-end":
+						yield* closeReasoning();
+						break;
+					case "tool-input-start": {
+						const id = String(part.id);
+						if (part.providerExecuted) {
+							skipped.add(id);
+							break;
+						}
+						yield* closeReasoning();
+						const name = String(part.toolName);
+						started.set(id, {
+							name,
+							args: "",
+							index: toolCallCount++
+						});
+						yield {
+							type: EventType.TOOL_CALL_START,
+							toolCallId: id,
+							toolCallName: name,
+							parentMessageId: messageId,
+							index: started.get(id)?.index,
+							model,
+							timestamp: Date.now()
+						};
+						break;
+					}
+					case "tool-input-delta": {
+						const id = String(part.id);
+						const call = started.get(id);
+						if (!call || skipped.has(id)) break;
+						const delta = String(part.delta ?? "");
+						call.args += delta;
+						yield {
+							type: EventType.TOOL_CALL_ARGS,
+							toolCallId: id,
+							delta,
+							args: call.args,
+							model,
+							timestamp: Date.now()
+						};
+						break;
+					}
+					case "tool-call": {
+						const id = String(part.toolCallId);
+						if (part.providerExecuted || skipped.has(id)) break;
+						const name = String(part.toolName);
+						const input = typeof part.input === "string" ? part.input : JSON.stringify(part.input ?? part.args ?? {});
+						let call = started.get(id);
+						if (!call) {
+							yield* closeReasoning();
+							call = {
+								name,
+								args: "",
+								index: toolCallCount++
+							};
+							started.set(id, call);
+							yield {
+								type: EventType.TOOL_CALL_START,
+								toolCallId: id,
+								toolCallName: name,
+								parentMessageId: messageId,
+								index: call.index,
+								model,
+								timestamp: Date.now()
+							};
+						}
+						if (call.args !== input) {
+							const delta = input.startsWith(call.args) ? input.slice(call.args.length) : input;
+							call.args = input;
+							if (delta) yield {
+								type: EventType.TOOL_CALL_ARGS,
+								toolCallId: id,
+								delta,
+								args: input,
+								model,
+								timestamp: Date.now()
+							};
+						}
+						const parsed = parseObject(input);
+						yield {
+							type: EventType.TOOL_CALL_END,
+							toolCallId: id,
+							toolCallName: name,
+							args: input,
+							...parsed !== void 0 && { input: parsed },
+							model,
+							timestamp: Date.now()
+						};
+						break;
+					}
+					case "error":
+						yield* closeReasoning();
+						yield this.runError(part.error, model, {
+							provider: this.name,
+							api: this.api,
+							model
+						});
+						return;
+					case "finish": {
+						yield* closeReasoning();
+						if (textOpen) {
+							textOpen = false;
+							yield {
+								type: EventType.TEXT_MESSAGE_END,
+								messageId,
+								model,
+								timestamp: Date.now()
+							};
+						}
+						const usage = languageModelUsage(part.usage);
+						finished = true;
+						yield {
+							type: EventType.RUN_FINISHED,
+							runId,
+							threadId,
+							model,
+							finishReason: finishReason(part.finishReason, toolCallCount > 0),
+							...usage && { usage },
+							timestamp: Date.now()
+						};
+						break;
+					}
+				}
+			}
+		} finally {
+			abortSignal?.removeEventListener("abort", onAbort);
+			reader.releaseLock();
+		}
+		if (!finished) {
+			yield* closeReasoning();
+			if (textOpen) yield {
+				type: EventType.TEXT_MESSAGE_END,
+				messageId,
+				model,
+				timestamp: Date.now()
+			};
+			yield {
+				type: EventType.RUN_FINISHED,
+				runId,
+				threadId,
+				model,
+				finishReason: toolCallCount > 0 ? "tool_calls" : "stop",
+				timestamp: Date.now()
+			};
+		}
+	}
+	async structuredOutput(options) {
+		const { chatOptions, outputSchema } = options;
+		const { logger } = chatOptions;
+		try {
+			const call = this.callOptions({
+				...chatOptions,
+				tools: void 0
+			});
+			call.responseFormat = {
+				type: "json",
+				schema: outputSchema
+			};
+			logger.request(`activity=chat provider=${this.name} model=${this.model} messages=${chatOptions.messages.length} stream=false structured=true`, {
+				provider: this.name,
+				model: this.model
+			});
+			const result = await this.languageModel.doGenerate(call);
+			const rawText = result.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+			if (finishReason(result.finishReason, false) === "length") throw new Error("the response was cut off at the maximum token limit; raise modelOptions.maxOutputTokens");
+			let data;
+			try {
+				data = parseJsonAnswer(rawText);
+			} catch {
+				throw new Error(`the model did not return valid JSON: ${rawText.slice(0, 200)}${rawText.length > 200 ? "..." : ""}`);
+			}
+			const usage = languageModelUsage(result.usage);
+			return {
+				data,
+				rawText,
+				...usage && { usage },
+				...result.response?.id && { responseId: result.response.id },
+				...result.response?.modelId && { model: result.response.modelId }
+			};
+		} catch (error) {
+			logger.errors(`${this.name}.structuredOutput fatal`, {
+				error,
+				source: `${this.name}.structuredOutput`
+			});
+			throw new Error(`Structured output generation failed: ${error?.message ?? String(error)}`, { cause: error });
+		}
+	}
+};
+/**
+* Wraps an AI SDK language model as a TanStack AI text adapter.
+*
+* @example
+* import { chat } from '@tanstack/ai'
+* import { deepseek } from '@ai-sdk/deepseek'
+* chat({ adapter: aiSdkText(deepseek('deepseek-chat')), messages, threadId })
+*/
+function aiSdkText(model, options) {
+	return new AiSdkTextAdapter(model, options);
+}
+// src/transcription.ts
+const SPECS = [
+	"v2",
+	"v3",
+	"v4"
+];
+async function toAudio(audio, fallbackType, signal) {
+	if (typeof audio === "string") {
+		if (/^https?:\/\//.test(audio)) {
+			const response = await fetch(audio, signal ? { signal } : void 0);
+			if (!response.ok) throw new Error(`Could not download audio (${response.status}) from ${audio}`);
+			return {
+				data: new Uint8Array(await response.arrayBuffer()),
+				mediaType: response.headers.get("content-type")?.split(";")[0] || fallbackType
+			};
+		}
+		const dataUrl = parseDataUrl(audio);
+		if (dataUrl) return {
+			data: base64ToBytes(dataUrl.base64),
+			mediaType: dataUrl.mediaType
+		};
+		return {
+			data: base64ToBytes(audio),
+			mediaType: fallbackType
+		};
+	}
+	if (audio instanceof ArrayBuffer) return {
+		data: new Uint8Array(audio),
+		mediaType: fallbackType
+	};
+	return {
+		data: new Uint8Array(await audio.arrayBuffer()),
+		mediaType: audio.type || fallbackType
+	};
+}
+/**
+* TanStack AI transcription adapter around an AI SDK transcription model.
+* `language` and `prompt` have no AI SDK equivalent: pass them in `modelOptions.providerOptions`.
+*/
+var AiSdkTranscriptionAdapter = class extends BaseTranscriptionAdapter {
+	name;
+	transcriptionModel;
+	specificationVersion;
+	constructor(model, options) {
+		super(model.modelId, {});
+		this.specificationVersion = specVersionOf(model, "transcription", SPECS);
+		this.transcriptionModel = model;
+		this.name = adapterName(model, options);
+	}
+	async transcribe(options) {
+		const { model, logger, modelOptions, abortSignal } = options;
+		try {
+			const audio = await toAudio(options.audio, modelOptions?.mediaType ?? "audio/mpeg", abortSignal);
+			logger.request(`activity=transcription provider=${this.name} model=${model} bytes=${audio.data.length}`, {
+				provider: this.name,
+				model
+			});
+			const result = await this.transcriptionModel.doGenerate({
+				audio: audio.data,
+				mediaType: audio.mediaType,
+				...callExtras(modelOptions, abortSignal)
+			});
+			return {
+				id: randomId(this.name),
+				model: result.response?.modelId ?? model,
+				text: result.text,
+				...result.language !== void 0 && { language: result.language },
+				...result.durationInSeconds !== void 0 && { duration: result.durationInSeconds },
+				...result.segments.length > 0 && { segments: result.segments.map((segment, id) => ({
+					id,
+					start: segment.startSecond,
+					end: segment.endSecond,
+					text: segment.text
+				})) }
+			};
+		} catch (error) {
+			logger.errors(`${this.name}.transcribe fatal`, {
+				error: toRunErrorPayload(error, `${this.name}.transcribe failed`),
+				source: `${this.name}.transcribe`
+			});
+			throw error;
+		}
+	}
+};
+/**
+* Wraps an AI SDK transcription model as a TanStack AI transcription adapter.
+*
+* @example
+* import { generateTranscription } from '@tanstack/ai'
+* import { openai } from '@ai-sdk/openai'
+* await generateTranscription({ threadId, adapter: aiSdkTranscription(openai.transcription('whisper-1')), audio: file })
+*/
+function aiSdkTranscription(model, options) {
+	return new AiSdkTranscriptionAdapter(model, options);
+}
+export { AiSdkEmbeddingAdapter, AiSdkImageAdapter, AiSdkRerankAdapter, AiSdkSpeechAdapter, AiSdkTextAdapter, AiSdkTranscriptionAdapter, aiSdkEmbedding, aiSdkImage, aiSdkRerank, aiSdkSpeech, aiSdkText, aiSdkTranscription };