@tanstack/ai-llmgateway 0.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,94 @@
+# @tanstack/ai-llmgateway
+
+[LLM Gateway](https://llmgateway.io) adapter for TanStack AI — one OpenAI-compatible endpoint that routes chat, tool calling, and structured outputs to hundreds of models across many providers.
+
+## Installation
+
+```bash
+npm install @tanstack/ai-llmgateway
+# or
+pnpm add @tanstack/ai-llmgateway
+# or
+yarn add @tanstack/ai-llmgateway
+```
+
+## Setup
+
+Get your API key from the [LLM Gateway dashboard](https://llmgateway.io) and set it as an environment variable:
+
+```bash
+export LLM_GATEWAY_API_KEY="llmgtwy_..."
+```
+
+## Usage
+
+### Text/Chat Adapter
+
+```typescript
+import { llmGatewayText } from '@tanstack/ai-llmgateway'
+import { chat } from '@tanstack/ai'
+
+const stream = chat({
+  adapter: llmGatewayText('gpt-5.6-terra'),
+  messages: [
+    { role: 'user', content: 'Explain quantum computing in simple terms' },
+  ],
+})
+```
+
+### With Explicit API Key
+
+```typescript
+import { createLLMGatewayText } from '@tanstack/ai-llmgateway'
+
+const adapter = createLLMGatewayText('gpt-5.6-terra', 'llmgtwy_api_key')
+```
+
+### Self-Hosted Gateways
+
+LLM Gateway is open source and self-hostable — point `baseURL` at your own deployment:
+
+```typescript
+import { createLLMGatewayText } from '@tanstack/ai-llmgateway'
+
+const adapter = createLLMGatewayText('gpt-5.6-terra', 'llmgtwy_api_key', {
+  baseURL: 'https://gateway.example.com/v1',
+})
+```
+
+## Models
+
+Any model listed on [llmgateway.io/models](https://llmgateway.io/models) works — pass its id as the model name. A curated set of flagship models additionally carries per-model type metadata (input modalities, provider options) with autocomplete, including `gpt-5.6-terra`, `claude-sonnet-5`, `gemini-pro-latest`, `kimi-k3`, `glm-5.2`, `deepseek-v4-pro`, and more (see `LLMGATEWAY_CHAT_MODELS`).
+
+Model ids accept an optional `provider/` prefix to pin routing to a specific provider:
+
+```typescript
+llmGatewayText('kimi-k3') // gateway picks the best available provider
+llmGatewayText('moonshot/kimi-k3') // always routed to Moonshot
+```
+
+## Features
+
+- ✅ Streaming chat completions
+- ✅ Structured output (JSON Schema)
+- ✅ Function/tool calling
+- ✅ Multimodal input (text + images for vision models)
+- ✅ Reasoning output (`reasoning_content` deltas from reasoning models)
+- ✅ Summarization (`llmGatewaySummarize`)
+
+## Tree-Shakeable Adapters
+
+This package uses tree-shakeable adapters, so you only import what you need:
+
+```typescript
+// Text/chat only
+import { llmGatewayText } from '@tanstack/ai-llmgateway'
+
+// Summarization only
+import { llmGatewaySummarize } from '@tanstack/ai-llmgateway'
+```
+
+## Documentation
+
+- [TanStack AI Documentation](https://tanstack.com/ai)
+- [LLM Gateway Documentation](https://docs.llmgateway.io)

package/dist/esm/adapters/summarize.d.ts

@@ -0,0 +1,51 @@
+import { ChatStreamSummarizeAdapter, InferTextProviderOptions } from '@tanstack/ai/adapters';
+import { LLMGatewayTextAdapter } from './text.js';
+import { LLMGatewayModelId } from '../model-meta.js';
+import { LLMGatewayClientConfig } from '../utils/client.js';
+/**
+ * Configuration for LLM Gateway summarize adapter
+ */
+export interface LLMGatewaySummarizeConfig extends LLMGatewayClientConfig {
+}
+/** Model type for LLM Gateway summarization */
+export type LLMGatewaySummarizeModel = LLMGatewayModelId;
+/**
+ * Creates an LLM Gateway summarize adapter with explicit API key.
+ * Type resolution happens here at the call site.
+ *
+ * @param model - The model id (e.g., 'gpt-5.6-terra')
+ * @param apiKey - Your LLM Gateway API key
+ * @param config - Optional additional configuration
+ * @returns Configured LLM Gateway summarize adapter instance with resolved types
+ *
+ * @example
+ * ```typescript
+ * const adapter = createLLMGatewaySummarize('gpt-5.6-terra', "llmgtwy_...");
+ * ```
+ */
+export declare function createLLMGatewaySummarize<TModel extends LLMGatewaySummarizeModel>(model: TModel, apiKey: string, config?: Omit<LLMGatewaySummarizeConfig, 'apiKey'>): ChatStreamSummarizeAdapter<TModel, InferTextProviderOptions<LLMGatewayTextAdapter<TModel>>>;
+/**
+ * Creates an LLM Gateway summarize adapter with automatic API key detection
+ * from environment variables. Type resolution happens here at the call site.
+ *
+ * Looks for `LLM_GATEWAY_API_KEY` in:
+ * - `process.env` (Node.js)
+ * - `window.env` (Browser with injected env)
+ *
+ * @param model - The model id (e.g., 'gpt-5.6-terra')
+ * @param config - Optional configuration (excluding apiKey which is auto-detected)
+ * @returns Configured LLM Gateway summarize adapter instance with resolved types
+ * @throws Error if LLM_GATEWAY_API_KEY is not found in environment
+ *
+ * @example
+ * ```typescript
+ * // Automatically uses LLM_GATEWAY_API_KEY from environment
+ * const adapter = llmGatewaySummarize('gpt-5.6-terra');
+ *
+ * await summarize({
+ *   adapter,
+ *   text: "Long article text..."
+ * });
+ * ```
+ */
+export declare function llmGatewaySummarize<TModel extends LLMGatewaySummarizeModel>(model: TModel, config?: Omit<LLMGatewaySummarizeConfig, 'apiKey'>): ChatStreamSummarizeAdapter<TModel, InferTextProviderOptions<LLMGatewayTextAdapter<TModel>>>;

package/dist/esm/adapters/summarize.js

@@ -0,0 +1,55 @@
+import { getLLMGatewayApiKeyFromEnv } from "../utils/client.js";
+import { LLMGatewayTextAdapter } from "./text.js";
+import { ChatStreamSummarizeAdapter } from "@tanstack/ai/adapters";
+//#region src/adapters/summarize.ts
+/**
+* Creates an LLM Gateway summarize adapter with explicit API key.
+* Type resolution happens here at the call site.
+*
+* @param model - The model id (e.g., 'gpt-5.6-terra')
+* @param apiKey - Your LLM Gateway API key
+* @param config - Optional additional configuration
+* @returns Configured LLM Gateway summarize adapter instance with resolved types
+*
+* @example
+* ```typescript
+* const adapter = createLLMGatewaySummarize('gpt-5.6-terra', "llmgtwy_...");
+* ```
+*/
+function createLLMGatewaySummarize(model, apiKey, config) {
+	return new ChatStreamSummarizeAdapter(new LLMGatewayTextAdapter({
+		apiKey,
+		...config
+	}, model), model, "llmgateway");
+}
+/**
+* Creates an LLM Gateway summarize adapter with automatic API key detection
+* from environment variables. Type resolution happens here at the call site.
+*
+* Looks for `LLM_GATEWAY_API_KEY` in:
+* - `process.env` (Node.js)
+* - `window.env` (Browser with injected env)
+*
+* @param model - The model id (e.g., 'gpt-5.6-terra')
+* @param config - Optional configuration (excluding apiKey which is auto-detected)
+* @returns Configured LLM Gateway summarize adapter instance with resolved types
+* @throws Error if LLM_GATEWAY_API_KEY is not found in environment
+*
+* @example
+* ```typescript
+* // Automatically uses LLM_GATEWAY_API_KEY from environment
+* const adapter = llmGatewaySummarize('gpt-5.6-terra');
+*
+* await summarize({
+*   adapter,
+*   text: "Long article text..."
+* });
+* ```
+*/
+function llmGatewaySummarize(model, config) {
+	return createLLMGatewaySummarize(model, getLLMGatewayApiKeyFromEnv(), config);
+}
+//#endregion
+export { createLLMGatewaySummarize, llmGatewaySummarize };
+
+//# sourceMappingURL=summarize.js.map

package/dist/esm/adapters/summarize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarize.js","names":[],"sources":["../../../src/adapters/summarize.ts"],"sourcesContent":["import { ChatStreamSummarizeAdapter } from '@tanstack/ai/adapters'\nimport { getLLMGatewayApiKeyFromEnv } from '../utils/client'\nimport { LLMGatewayTextAdapter } from './text'\nimport type { InferTextProviderOptions } from '@tanstack/ai/adapters'\nimport type { LLMGatewayModelId } from '../model-meta'\nimport type { LLMGatewayClientConfig } from '../utils/client'\n\n/**\n * Configuration for LLM Gateway summarize adapter\n */\nexport interface LLMGatewaySummarizeConfig extends LLMGatewayClientConfig {}\n\n/** Model type for LLM Gateway summarization */\nexport type LLMGatewaySummarizeModel = LLMGatewayModelId\n\n/**\n * Creates an LLM Gateway summarize adapter with explicit API key.\n * Type resolution happens here at the call site.\n *\n * @param model - The model id (e.g., 'gpt-5.6-terra')\n * @param apiKey - Your LLM Gateway API key\n * @param config - Optional additional configuration\n * @returns Configured LLM Gateway summarize adapter instance with resolved types\n *\n * @example\n * ```typescript\n * const adapter = createLLMGatewaySummarize('gpt-5.6-terra', \"llmgtwy_...\");\n * ```\n */\nexport function createLLMGatewaySummarize<\n  TModel extends LLMGatewaySummarizeModel,\n>(\n  model: TModel,\n  apiKey: string,\n  config?: Omit<LLMGatewaySummarizeConfig, 'apiKey'>,\n): ChatStreamSummarizeAdapter<\n  TModel,\n  InferTextProviderOptions<LLMGatewayTextAdapter<TModel>>\n> {\n  return new ChatStreamSummarizeAdapter(\n    new LLMGatewayTextAdapter({ apiKey, ...config }, model),\n    model,\n    'llmgateway',\n  )\n}\n\n/**\n * Creates an LLM Gateway summarize adapter with automatic API key detection\n * from environment variables. Type resolution happens here at the call site.\n *\n * Looks for `LLM_GATEWAY_API_KEY` in:\n * - `process.env` (Node.js)\n * - `window.env` (Browser with injected env)\n *\n * @param model - The model id (e.g., 'gpt-5.6-terra')\n * @param config - Optional configuration (excluding apiKey which is auto-detected)\n * @returns Configured LLM Gateway summarize adapter instance with resolved types\n * @throws Error if LLM_GATEWAY_API_KEY is not found in environment\n *\n * @example\n * ```typescript\n * // Automatically uses LLM_GATEWAY_API_KEY from environment\n * const adapter = llmGatewaySummarize('gpt-5.6-terra');\n *\n * await summarize({\n *   adapter,\n *   text: \"Long article text...\"\n * });\n * ```\n */\nexport function llmGatewaySummarize<TModel extends LLMGatewaySummarizeModel>(\n  model: TModel,\n  config?: Omit<LLMGatewaySummarizeConfig, 'apiKey'>,\n): ChatStreamSummarizeAdapter<\n  TModel,\n  InferTextProviderOptions<LLMGatewayTextAdapter<TModel>>\n> {\n  return createLLMGatewaySummarize(model, getLLMGatewayApiKeyFromEnv(), config)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA6BA,SAAgB,0BAGd,OACA,QACA,QAIA;CACA,OAAO,IAAI,2BACT,IAAI,sBAAsB;EAAE;EAAQ,GAAG;CAAO,GAAG,KAAK,GACtD,OACA,YACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,oBACd,OACA,QAIA;CACA,OAAO,0BAA0B,OAAO,2BAA2B,GAAG,MAAM;AAC9E"}

package/dist/esm/adapters/text.d.ts

@@ -0,0 +1,64 @@
+import { default as OpenAI } from 'openai';
+import { OpenAIBaseChatCompletionsTextAdapter } from '@tanstack/openai-base';
+import { Modality } from '@tanstack/ai';
+import { LLMGatewayChatModelToolCapabilitiesByName, LLMGatewayModelId, ResolveInputModalities, ResolveProviderOptions } from '../model-meta.js';
+import { LLMGatewayMessageMetadataByModality } from '../message-types.js';
+import { LLMGatewayClientConfig } from '../utils/client.js';
+type ResolveToolCapabilities<TModel extends string> = TModel extends keyof LLMGatewayChatModelToolCapabilitiesByName ? NonNullable<LLMGatewayChatModelToolCapabilitiesByName[TModel]> : readonly [];
+/**
+ * Configuration for LLM Gateway text adapter
+ */
+export interface LLMGatewayTextConfig extends LLMGatewayClientConfig {
+}
+/**
+ * Re-export of the public provider options type
+ */
+export type { ExternalTextProviderOptions as LLMGatewayTextProviderOptions } from '../text/text-provider-options.js';
+/**
+ * LLM Gateway Text (Chat) Adapter
+ *
+ * Tree-shakeable adapter for LLM Gateway chat/text completion. LLM Gateway
+ * exposes one OpenAI-compatible Chat Completions endpoint that routes to
+ * hundreds of models across many providers, so the adapter drives it with
+ * the OpenAI SDK via a `baseURL` override (the same pattern as `ai-grok`
+ * and `ai-groq`).
+ *
+ * Model ids are open-ended: curated ids get per-model type metadata, and
+ * any other id from https://llmgateway.io/models works with text-only
+ * defaults. A `provider/model` id (e.g. `openai/gpt-5.5`) pins routing to
+ * that provider; a bare id lets the gateway pick.
+ */
+export declare class LLMGatewayTextAdapter<TModel extends LLMGatewayModelId, TProviderOptions extends Record<string, any> = ResolveProviderOptions<TModel>, TInputModalities extends ReadonlyArray<Modality> = ResolveInputModalities<TModel>, TToolCapabilities extends ReadonlyArray<string> = ResolveToolCapabilities<TModel>> extends OpenAIBaseChatCompletionsTextAdapter<TModel, TProviderOptions, TInputModalities, LLMGatewayMessageMetadataByModality, TToolCapabilities> {
+    readonly kind: "text";
+    readonly name: "llmgateway";
+    constructor(config: LLMGatewayTextConfig, model: TModel);
+    /**
+     * Surfaces reasoning deltas during streaming. LLM Gateway normalizes
+     * upstream reasoning output to `delta.reasoning_content` on the OpenAI
+     * Chat Completions wire format (the DeepSeek-style field most
+     * OpenAI-compatible providers emit); some routed providers emit
+     * `delta.reasoning` instead, so both are read.
+     */
+    protected extractReasoning(chunk: OpenAI.Chat.Completions.ChatCompletionChunk): {
+        text: string;
+    } | undefined;
+}
+/**
+ * Creates an LLM Gateway text adapter with explicit API key.
+ *
+ * @example
+ * ```typescript
+ * const adapter = createLLMGatewayText('gpt-5.6-terra', "llmgtwy_...");
+ * ```
+ */
+export declare function createLLMGatewayText<TModel extends LLMGatewayModelId>(model: TModel, apiKey: string, config?: Omit<LLMGatewayTextConfig, 'apiKey'>): LLMGatewayTextAdapter<TModel>;
+/**
+ * Creates an LLM Gateway text adapter with API key from
+ * `LLM_GATEWAY_API_KEY`.
+ *
+ * @example
+ * ```typescript
+ * const adapter = llmGatewayText('gpt-5.6-terra');
+ * ```
+ */
+export declare function llmGatewayText<TModel extends LLMGatewayModelId>(model: TModel, config?: Omit<LLMGatewayTextConfig, 'apiKey'>): LLMGatewayTextAdapter<TModel>;

package/dist/esm/adapters/text.js

@@ -0,0 +1,67 @@
+import { getLLMGatewayApiKeyFromEnv, withLLMGatewayDefaults } from "../utils/client.js";
+import OpenAI from "openai";
+import { OpenAIBaseChatCompletionsTextAdapter } from "@tanstack/openai-base";
+//#region src/adapters/text.ts
+/**
+* LLM Gateway Text (Chat) Adapter
+*
+* Tree-shakeable adapter for LLM Gateway chat/text completion. LLM Gateway
+* exposes one OpenAI-compatible Chat Completions endpoint that routes to
+* hundreds of models across many providers, so the adapter drives it with
+* the OpenAI SDK via a `baseURL` override (the same pattern as `ai-grok`
+* and `ai-groq`).
+*
+* Model ids are open-ended: curated ids get per-model type metadata, and
+* any other id from https://llmgateway.io/models works with text-only
+* defaults. A `provider/model` id (e.g. `openai/gpt-5.5`) pins routing to
+* that provider; a bare id lets the gateway pick.
+*/
+var LLMGatewayTextAdapter = class extends OpenAIBaseChatCompletionsTextAdapter {
+	kind = "text";
+	name = "llmgateway";
+	constructor(config, model) {
+		super(model, "llmgateway", new OpenAI(withLLMGatewayDefaults(config)));
+	}
+	/**
+	* Surfaces reasoning deltas during streaming. LLM Gateway normalizes
+	* upstream reasoning output to `delta.reasoning_content` on the OpenAI
+	* Chat Completions wire format (the DeepSeek-style field most
+	* OpenAI-compatible providers emit); some routed providers emit
+	* `delta.reasoning` instead, so both are read.
+	*/
+	extractReasoning(chunk) {
+		const delta = chunk.choices[0]?.delta;
+		const raw = delta?.reasoning_content ?? delta?.reasoning;
+		if (typeof raw === "string" && raw.length > 0) return { text: raw };
+	}
+};
+/**
+* Creates an LLM Gateway text adapter with explicit API key.
+*
+* @example
+* ```typescript
+* const adapter = createLLMGatewayText('gpt-5.6-terra', "llmgtwy_...");
+* ```
+*/
+function createLLMGatewayText(model, apiKey, config) {
+	return new LLMGatewayTextAdapter({
+		apiKey,
+		...config
+	}, model);
+}
+/**
+* Creates an LLM Gateway text adapter with API key from
+* `LLM_GATEWAY_API_KEY`.
+*
+* @example
+* ```typescript
+* const adapter = llmGatewayText('gpt-5.6-terra');
+* ```
+*/
+function llmGatewayText(model, config) {
+	return createLLMGatewayText(model, getLLMGatewayApiKeyFromEnv(), config);
+}
+//#endregion
+export { LLMGatewayTextAdapter, createLLMGatewayText, llmGatewayText };
+
+//# sourceMappingURL=text.js.map

package/dist/esm/adapters/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","names":[],"sources":["../../../src/adapters/text.ts"],"sourcesContent":["import OpenAI from 'openai'\nimport { OpenAIBaseChatCompletionsTextAdapter } from '@tanstack/openai-base'\nimport {\n  getLLMGatewayApiKeyFromEnv,\n  withLLMGatewayDefaults,\n} from '../utils/client'\nimport type { Modality } from '@tanstack/ai'\nimport type {\n  LLMGatewayChatModelToolCapabilitiesByName,\n  LLMGatewayModelId,\n  ResolveInputModalities,\n  ResolveProviderOptions,\n} from '../model-meta'\nimport type { LLMGatewayMessageMetadataByModality } from '../message-types'\nimport type { LLMGatewayClientConfig } from '../utils/client'\n\ntype ResolveToolCapabilities<TModel extends string> =\n  TModel extends keyof LLMGatewayChatModelToolCapabilitiesByName\n    ? NonNullable<LLMGatewayChatModelToolCapabilitiesByName[TModel]>\n    : readonly []\n\n/**\n * Configuration for LLM Gateway text adapter\n */\nexport interface LLMGatewayTextConfig extends LLMGatewayClientConfig {}\n\n/**\n * Re-export of the public provider options type\n */\nexport type { ExternalTextProviderOptions as LLMGatewayTextProviderOptions } from '../text/text-provider-options'\n\n/**\n * LLM Gateway Text (Chat) Adapter\n *\n * Tree-shakeable adapter for LLM Gateway chat/text completion. LLM Gateway\n * exposes one OpenAI-compatible Chat Completions endpoint that routes to\n * hundreds of models across many providers, so the adapter drives it with\n * the OpenAI SDK via a `baseURL` override (the same pattern as `ai-grok`\n * and `ai-groq`).\n *\n * Model ids are open-ended: curated ids get per-model type metadata, and\n * any other id from https://llmgateway.io/models works with text-only\n * defaults. A `provider/model` id (e.g. `openai/gpt-5.5`) pins routing to\n * that provider; a bare id lets the gateway pick.\n */\nexport class LLMGatewayTextAdapter<\n  TModel extends LLMGatewayModelId,\n  TProviderOptions extends Record<string, any> = ResolveProviderOptions<TModel>,\n  TInputModalities extends ReadonlyArray<Modality> =\n    ResolveInputModalities<TModel>,\n  TToolCapabilities extends ReadonlyArray<string> =\n    ResolveToolCapabilities<TModel>,\n> extends OpenAIBaseChatCompletionsTextAdapter<\n  TModel,\n  TProviderOptions,\n  TInputModalities,\n  LLMGatewayMessageMetadataByModality,\n  TToolCapabilities\n> {\n  override readonly kind = 'text' as const\n  override readonly name = 'llmgateway' as const\n\n  constructor(config: LLMGatewayTextConfig, model: TModel) {\n    super(model, 'llmgateway', new OpenAI(withLLMGatewayDefaults(config)))\n  }\n\n  /**\n   * Surfaces reasoning deltas during streaming. LLM Gateway normalizes\n   * upstream reasoning output to `delta.reasoning_content` on the OpenAI\n   * Chat Completions wire format (the DeepSeek-style field most\n   * OpenAI-compatible providers emit); some routed providers emit\n   * `delta.reasoning` instead, so both are read.\n   */\n  protected override extractReasoning(\n    chunk: OpenAI.Chat.Completions.ChatCompletionChunk,\n  ): { text: string } | undefined {\n    const delta = chunk.choices[0]?.delta as\n      | { reasoning?: unknown; reasoning_content?: unknown }\n      | undefined\n    const raw = delta?.reasoning_content ?? delta?.reasoning\n    if (typeof raw === 'string' && raw.length > 0) {\n      return { text: raw }\n    }\n    return undefined\n  }\n}\n\n/**\n * Creates an LLM Gateway text adapter with explicit API key.\n *\n * @example\n * ```typescript\n * const adapter = createLLMGatewayText('gpt-5.6-terra', \"llmgtwy_...\");\n * ```\n */\nexport function createLLMGatewayText<TModel extends LLMGatewayModelId>(\n  model: TModel,\n  apiKey: string,\n  config?: Omit<LLMGatewayTextConfig, 'apiKey'>,\n): LLMGatewayTextAdapter<TModel> {\n  return new LLMGatewayTextAdapter({ apiKey, ...config }, model)\n}\n\n/**\n * Creates an LLM Gateway text adapter with API key from\n * `LLM_GATEWAY_API_KEY`.\n *\n * @example\n * ```typescript\n * const adapter = llmGatewayText('gpt-5.6-terra');\n * ```\n */\nexport function llmGatewayText<TModel extends LLMGatewayModelId>(\n  model: TModel,\n  config?: Omit<LLMGatewayTextConfig, 'apiKey'>,\n): LLMGatewayTextAdapter<TModel> {\n  const apiKey = getLLMGatewayApiKeyFromEnv()\n  return createLLMGatewayText(model, apiKey, config)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA6CA,IAAa,wBAAb,cAOU,qCAMR;CACA,OAAyB;CACzB,OAAyB;CAEzB,YAAY,QAA8B,OAAe;EACvD,MAAM,OAAO,cAAc,IAAI,OAAO,uBAAuB,MAAM,CAAC,CAAC;CACvE;;;;;;;;CASA,iBACE,OAC8B;EAC9B,MAAM,QAAQ,MAAM,QAAQ,EAAE,EAAE;EAGhC,MAAM,MAAM,OAAO,qBAAqB,OAAO;EAC/C,IAAI,OAAO,QAAQ,YAAY,IAAI,SAAS,GAC1C,OAAO,EAAE,MAAM,IAAI;CAGvB;AACF;;;;;;;;;AAUA,SAAgB,qBACd,OACA,QACA,QAC+B;CAC/B,OAAO,IAAI,sBAAsB;EAAE;EAAQ,GAAG;CAAO,GAAG,KAAK;AAC/D;;;;;;;;;;AAWA,SAAgB,eACd,OACA,QAC+B;CAE/B,OAAO,qBAAqB,OADb,2BACoB,GAAQ,MAAM;AACnD"}

package/dist/esm/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module @tanstack/ai-llmgateway
+ *
+ * LLM Gateway provider adapter for TanStack AI.
+ * Provides tree-shakeable adapters for LLM Gateway's OpenAI-compatible Chat
+ * Completions API, which routes one endpoint to hundreds of models across
+ * many providers.
+ */
+export { LLMGatewayTextAdapter, createLLMGatewayText, llmGatewayText, type LLMGatewayTextConfig, type LLMGatewayTextProviderOptions, } from './adapters/text.js';
+export { createLLMGatewaySummarize, llmGatewaySummarize, type LLMGatewaySummarizeConfig, type LLMGatewaySummarizeModel, } from './adapters/summarize.js';
+export type { LLMGatewayChatModelProviderOptionsByName, LLMGatewayChatModelToolCapabilitiesByName, LLMGatewayModelInputModalitiesByName, ResolveProviderOptions, ResolveInputModalities, LLMGatewayChatModels, LLMGatewayModelId, } from './model-meta.js';
+export { LLMGATEWAY_CHAT_MODELS } from './model-meta.js';
+export type { LLMGatewayTextMetadata, LLMGatewayImageMetadata, LLMGatewayAudioMetadata, LLMGatewayVideoMetadata, LLMGatewayDocumentMetadata, LLMGatewayMessageMetadataByModality, } from './message-types.js';
+export { getLLMGatewayApiKeyFromEnv, withLLMGatewayDefaults, type LLMGatewayClientConfig, } from './utils/client.js';

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+import { getLLMGatewayApiKeyFromEnv, withLLMGatewayDefaults } from "./utils/client.js";
+import { LLMGatewayTextAdapter, createLLMGatewayText, llmGatewayText } from "./adapters/text.js";
+import { createLLMGatewaySummarize, llmGatewaySummarize } from "./adapters/summarize.js";
+import { LLMGATEWAY_CHAT_MODELS } from "./model-meta.js";
+export { LLMGATEWAY_CHAT_MODELS, LLMGatewayTextAdapter, createLLMGatewaySummarize, createLLMGatewayText, getLLMGatewayApiKeyFromEnv, llmGatewaySummarize, llmGatewayText, withLLMGatewayDefaults };

package/dist/esm/message-types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * LLM Gateway-specific message types for the Chat Completions API.
+ *
+ * LLM Gateway's wire format is OpenAI Chat Completions — the gateway
+ * translates it to each routed provider's native format server-side. These
+ * type definitions describe that wire shape directly; the adapter drives
+ * the endpoint with the OpenAI SDK pointed at the gateway's base URL.
+ *
+ * @see https://docs.llmgateway.io
+ */
+export interface ChatCompletionNamedToolChoice {
+    /** Always `function` for a named tool choice. */
+    type: 'function';
+    function: {
+        /** The name of the function to call. */
+        name: string;
+    };
+}
+/**
+ * Controls which (if any) tool is called by the model.
+ *
+ * - `none` — the model will not call any tool and instead generates a message
+ * - `auto` — the model can pick between generating a message or calling tools
+ * - `required` — the model must call one or more tools
+ * - Named tool choice — forces the model to call a specific tool
+ */
+export type ChatCompletionToolChoiceOption = 'none' | 'auto' | 'required' | ChatCompletionNamedToolChoice;
+export interface ResponseFormatText {
+    /** The type of response format being defined. Always `text`. */
+    type: 'text';
+}
+export interface ResponseFormatJsonSchemaJsonSchema {
+    /**
+     * The name of the response format. Must be a-z, A-Z, 0-9, or contain
+     * underscores and dashes, with a maximum length of 64.
+     */
+    name: string;
+    /**
+     * A description of what the response format is for, used by the model to
+     * determine how to respond in the format.
+     */
+    description?: string;
+    /**
+     * The schema for the response format, described as a JSON Schema object.
+     * @see https://json-schema.org/
+     */
+    schema?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Whether to enable strict schema adherence when generating the output. If
+     * set to true, the model will always follow the exact schema defined in the
+     * `schema` field. Only a subset of JSON Schema is supported when `strict`
+     * is `true`.
+     */
+    strict?: boolean | null;
+}
+export interface ResponseFormatJsonSchema {
+    /** Structured Outputs configuration options, including a JSON Schema. */
+    json_schema: ResponseFormatJsonSchemaJsonSchema;
+    /** The type of response format being defined. Always `json_schema`. */
+    type: 'json_schema';
+}
+export interface ResponseFormatJsonObject {
+    /** The type of response format being defined. Always `json_object`. */
+    type: 'json_object';
+}
+/**
+ * Metadata for LLM Gateway document content parts.
+ */
+export interface LLMGatewayDocumentMetadata {
+}
+/**
+ * Metadata for LLM Gateway text content parts.
+ * Currently no specific metadata options for text.
+ */
+export interface LLMGatewayTextMetadata {
+}
+/**
+ * Metadata for LLM Gateway image content parts.
+ * Controls how the model processes and analyzes images.
+ */
+export interface LLMGatewayImageMetadata {
+    /**
+     * Specifies the detail level of the image.
+     * - 'auto': Let the model decide based on image size and content
+     * - 'low': Use low resolution processing (faster, cheaper, less detail)
+     * - 'high': Use high resolution processing (slower, more expensive, more detail)
+     *
+     * @default 'auto'
+     */
+    detail?: 'auto' | 'low' | 'high';
+}
+/**
+ * Metadata for LLM Gateway audio content parts.
+ * Note: audio input support depends on the routed model.
+ */
+export interface LLMGatewayAudioMetadata {
+}
+/**
+ * Metadata for LLM Gateway video content parts.
+ * Note: video input support depends on the routed model.
+ */
+export interface LLMGatewayVideoMetadata {
+}
+/**
+ * Map of modality types to their LLM Gateway-specific metadata types.
+ * Used for type inference when constructing multimodal messages.
+ */
+export interface LLMGatewayMessageMetadataByModality {
+    text: LLMGatewayTextMetadata;
+    image: LLMGatewayImageMetadata;
+    audio: LLMGatewayAudioMetadata;
+    video: LLMGatewayVideoMetadata;
+    document: LLMGatewayDocumentMetadata;
+}