@gedatou/cadenza-ai 0.7.1

package/dist/providers/deepseek.mjs

@@ -0,0 +1,283 @@
+import { t as deepseek$1 } from "../deepseek-C1b74T2F.mjs";
+import { i as deepseekResponsesThinking, t as definePreset } from "../preset-CEyIPxfS.mjs";
+import { openaiCompatiblePreset } from "./openai-compatible.mjs";
+import { EventType } from "@tanstack/ai";
+import { OpenAICompatibleResponsesAdapter, openaiCompatibleText } from "@tanstack/ai-openai/compatible";
+import { convertToolsToProviderFormat, webSearchTool } from "@tanstack/ai-openai/tools";
+//#region src/providers/deepseek.ts
+const BASE_URL = "https://api.deepseek.com";
+/** What the built-in search reports as. `sourcesOf` keys on a provider-executed call whose name matches `/search/i`. */
+const SEARCH_TOOL = "web_search";
+/**
+* A `web_search_call` output item wearing the `function_call` shape.
+*
+* The base adapter's stream handler only knows `function_call` items, so every
+* other kind — DeepSeek's server-side searches included — is dropped: no events,
+* no content, no trace. Dropping them is not merely lossy. The client's stream
+* processor keeps one text buffer per *message* and only clears it on
+* `TOOL_CALL_START`, while it starts a *new* text part whenever some other part
+* type lands in between. DeepSeek's search auto-continues up to 10 rounds inside
+* one response — reasoning, text, search, reasoning, text — so with the searches
+* invisible the reasoning splits the parts while nothing resets the buffer, and
+* every text block repeats all the earlier ones.
+*
+* Reporting the search as a tool call is therefore both the honest mapping and
+* the fix: it is what `@ai-sdk/openai` does with the same wire items, it gives
+* the run its segment boundaries back, and it puts the searches on screen.
+*/
+function asFunctionCall(event) {
+	const item = event.item;
+	if (item?.type !== "web_search_call" || item.id === void 0) return event;
+	return {
+		...event,
+		item: {
+			type: "function_call",
+			id: item.id,
+			call_id: item.id,
+			name: SEARCH_TOOL,
+			arguments: JSON.stringify(item.action ?? {})
+		}
+	};
+}
+async function* rewriteSearchCalls(stream) {
+	for await (const event of stream) {
+		const raw = event;
+		yield raw.type === "response.output_item.added" || raw.type === "response.output_item.done" ? asFunctionCall(raw) : raw;
+	}
+}
+function isAsyncIterable(value) {
+	return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+/**
+* The same client with `responses.create` teed through the rewrite — the base
+* reaches for nothing else on it. `Object.create` rather than a spread: these are
+* SDK class instances, so their methods live on the prototype.
+*/
+function withSearchCalls(client) {
+	const inner = client.responses;
+	const create = async (...args) => {
+		const result = await inner.create(...args);
+		return isAsyncIterable(result) ? rewriteSearchCalls(result) : result;
+	};
+	const responses = Object.create(inner, { create: { value: create } });
+	return Object.create(client, { responses: { value: responses } });
+}
+/**
+* The built-in searches in a history, keyed by the call id they were rewritten
+* under, each already shaped back into the `web_search_call` DeepSeek issued.
+*
+* Both conditions have to hold — `metadata.providerExecuted` *and* the name.
+* The metadata alone would restore any future provider-executed tool as a
+* search; the name alone would catch a consumer's own function called
+* `web_search`, which carries no such metadata. (`TranscriptParts` keys on the
+* metadata alone, because there the question is only "did we run it".)
+*/
+function restorableSearches(messages) {
+	const searches = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		if (message.role !== "assistant") continue;
+		for (const toolCall of message.toolCalls ?? []) {
+			const metadata = toolCall.metadata;
+			if (metadata?.providerExecuted !== true || toolCall.function.name !== SEARCH_TOOL) continue;
+			const raw = toolCall.function.arguments;
+			let action;
+			try {
+				action = typeof raw === "string" ? JSON.parse(raw) : raw;
+			} catch {
+				continue;
+			}
+			if (typeof action !== "object" || action === null) continue;
+			searches.set(toolCall.id, {
+				type: "web_search_call",
+				id: metadata.itemId ?? toolCall.id,
+				action,
+				status: "completed"
+			});
+		}
+	}
+	return searches;
+}
+/**
+* The compatible Responses adapter with one fix: its base converts *every* tool
+* with `convertToolsToResponsesFormat`, which forces `{ type: 'function' }` and
+* so degrades a provider tool into a schema-less function call nothing can
+* execute. Routing through `convertToolsToProviderFormat` — which dispatches on
+* the tool's private `metadata.__kind` — is exactly what `OpenAITextAdapter`
+* does for the same reason, and is what lets `deepseekWebSearch()` reach the
+* wire as `{ type: 'web_search' }`.
+*
+* Module-private: its declaration would need the openai SDK's types, which this
+* package cannot name; `deepseek.create()` is the way to one.
+*/
+var DeepSeekResponsesAdapter = class extends OpenAICompatibleResponsesAdapter {
+	constructor(client, model) {
+		super(client, model, "deepseek");
+		let wrapped = withSearchCalls(client);
+		Object.defineProperty(this, "client", {
+			configurable: true,
+			get: () => wrapped,
+			set: (next) => {
+				wrapped = withSearchCalls(next);
+			}
+		});
+	}
+	/**
+	* Mark the rewritten search calls provider-executed. Without it the agent loop
+	* would count them as pending client work forever (`isProviderExecutedToolCall`
+	* gates that in `@tanstack/ai`), and the tool card would spin: the processor
+	* treats a provider-executed call as already complete.
+	*/
+	async *chatStream(options) {
+		const searches = /* @__PURE__ */ new Set();
+		for await (const chunk of super.chatStream(options)) {
+			const event = chunk;
+			if (event.type === EventType.TOOL_CALL_START && event.toolName === SEARCH_TOOL && event.toolCallId !== void 0) {
+				searches.add(event.toolCallId);
+				yield {
+					...chunk,
+					metadata: {
+						...event.metadata,
+						providerExecuted: true
+					}
+				};
+				continue;
+			}
+			yield chunk;
+			if (event.type !== EventType.TOOL_CALL_END || event.toolCallId === void 0 || !searches.delete(event.toolCallId)) continue;
+			yield {
+				type: EventType.TOOL_CALL_RESULT,
+				toolCallId: event.toolCallId,
+				toolCallName: SEARCH_TOOL,
+				messageId: `${event.toolCallId}-result`,
+				role: "tool",
+				content: JSON.stringify(event.input ?? {}),
+				timestamp: Date.now()
+			};
+		}
+	}
+	/**
+	* Rebuild one assistant turn the way DeepSeek wants to read it back.
+	*
+	* Two things have to be true at once, both measured against the live API on
+	* 2026-08-30 rather than reasoned about:
+	*
+	* 1. **Every `function_call` must sit next to its `function_call_output`.**
+	*    The base emits an assistant message as `[...function_call, message]`
+	*    while the outputs arrive as the *next* messages, so a turn that called a
+	*    tool and then answered replays as `function_call → message →
+	*    function_call_output`. DeepSeek documents `function_call` as "merged into
+	*    the adjacent assistant message": the call is folded into the message
+	*    behind it, that turn closes, and the output left over pairs with nothing
+	*    — `400 No tool output found for tool call <call_id>` on the user's next
+	*    question, every time the previous one used a tool. A `web_search_call`
+	*    between the two breaks it in exactly the same way.
+	* 2. **A built-in search must go back as the `web_search_call` it was.** We
+	*    rewrite those items into `function_call`s on the way in, because that is
+	*    the only signal that keeps the client's text segments apart (see
+	*    `asFunctionCall`) — but the rewrite must not reach the wire. DeepSeek
+	*    "automatically restores the search results" for a `web_search_call`
+	*    passed back as-is; hand it the rewritten `function_call` instead and the
+	*    results are gone, so the model searches again on every follow-up.
+	*
+	* Hence the order `[assistant message, calls, outputs, searches]`. The search
+	* items carry no output of their own, so their own `function_call_output` is
+	* dropped. A search whose action no longer parses simply stays a plain
+	* function call: accepted too, only costing the re-search.
+	*/
+	convertMessagesToInput(messages) {
+		const searches = restorableSearches(messages);
+		const input = super.convertMessagesToInput(messages);
+		const output = [];
+		for (let i = 0; i < input.length;) {
+			if (input[i].type !== "function_call") {
+				output.push(input[i]);
+				i += 1;
+				continue;
+			}
+			const calls = [];
+			const restored = [];
+			let end = i;
+			while (end < input.length && input[end].type === "function_call") {
+				const search = searches.get(String(input[end].call_id));
+				if (search === void 0) calls.push(input[end]);
+				else restored.push(search);
+				end += 1;
+			}
+			const next = input[end];
+			const message = next?.type === "message" && next.role === "assistant" ? next : void 0;
+			if (message !== void 0) end += 1;
+			const outputs = [];
+			while (end < input.length && input[end].type === "function_call_output") {
+				if (!searches.has(String(input[end].call_id))) outputs.push(input[end]);
+				end += 1;
+			}
+			if (message !== void 0) output.push(message);
+			output.push(...calls, ...outputs, ...restored);
+			i = end;
+		}
+		return output;
+	}
+	mapOptionsToRequest(options) {
+		const { tools: _dropped, ...request } = super.mapOptionsToRequest({
+			...options,
+			tools: void 0
+		});
+		const tools = options.tools ? convertToolsToProviderFormat(options.tools) : void 0;
+		return tools !== void 0 && tools.length > 0 ? {
+			...request,
+			tools
+		} : request;
+	}
+};
+/**
+* DeepSeek's server-side web search: the model searches, opens and reads pages
+* itself (auto-continuing up to 10 rounds) before answering, and nothing is
+* executed on our side. Only the Responses endpoint has it — Chat Completions
+* still documents `function` as the one tool type.
+*
+* The wire shape is OpenAI's, so this is that factory; DeepSeek ignores the
+* extra `search_context_size` / `user_location` fields it can carry.
+*
+* Hand it to `createChatHandler` through the *function* form of `tools`, so it
+* only ever reaches DeepSeek:
+*
+* ```ts
+* tools: sel => sel.preset.id === 'deepseek' ? [deepseekWebSearch()] : []
+* ```
+*/
+function deepseekWebSearch() {
+	return webSearchTool({ type: "web_search" });
+}
+const compatible = openaiCompatiblePreset({
+	id: deepseek$1.id,
+	label: deepseek$1.label,
+	baseURL: BASE_URL,
+	env: "DEEPSEEK_API_KEY",
+	models: deepseek$1.models,
+	api: "responses",
+	thinking: deepseekResponsesThinking
+});
+/**
+* DeepSeek speaks three protocols under one host and they are not equal: only
+* `/responses` carries the built-in `web_search` tool, and only there does
+* thinking arrive as the standard `response.reasoning_text.delta` (which the
+* base adapter already parses) instead of Chat Completions'
+* `delta.reasoning_content` (which it ignores, and which forced a hand-written
+* subclass plus `reasoning_content` echo on every assistant turn). So the
+* preset is the compatible one over `/responses`, with the adapter swapped for
+* the tool-converter fix above. The `openai` client is borrowed from the
+* compatible factory: this package cannot resolve the SDK itself.
+*/
+const deepseek = definePreset({
+	...compatible,
+	create: (model, key) => {
+		return new DeepSeekResponsesAdapter(openaiCompatibleText(model, {
+			baseURL: BASE_URL,
+			apiKey: key ?? "",
+			name: "deepseek",
+			api: "responses"
+		}).client, model);
+	}
+});
+//#endregion
+export { deepseek, deepseekWebSearch };

package/dist/providers/gemini.d.mts

@@ -0,0 +1,6 @@
+import { t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import "../server/index.mjs";
+//#region src/providers/gemini.d.ts
+declare const gemini: ProviderPreset;
+//#endregion
+export { gemini };

package/dist/providers/gemini.mjs

@@ -0,0 +1,11 @@
+import { t as gemini$1 } from "../gemini-DcJ5Kr3h.mjs";
+import { o as geminiThinking, t as definePreset } from "../preset-CEyIPxfS.mjs";
+import { createGeminiChat } from "@tanstack/ai-gemini";
+//#region src/providers/gemini.ts
+const gemini = definePreset({
+	...gemini$1,
+	create: (model, key) => createGeminiChat(model, key ?? ""),
+	thinking: geminiThinking
+});
+//#endregion
+export { gemini };

package/dist/providers/grok.d.mts

@@ -0,0 +1,6 @@
+import { t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import "../server/index.mjs";
+//#region src/providers/grok.d.ts
+declare const grok: ProviderPreset;
+//#endregion
+export { grok };

package/dist/providers/grok.mjs

@@ -0,0 +1,11 @@
+import { t as grok$1 } from "../grok-CffQuBd6.mjs";
+import { s as grokThinking, t as definePreset } from "../preset-CEyIPxfS.mjs";
+import { createGrokText } from "@tanstack/ai-grok";
+//#region src/providers/grok.ts
+const grok = definePreset({
+	...grok$1,
+	create: (model, key) => createGrokText(model, key ?? ""),
+	thinking: grokThinking
+});
+//#endregion
+export { grok };

package/dist/providers/groq.d.mts

@@ -0,0 +1,6 @@
+import { t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import "../server/index.mjs";
+//#region src/providers/groq.d.ts
+declare const groq: ProviderPreset;
+//#endregion
+export { groq };

package/dist/providers/groq.mjs

@@ -0,0 +1,11 @@
+import { t as groq$1 } from "../groq-Ba6TTYLp.mjs";
+import { c as groqThinking, t as definePreset } from "../preset-CEyIPxfS.mjs";
+import { createGroqText } from "@tanstack/ai-groq";
+//#region src/providers/groq.ts
+const groq = definePreset({
+	...groq$1,
+	create: (model, key) => createGroqText(model, key ?? ""),
+	thinking: groqThinking
+});
+//#endregion
+export { groq };

package/dist/providers/llmgateway.d.mts

@@ -0,0 +1,6 @@
+import { t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import "../server/index.mjs";
+//#region src/providers/llmgateway.d.ts
+declare const llmgateway: ProviderPreset;
+//#endregion
+export { llmgateway };

package/dist/providers/llmgateway.mjs

@@ -0,0 +1,11 @@
+import { t as llmgateway$1 } from "../llmgateway-Pt5CS6aQ.mjs";
+import { l as llmgatewayThinking, t as definePreset } from "../preset-CEyIPxfS.mjs";
+import { createLLMGatewayText } from "@tanstack/ai-llmgateway";
+//#region src/providers/llmgateway.ts
+const llmgateway = definePreset({
+	...llmgateway$1,
+	create: (model, key) => createLLMGatewayText(model, key ?? ""),
+	thinking: llmgatewayThinking
+});
+//#endregion
+export { llmgateway };

package/dist/providers/mistral.d.mts

@@ -0,0 +1,6 @@
+import { t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import "../server/index.mjs";
+//#region src/providers/mistral.d.ts
+declare const mistral: ProviderPreset;
+//#endregion
+export { mistral };

package/dist/providers/mistral.mjs

@@ -0,0 +1,11 @@
+import { t as mistral$1 } from "../mistral-BGMwwbU9.mjs";
+import { t as definePreset, u as noThinking } from "../preset-CEyIPxfS.mjs";
+import { createMistralText } from "@tanstack/ai-mistral";
+//#region src/providers/mistral.ts
+const mistral = definePreset({
+	...mistral$1,
+	create: (model, key) => createMistralText(model, key ?? ""),
+	thinking: noThinking
+});
+//#endregion
+export { mistral };

package/dist/providers/ollama.d.mts

@@ -0,0 +1,9 @@
+import { r as Model } from "../types-56Hn7Qq2.mjs";
+import { t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import "../server/index.mjs";
+//#region src/providers/ollama.d.ts
+/** `GET {host}/api/tags` → one `Model` per installed tag; catalog metadata wins when the tag is known. */
+declare function discoverOllamaModels(host: string): Promise<Model[]>;
+declare const ollama: ProviderPreset;
+//#endregion
+export { discoverOllamaModels, ollama };

package/dist/providers/ollama.mjs

@@ -0,0 +1,28 @@
+import { t as ollama$1 } from "../ollama-BBJs-3mK.mjs";
+import { d as ollamaThinking, t as definePreset } from "../preset-CEyIPxfS.mjs";
+import { createOllamaChat, ollamaText } from "@tanstack/ai-ollama";
+//#region src/providers/ollama.ts
+function defaultHost() {
+	const host = process.env.OLLAMA_HOST;
+	return host !== void 0 && host !== "" ? host : "http://localhost:11434";
+}
+/** `GET {host}/api/tags` → one `Model` per installed tag; catalog metadata wins when the tag is known. */
+async function discoverOllamaModels(host) {
+	const res = await fetch(`${host.replace(/\/$/, "")}/api/tags`);
+	if (!res.ok) throw new Error(`Ollama ${host} answered ${res.status}`);
+	return ((await res.json()).models ?? []).map(({ name }) => ollama$1.models.find((m) => m.id === name) ?? {
+		id: name,
+		name,
+		provider: "ollama",
+		input: ["text"],
+		reasoning: false
+	});
+}
+const ollama = definePreset({
+	...ollama$1,
+	create: (model, key) => key !== null ? createOllamaChat(model, key) : ollamaText(model),
+	thinking: ollamaThinking,
+	discoverModels: (key) => discoverOllamaModels(key ?? defaultHost())
+});
+//#endregion
+export { discoverOllamaModels, ollama };

package/dist/providers/openai-compatible.d.mts

@@ -0,0 +1,32 @@
+import { r as Model } from "../types-56Hn7Qq2.mjs";
+import { t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import { CompatibleApi } from "@tanstack/ai-openai/compatible";
+//#region src/providers/openai-compatible.d.ts
+interface OpenAICompatibleConfig {
+  /** BYOK slug (`x-byok-<id>`), `/^[a-z][a-z0-9-]{0,63}$/`. */
+  id: string;
+  label: string;
+  baseURL: string;
+  /** Env names `getByokKey` may fall back to, in order. */
+  env?: string | readonly string[];
+  models: readonly Model[];
+  /**
+   * Which OpenAI protocol the endpoint speaks. Default `'chat-completions'`
+   * (`{baseURL}/chat/completions`); `'responses'` targets `{baseURL}/responses`,
+   * which a few compatible vendors implement — and where their built-in tools
+   * (DeepSeek's `web_search`) and native reasoning events live.
+   */
+  api?: CompatibleApi;
+  /** Defaults to `openaiCompatibleThinking` (`reasoning_effort` for reasoning models). */
+  thinking?: ProviderPreset['thinking'];
+  /** Adapter name shown in TanStack AI's events / debug output; defaults to `id`. */
+  name?: string;
+}
+/**
+ * The one entry point for a consumer-defined provider: any endpoint speaking the
+ * OpenAI Chat Completions / Responses protocol. The catalog half (`Provider`)
+ * is the same object minus `create` / `thinking`, so hand it to `withProvider` too.
+ */
+declare function openaiCompatiblePreset(config: OpenAICompatibleConfig): ProviderPreset;
+//#endregion
+export { OpenAICompatibleConfig, openaiCompatiblePreset };

package/dist/providers/openai-compatible.mjs

@@ -0,0 +1,45 @@
+import { f as openaiCompatibleThinking, t as definePreset } from "../preset-CEyIPxfS.mjs";
+import { defineByokProvider } from "@tanstack/ai/byok";
+import { openaiCompatibleText } from "@tanstack/ai-openai/compatible";
+//#region src/providers/openai-compatible.ts
+/** `GET {baseURL}/models` (Bearer key) → `data[].id`; catalog metadata wins when the id is known. */
+async function discoverCompatibleModels(config, key) {
+	const res = await fetch(`${config.baseURL.replace(/\/$/, "")}/models`, { headers: key !== null ? { authorization: `Bearer ${key}` } : {} });
+	if (!res.ok) throw new Error(`${config.label} answered ${res.status}`);
+	return ((await res.json()).data ?? []).map(({ id }) => config.models.find((m) => m.id === id) ?? {
+		id,
+		name: id,
+		provider: config.id,
+		input: ["text"],
+		reasoning: false
+	});
+}
+/**
+* The one entry point for a consumer-defined provider: any endpoint speaking the
+* OpenAI Chat Completions / Responses protocol. The catalog half (`Provider`)
+* is the same object minus `create` / `thinking`, so hand it to `withProvider` too.
+*/
+function openaiCompatiblePreset(config) {
+	return definePreset({
+		id: config.id,
+		label: config.label,
+		byok: defineByokProvider({
+			id: config.id,
+			label: config.label,
+			env: config.env
+		}),
+		keyRequired: true,
+		runtime: "node",
+		models: config.models,
+		create: (model, key) => openaiCompatibleText(model, {
+			baseURL: config.baseURL,
+			apiKey: key ?? "",
+			name: config.name ?? config.id,
+			api: config.api
+		}),
+		thinking: config.thinking ?? openaiCompatibleThinking,
+		discoverModels: (key) => discoverCompatibleModels(config, key)
+	});
+}
+//#endregion
+export { openaiCompatiblePreset };

package/dist/providers/openai.d.mts

@@ -0,0 +1,6 @@
+import { t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import "../server/index.mjs";
+//#region src/providers/openai.d.ts
+declare const openai: ProviderPreset;
+//#endregion
+export { openai };

package/dist/providers/openai.mjs

@@ -0,0 +1,11 @@
+import { t as openai$1 } from "../openai--FIeahIH.mjs";
+import { p as openaiThinking, t as definePreset } from "../preset-CEyIPxfS.mjs";
+import { createOpenaiChat } from "@tanstack/ai-openai";
+//#region src/providers/openai.ts
+const openai = definePreset({
+	...openai$1,
+	create: (model, key) => createOpenaiChat(model, key ?? ""),
+	thinking: openaiThinking
+});
+//#endregion
+export { openai };

package/dist/providers/openrouter.d.mts

@@ -0,0 +1,6 @@
+import { t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import "../server/index.mjs";
+//#region src/providers/openrouter.d.ts
+declare const openrouter: ProviderPreset;
+//#endregion
+export { openrouter };

package/dist/providers/openrouter.mjs

@@ -0,0 +1,11 @@
+import { t as openrouter$1 } from "../openrouter-q-lx-2Cb.mjs";
+import { m as openrouterThinking, t as definePreset } from "../preset-CEyIPxfS.mjs";
+import { createOpenRouterText } from "@tanstack/ai-openrouter";
+//#region src/providers/openrouter.ts
+const openrouter = definePreset({
+	...openrouter$1,
+	create: (model, key) => createOpenRouterText(model, key ?? ""),
+	thinking: openrouterThinking
+});
+//#endregion
+export { openrouter };

package/dist/providers/vercel-gateway.d.mts

@@ -0,0 +1,6 @@
+import { t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import "../server/index.mjs";
+//#region src/providers/vercel-gateway.d.ts
+declare const vercelGateway: ProviderPreset;
+//#endregion
+export { vercelGateway };

package/dist/providers/vercel-gateway.mjs

@@ -0,0 +1,11 @@
+import { t as vercelGateway$1 } from "../vercel-gateway-DW3Z0Os1.mjs";
+import { g as vercelGatewayThinking, t as definePreset } from "../preset-CEyIPxfS.mjs";
+import { createVercelGatewayText } from "@tanstack/ai-vercel-gateway";
+//#region src/providers/vercel-gateway.ts
+const vercelGateway = definePreset({
+	...vercelGateway$1,
+	create: (model, key) => createVercelGatewayText(model, key ?? "", { api: "chat" }),
+	thinking: vercelGatewayThinking
+});
+//#endregion
+export { vercelGateway };

package/dist/providers/vertex.d.mts

@@ -0,0 +1,6 @@
+import { t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import "../server/index.mjs";
+//#region src/providers/vertex.d.ts
+declare const vertex: ProviderPreset;
+//#endregion
+export { vertex };

package/dist/providers/vertex.mjs

@@ -0,0 +1,11 @@
+import { t as vertex$1 } from "../vertex-hg4Dt54O.mjs";
+import { o as geminiThinking, t as definePreset } from "../preset-CEyIPxfS.mjs";
+import { vertexText } from "@tanstack/ai-vertex";
+//#region src/providers/vertex.ts
+const vertex = definePreset({
+	...vertex$1,
+	create: (model, key) => vertexText(model, key !== null ? { apiKey: key } : void 0),
+	thinking: geminiThinking
+});
+//#endregion
+export { vertex };