@neondatabase/ai-sdk-provider 0.0.0

package/README.md

@@ -0,0 +1,90 @@
+# @neondatabase/ai-sdk-provider
+
+Community [Vercel AI SDK](https://ai-sdk.dev) provider for the [Neon](https://neon.com) AI Gateway.
+
+The Neon AI Gateway is **branch-scoped**: each Neon project branch gets its own gateway host, and a platform token authorizes requests for that branch. This provider routes each model to the best gateway endpoint (Anthropic → native Messages, OpenAI → native Responses incl. **Codex**, everything else → unified OpenAI-compatible MLflow endpoint), so a single `neon('databricks-...')` call reaches the whole `databricks-*` catalog.
+
+## Install
+
+```bash
+npm install @neondatabase/ai-sdk-provider
+```
+
+## Configuration
+
+The gateway URL is branch-scoped, so both values come from the Neon Console (your project → a branch → **AI Gateway** tab), or from `neonctl env pull` / `neon dev`:
+
+```bash
+NEON_AI_GATEWAY_BASE_URL="https://<branch-id>-api.ai.<region>.aws.neon.tech"
+NEON_AI_GATEWAY_TOKEN="nt_live_..."
+```
+
+## Usage
+
+```ts
+import { neon } from "@neondatabase/ai-sdk-provider/v1";
+import { generateText } from "ai";
+
+// Reads NEON_AI_GATEWAY_BASE_URL + NEON_AI_GATEWAY_TOKEN from the environment.
+const { text } = await generateText({
+  model: neon("databricks-claude-haiku-4-5"), // or 'databricks-gpt-5-3-codex', etc.
+  prompt: "Summarize Postgres for me.",
+});
+```
+
+Or configure explicitly with `createNeon`:
+
+```ts
+import { createNeon } from "@neondatabase/ai-sdk-provider/v1";
+
+const neon = createNeon({
+  baseURL: process.env.NEON_AI_GATEWAY_BASE_URL,
+  apiKey: process.env.NEON_AI_GATEWAY_TOKEN,
+});
+```
+
+## Routing
+
+| Model family | Endpoint | Why |
+| --- | --- | --- |
+| Anthropic (`databricks-claude-*`) | native Messages API | streaming structured output + native reasoning |
+| OpenAI (`databricks-gpt-*`, `*-codex`) | native Responses API | Codex (native-only), native reasoning, image-gen tool |
+| Everything else (Gemini, Llama, Qwen, gpt-oss, ...) | unified MLflow endpoint | broad coverage; Gemini is here because its native endpoint does not support streaming |
+
+## Capabilities
+
+Verified across Anthropic, OpenAI (incl. Codex), Google, and Meta models: `generateText` / `streamText` (text, system prompts, multi-turn), tool calling (single and multi-step, generate and stream), `generateObject` / `streamObject`, and image (vision) input.
+
+For MLflow-routed models, the provider detects the model family and drops parameters a backend rejects (e.g. penalties/`seed` for Llama, `reasoningEffort` for Gemini) with an AI SDK warning (`result.warnings`) instead of failing the request.
+
+## Image generation
+
+Available on OpenAI models via the Responses `image_generation` tool (there is no `generateImage()` image-model endpoint). Use `streamText` — streaming returns the image as a `tool-result` part and avoids the gateway's non-streaming response-size cap and read timeout:
+
+```ts
+import { streamText } from "ai";
+import { neon } from "@neondatabase/ai-sdk-provider/v1";
+import { imageGeneration } from "@ai-sdk/openai/internal";
+
+const result = streamText({
+  model: neon("databricks-gpt-5-mini"),
+  prompt: "Generate an image of a red apple on a wooden table",
+  tools: { image: imageGeneration({ partialImages: 3 }) },
+});
+
+for await (const part of result.fullStream) {
+  if (part.type === "tool-result" && "result" in part.output) {
+    const png = Buffer.from(part.output.result as string, "base64");
+    // save or use the image
+  }
+}
+```
+
+## Limitations
+
+- `generateImage()` and embeddings (`embed` / `embedMany`) are not offered by the gateway and throw `NoSuchModelError`.
+- `gpt-oss-*` models return a non-standard ("harmony") response shape on the unified endpoint and are not fully supported.
+
+## Versioning
+
+Import from `@neondatabase/ai-sdk-provider/v1` to pin to a specific major. The default entry re-exports the latest stable version.

package/package.json

@@ -0,0 +1,24 @@
+{
+	"name": "@neondatabase/ai-sdk-provider",
+	"version": "0.0.0",
+	"description": "Community Vercel AI SDK provider for the Neon AI Gateway.",
+	"keywords": [
+		"neon",
+		"ai",
+		"ai-sdk",
+		"vercel-ai-sdk",
+		"provider",
+		"ai-gateway",
+		"llm",
+		"platform"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/neondatabase/neon-pkgs.git"
+	},
+	"license": "Apache-2.0",
+	"author": {
+		"name": "Neon",
+		"url": "https://neon.com"
+	}
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+/**
+ * The default entry point re-exports the latest stable version. New consumers should import
+ * directly from `@neondatabase/ai-sdk-provider/v1` to opt in to a specific major.
+ */
+export * from "./v1.js";

package/src/lib/neon-anthropic-language-model.ts

@@ -0,0 +1,51 @@
+import { AnthropicLanguageModel } from "@ai-sdk/anthropic/internal";
+import type {
+	LanguageModelV4,
+	LanguageModelV4CallOptions,
+	LanguageModelV4GenerateResult,
+	LanguageModelV4StreamResult,
+} from "@ai-sdk/provider";
+
+/**
+ * Language model for Anthropic models served via the Neon AI Gateway's native
+ * Messages API (`/ai-gateway/anthropic/v1/messages`). Unlocks streaming
+ * structured output and native reasoning for Claude.
+ *
+ * The shared Anthropic model defaults to fine-grained tool-input streaming
+ * (`eager_input_streaming: true`) on streaming tool calls, which the gateway
+ * rejects (`Extra inputs are not permitted`). We disable it via the model's own
+ * `toolStreaming` option so streaming tool calls work. Users can still override.
+ */
+export class NeonAnthropicLanguageModel
+	extends AnthropicLanguageModel
+	implements LanguageModelV4
+{
+	private withGatewayCompat(
+		options: LanguageModelV4CallOptions,
+	): LanguageModelV4CallOptions {
+		const anthropic = options.providerOptions?.anthropic;
+		// Respect an explicit user setting.
+		if (anthropic != null && "toolStreaming" in anthropic) {
+			return options;
+		}
+		return {
+			...options,
+			providerOptions: {
+				...options.providerOptions,
+				anthropic: { ...anthropic, toolStreaming: false },
+			},
+		};
+	}
+
+	override doGenerate(
+		options: LanguageModelV4CallOptions,
+	): Promise<LanguageModelV4GenerateResult> {
+		return super.doGenerate(this.withGatewayCompat(options));
+	}
+
+	override doStream(
+		options: LanguageModelV4CallOptions,
+	): Promise<LanguageModelV4StreamResult> {
+		return super.doStream(this.withGatewayCompat(options));
+	}
+}

package/src/lib/neon-capabilities.ts

@@ -0,0 +1,133 @@
+import type {
+	LanguageModelV4CallOptions,
+	LanguageModelV4StreamPart,
+	SharedV4ProviderOptions,
+	SharedV4Warning,
+} from "@ai-sdk/provider";
+import { isCustomReasoning } from "@ai-sdk/provider-utils";
+import { getNeonModelCapabilities } from "./neon-model-capabilities.js";
+
+/**
+ * Drop call options the resolved model's upstream backend does not accept and
+ * collect a warning for each, so callers get a clear signal instead of a hard
+ * `400` from the gateway.
+ */
+export function applyNeonCapabilities(
+	modelId: string,
+	options: LanguageModelV4CallOptions,
+): { options: LanguageModelV4CallOptions; warnings: SharedV4Warning[] } {
+	const caps = getNeonModelCapabilities(modelId);
+	const warnings: SharedV4Warning[] = [];
+	const patch: Partial<LanguageModelV4CallOptions> = {};
+
+	const dropUnsupported = (feature: string) => {
+		warnings.push({
+			type: "unsupported",
+			feature,
+			details: `${feature} is not supported by the Neon AI Gateway for ${caps.family} model "${modelId}" and was dropped.`,
+		});
+	};
+
+	if (options.temperature != null && !caps.supportsTemperature) {
+		patch.temperature = undefined;
+		dropUnsupported("temperature");
+	}
+	if (options.topP != null && !caps.supportsTopP) {
+		patch.topP = undefined;
+		dropUnsupported("topP");
+	}
+
+	// Anthropic-style models accept only one of temperature / topP.
+	const effectiveTemperature =
+		"temperature" in patch ? patch.temperature : options.temperature;
+	const effectiveTopP = "topP" in patch ? patch.topP : options.topP;
+	if (
+		caps.temperatureTopPMutuallyExclusive &&
+		effectiveTemperature != null &&
+		effectiveTopP != null
+	) {
+		patch.topP = undefined;
+		warnings.push({
+			type: "compatibility",
+			feature: "topP",
+			details: `${caps.family} models accept only one of temperature or topP; topP was dropped.`,
+		});
+	}
+
+	if (options.frequencyPenalty != null && !caps.supportsPenalties) {
+		patch.frequencyPenalty = undefined;
+		dropUnsupported("frequencyPenalty");
+	}
+	if (options.presencePenalty != null && !caps.supportsPenalties) {
+		patch.presencePenalty = undefined;
+		dropUnsupported("presencePenalty");
+	}
+	if (options.seed != null && !caps.supportsSeed) {
+		patch.seed = undefined;
+		dropUnsupported("seed");
+	}
+	if (options.stopSequences != null && !caps.supportsStopSequences) {
+		patch.stopSequences = undefined;
+		dropUnsupported("stopSequences");
+	}
+
+	if (!caps.supportsReasoningEffort) {
+		const { providerOptions } = options;
+		const hasProviderEffort =
+			providerOptions != null &&
+			Object.values(providerOptions).some(
+				(group) =>
+					"reasoningEffort" in group && group.reasoningEffort != null,
+			);
+		const hasReasoningOption =
+			isCustomReasoning(options.reasoning) &&
+			options.reasoning !== "none";
+
+		if (hasProviderEffort || hasReasoningOption) {
+			dropUnsupported("reasoningEffort");
+			if (hasProviderEffort && providerOptions != null) {
+				const cleaned: SharedV4ProviderOptions = {};
+				for (const [key, group] of Object.entries(providerOptions)) {
+					if ("reasoningEffort" in group) {
+						const { reasoningEffort: _removed, ...rest } = group;
+						cleaned[key] = rest;
+					} else {
+						cleaned[key] = group;
+					}
+				}
+				patch.providerOptions = cleaned;
+			}
+			if (hasReasoningOption) {
+				patch.reasoning = undefined;
+			}
+		}
+	}
+
+	if (Object.keys(patch).length === 0) {
+		return { options, warnings };
+	}
+	return { options: { ...options, ...patch }, warnings };
+}
+
+/**
+ * Merge additional warnings into the `stream-start` part of a model stream.
+ */
+export function mergeStreamStartWarnings(extra: SharedV4Warning[]) {
+	let merged = false;
+	return new TransformStream<
+		LanguageModelV4StreamPart,
+		LanguageModelV4StreamPart
+	>({
+		transform(part, controller) {
+			if (!merged && part.type === "stream-start") {
+				merged = true;
+				controller.enqueue({
+					...part,
+					warnings: [...extra, ...part.warnings],
+				});
+			} else {
+				controller.enqueue(part);
+			}
+		},
+	});
+}

package/src/lib/neon-chat-language-model.ts

@@ -0,0 +1,56 @@
+import { OpenAICompatibleChatLanguageModel } from "@ai-sdk/openai-compatible";
+import type {
+	LanguageModelV4,
+	LanguageModelV4CallOptions,
+	LanguageModelV4GenerateResult,
+	LanguageModelV4StreamResult,
+} from "@ai-sdk/provider";
+import {
+	applyNeonCapabilities,
+	mergeStreamStartWarnings,
+} from "./neon-capabilities.js";
+
+/**
+ * Language model for the Neon AI Gateway unified (MLflow) endpoint.
+ *
+ * Used for every model that is not routed to a provider-native endpoint
+ * (Gemini, Llama, Qwen, gpt-oss, ...). It is a thin specialization of the shared
+ * OpenAI-compatible chat model that adds per-model capability handling:
+ * parameters an upstream backend is known to reject are dropped and reported as
+ * warnings instead of failing the request.
+ */
+export class NeonChatLanguageModel
+	extends OpenAICompatibleChatLanguageModel
+	implements LanguageModelV4
+{
+	override async doGenerate(
+		options: LanguageModelV4CallOptions,
+	): Promise<LanguageModelV4GenerateResult> {
+		const { options: adjusted, warnings } = applyNeonCapabilities(
+			this.modelId,
+			options,
+		);
+		const result = await super.doGenerate(adjusted);
+		return warnings.length > 0
+			? { ...result, warnings: [...warnings, ...result.warnings] }
+			: result;
+	}
+
+	override async doStream(
+		options: LanguageModelV4CallOptions,
+	): Promise<LanguageModelV4StreamResult> {
+		const { options: adjusted, warnings } = applyNeonCapabilities(
+			this.modelId,
+			options,
+		);
+		const result = await super.doStream(adjusted);
+		return warnings.length > 0
+			? {
+					...result,
+					stream: result.stream.pipeThrough(
+						mergeStreamStartWarnings(warnings),
+					),
+				}
+			: result;
+	}
+}

package/src/lib/neon-chat-options.ts

@@ -0,0 +1,48 @@
+// Models served by the Neon AI Gateway. Anthropic and OpenAI models are routed
+// to their provider-native endpoints; everything else uses the unified MLflow
+// (OpenAI-compatible) endpoint.
+//
+// The authoritative, always-current catalog is shown in the Neon Console under
+// the branch's "AI Gateway" tab. Any other id can be passed as a plain string
+// via the `(string & {})` fallback.
+export type NeonChatModelId =
+	// Anthropic (native Messages API)
+	| "databricks-claude-opus-4-8"
+	| "databricks-claude-opus-4-7"
+	| "databricks-claude-opus-4-6"
+	| "databricks-claude-opus-4-5"
+	| "databricks-claude-opus-4-1"
+	| "databricks-claude-sonnet-4-6"
+	| "databricks-claude-sonnet-4-5"
+	| "databricks-claude-sonnet-4"
+	| "databricks-claude-haiku-4-5"
+	// OpenAI (native Responses API, incl. Codex)
+	| "databricks-gpt-5"
+	| "databricks-gpt-5-mini"
+	| "databricks-gpt-5-nano"
+	| "databricks-gpt-5-1"
+	| "databricks-gpt-5-2"
+	| "databricks-gpt-5-2-codex"
+	| "databricks-gpt-5-3-codex"
+	| "databricks-gpt-5-4"
+	| "databricks-gpt-5-4-mini"
+	| "databricks-gpt-5-4-nano"
+	| "databricks-gpt-5-5"
+	| "databricks-gpt-5-5-pro"
+	// OpenAI open-weight (unified MLflow endpoint)
+	| "databricks-gpt-oss-120b"
+	| "databricks-gpt-oss-20b"
+	// Google (unified MLflow endpoint)
+	| "databricks-gemini-3-5-flash"
+	| "databricks-gemini-3-1-flash-lite"
+	| "databricks-gemini-2-5-pro"
+	| "databricks-gemini-2-5-flash"
+	| "databricks-gemma-3-12b"
+	// Meta (unified MLflow endpoint)
+	| "databricks-llama-4-maverick"
+	| "databricks-meta-llama-3-3-70b-instruct"
+	| "databricks-meta-llama-3-1-8b-instruct"
+	// Alibaba (unified MLflow endpoint)
+	| "databricks-qwen3-next-80b-a3b-instruct"
+	| "databricks-qwen35-122b-a10b"
+	| (string & {});

package/src/lib/neon-model-capabilities.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import {
+	getNeonModelCapabilities,
+	getNeonModelRoute,
+} from "./neon-model-capabilities.js";
+
+describe("getNeonModelRoute", () => {
+	it("routes Anthropic and OpenAI models to their native endpoints", () => {
+		expect(getNeonModelRoute("databricks-claude-opus-4-8")).toBe(
+			"anthropic",
+		);
+		expect(getNeonModelRoute("databricks-claude-haiku-4-5")).toBe(
+			"anthropic",
+		);
+		expect(getNeonModelRoute("databricks-gpt-5")).toBe("openai");
+		expect(getNeonModelRoute("databricks-gpt-5-mini")).toBe("openai");
+		expect(getNeonModelRoute("databricks-gpt-5-3-codex")).toBe("openai");
+	});
+
+	it("falls back to the unified MLflow endpoint for everything else", () => {
+		// Gemini is routed to MLflow because its native endpoint cannot stream.
+		expect(getNeonModelRoute("databricks-gemini-2-5-flash")).toBe("mlflow");
+		expect(getNeonModelRoute("databricks-llama-4-maverick")).toBe("mlflow");
+		expect(getNeonModelRoute("databricks-qwen35-122b-a10b")).toBe("mlflow");
+		// gpt-oss is open-weight and served on the unified endpoint, not Responses.
+		expect(getNeonModelRoute("databricks-gpt-oss-120b")).toBe("mlflow");
+	});
+});
+
+describe("getNeonModelCapabilities", () => {
+	it("marks Anthropic models correctly", () => {
+		const caps = getNeonModelCapabilities("databricks-claude-haiku-4-5");
+		expect(caps.family).toBe("anthropic");
+		expect(caps.supportsPenalties).toBe(false);
+		expect(caps.supportsSeed).toBe(false);
+		expect(caps.temperatureTopPMutuallyExclusive).toBe(true);
+		expect(caps.supportsReasoningEffort).toBe(false);
+	});
+
+	it("marks plain GPT-5 reasoning models without temperature/topP support", () => {
+		const caps = getNeonModelCapabilities("databricks-gpt-5-mini");
+		expect(caps.family).toBe("openai");
+		expect(caps.supportsTemperature).toBe(false);
+		expect(caps.supportsTopP).toBe(false);
+	});
+
+	it("keeps temperature for gpt-5.1+ models", () => {
+		const caps = getNeonModelCapabilities("databricks-gpt-5-1");
+		expect(caps.supportsTemperature).toBe(true);
+		expect(caps.supportsTopP).toBe(true);
+	});
+
+	it("marks Meta models without penalties/seed support", () => {
+		const caps = getNeonModelCapabilities("databricks-llama-4-maverick");
+		expect(caps.family).toBe("meta");
+		expect(caps.supportsPenalties).toBe(false);
+		expect(caps.supportsSeed).toBe(false);
+	});
+
+	it("is permissive for unknown models", () => {
+		const caps = getNeonModelCapabilities("databricks-qwen35-122b-a10b");
+		expect(caps.family).toBe("other");
+		expect(caps.supportsPenalties).toBe(true);
+		expect(caps.supportsReasoningEffort).toBe(true);
+	});
+});

package/src/lib/neon-model-capabilities.ts

@@ -0,0 +1,137 @@
+export type NeonModelFamily =
+	| "anthropic"
+	| "google"
+	| "openai"
+	| "meta"
+	| "other";
+
+/**
+ * Which gateway endpoint a model should be routed to.
+ *
+ * - `anthropic`: native Messages API — streaming structured output + native reasoning.
+ * - `openai`: native Responses API — models served only natively (e.g. Codex),
+ *   native reasoning, and the image-generation tool.
+ * - `mlflow`: the unified, OpenAI-compatible endpoint (the fallback). Gemini is
+ *   routed here because the gateway's native Gemini endpoint does not support
+ *   streaming (`streamGenerateContent` is rejected).
+ */
+export type NeonModelRoute = "anthropic" | "openai" | "mlflow";
+
+export function getNeonModelRoute(modelId: string): NeonModelRoute {
+	const id = modelId.toLowerCase();
+	if (id.includes("claude")) {
+		return "anthropic";
+	}
+	// OpenAI proprietary models (gpt-4/gpt-5 families, Codex) are served only via
+	// the native Responses API. `gpt-oss` is open-weight and served on the
+	// unified chat endpoint, so it is intentionally excluded here.
+	if (
+		(id.includes("gpt-") && !id.includes("gpt-oss")) ||
+		id.includes("codex")
+	) {
+		return "openai";
+	}
+	return "mlflow";
+}
+
+export interface NeonModelCapabilities {
+	family: NeonModelFamily;
+	supportsTemperature: boolean;
+	supportsTopP: boolean;
+	/**
+	 * Whether `temperature` and `topP` may be sent together. Anthropic models
+	 * accept only one of the two.
+	 */
+	temperatureTopPMutuallyExclusive: boolean;
+	supportsPenalties: boolean;
+	supportsSeed: boolean;
+	supportsStopSequences: boolean;
+	supportsReasoningEffort: boolean;
+}
+
+const PERMISSIVE: Omit<NeonModelCapabilities, "family"> = {
+	supportsTemperature: true,
+	supportsTopP: true,
+	temperatureTopPMutuallyExclusive: false,
+	supportsPenalties: true,
+	supportsSeed: true,
+	supportsStopSequences: true,
+	supportsReasoningEffort: true,
+};
+
+/**
+ * Heuristic, prefix-based capability detection for MLflow-routed Neon models.
+ *
+ * The unified endpoint proxies to heterogeneous upstream providers, each of
+ * which accepts a different subset of the OpenAI-style parameters the AI SDK
+ * emits. Sending a parameter an upstream rejects results in a hard `400`, so we
+ * strip the parameters a family is known to reject and surface a warning
+ * instead. Unknown/untested models stay permissive (passed through unchanged).
+ */
+export function getNeonModelCapabilities(
+	modelId: string,
+): NeonModelCapabilities {
+	const id = modelId.toLowerCase();
+
+	// Anthropic (Claude): rejects penalties and seed, accepts only one of
+	// temperature/topP, and rejects the OpenAI `reasoning_effort` field.
+	if (id.includes("claude")) {
+		return {
+			family: "anthropic",
+			supportsTemperature: true,
+			supportsTopP: true,
+			temperatureTopPMutuallyExclusive: true,
+			supportsPenalties: false,
+			supportsSeed: false,
+			supportsStopSequences: true,
+			supportsReasoningEffort: false,
+		};
+	}
+
+	// Google (Gemini): accepts standard sampling params but rejects the OpenAI
+	// `reasoning_effort` field (not part of Gemini's generation config).
+	if (id.includes("gemini")) {
+		return {
+			family: "google",
+			...PERMISSIVE,
+			supportsReasoningEffort: false,
+		};
+	}
+
+	// OpenAI GPT-5 reasoning family (routed to the native Responses API). The
+	// Responses model strips parameters the Responses API doesn't accept
+	// (penalties, seed, stop), but its reasoning-model detection matches the bare
+	// model id (`gpt-5`), which the gateway's `databricks-` prefix defeats. So we
+	// only handle the temperature/topP restriction here: the original gpt-5 /
+	// gpt-5-mini / gpt-5-nano require the default temperature and reject topP,
+	// while gpt-5.1+ (a minor version digit follows) accept them again.
+	if (/gpt-5/.test(id)) {
+		const hasMinorVersion = /gpt-5[.-]\d/.test(id);
+		return {
+			family: "openai",
+			supportsTemperature: hasMinorVersion,
+			supportsTopP: hasMinorVersion,
+			temperatureTopPMutuallyExclusive: false,
+			supportsPenalties: true,
+			supportsSeed: true,
+			supportsStopSequences: true,
+			supportsReasoningEffort: true,
+		};
+	}
+
+	// Meta (Llama): rejects penalties and seed; accepts sampling params and stop.
+	if (id.includes("llama")) {
+		return {
+			family: "meta",
+			supportsTemperature: true,
+			supportsTopP: true,
+			temperatureTopPMutuallyExclusive: false,
+			supportsPenalties: false,
+			supportsSeed: false,
+			supportsStopSequences: true,
+			supportsReasoningEffort: true,
+		};
+	}
+
+	return { family: "other", ...PERMISSIVE };
+}

package/src/lib/neon-responses-language-model.ts

@@ -0,0 +1,60 @@
+import { OpenAIResponsesLanguageModel } from "@ai-sdk/openai/internal";
+import type {
+	LanguageModelV4,
+	LanguageModelV4CallOptions,
+	LanguageModelV4GenerateResult,
+	LanguageModelV4StreamResult,
+} from "@ai-sdk/provider";
+
+/**
+ * Language model for OpenAI models served via the Neon AI Gateway's native
+ * Responses API (`/ai-gateway/openai/v1/responses`). This route is required for
+ * models that are only served natively (e.g. Codex) and unlocks native
+ * reasoning and the image-generation tool.
+ *
+ * The shared OpenAI Responses model shapes a request based on whether the model
+ * is a reasoning model, but it detects that from the bare model id (`gpt-5`),
+ * which the gateway's required `databricks-` prefix defeats. For the GPT-5
+ * reasoning family we set the model's own `forceReasoning` provider option so it
+ * applies the correct reasoning behavior. Users can still override it.
+ */
+export class NeonResponsesLanguageModel
+	extends OpenAIResponsesLanguageModel
+	implements LanguageModelV4
+{
+	private get isReasoningFamily(): boolean {
+		return /gpt-5/.test(this.modelId.toLowerCase());
+	}
+
+	private withForcedReasoning(
+		options: LanguageModelV4CallOptions,
+	): LanguageModelV4CallOptions {
+		if (!this.isReasoningFamily) {
+			return options;
+		}
+		const openai = options.providerOptions?.openai;
+		// Respect an explicit user setting.
+		if (openai != null && "forceReasoning" in openai) {
+			return options;
+		}
+		return {
+			...options,
+			providerOptions: {
+				...options.providerOptions,
+				openai: { ...openai, forceReasoning: true },
+			},
+		};
+	}
+
+	override doGenerate(
+		options: LanguageModelV4CallOptions,
+	): Promise<LanguageModelV4GenerateResult> {
+		return super.doGenerate(this.withForcedReasoning(options));
+	}
+
+	override doStream(
+		options: LanguageModelV4CallOptions,
+	): Promise<LanguageModelV4StreamResult> {
+		return super.doStream(this.withForcedReasoning(options));
+	}
+}

package/src/lib/provider.ts

@@ -0,0 +1,211 @@
+/**
+ * Community Vercel AI SDK provider for the Neon AI Gateway.
+ *
+ * `createNeon()` returns a provider that routes each model to the best gateway
+ * endpoint based on its id (Anthropic → native Messages, OpenAI → native
+ * Responses incl. Codex, everything else → unified MLflow), so a single
+ * `neon('databricks-...')` call (same base URL + token) reaches the whole
+ * catalog. Configure with the branch-scoped `NEON_AI_GATEWAY_BASE_URL` +
+ * `NEON_AI_GATEWAY_TOKEN` emitted by `neonctl env pull` / `neon dev`, or pass
+ * `baseURL` / `apiKey` explicitly.
+ */
+import type { ProviderErrorStructure } from "@ai-sdk/openai-compatible";
+import {
+	type LanguageModelV4,
+	NoSuchModelError,
+	type ProviderV4,
+} from "@ai-sdk/provider";
+import {
+	type FetchFunction,
+	generateId,
+	loadApiKey,
+	loadSetting,
+	withoutTrailingSlash,
+	withUserAgentSuffix,
+} from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+import { NeonAnthropicLanguageModel } from "./neon-anthropic-language-model.js";
+import { NeonChatLanguageModel } from "./neon-chat-language-model.js";
+import type { NeonChatModelId } from "./neon-chat-options.js";
+import { getNeonModelRoute } from "./neon-model-capabilities.js";
+import { NeonResponsesLanguageModel } from "./neon-responses-language-model.js";
+import { VERSION } from "./version.js";
+
+const neonErrorSchema = z.object({
+	error: z.object({
+		message: z.string(),
+		type: z.string().nullish(),
+		param: z.unknown().nullish(),
+		code: z.unknown().nullish(),
+	}),
+});
+
+export type NeonErrorData = z.infer<typeof neonErrorSchema>;
+
+const neonErrorStructure: ProviderErrorStructure<NeonErrorData> = {
+	errorSchema: neonErrorSchema,
+	errorToMessage: (data) => data.error.message,
+};
+
+/**
+ * Recursively remove the JSON Schema `$schema` marker, which some gateway
+ * backends (notably Gemini) reject in tool/structured-output schemas. Other
+ * backends ignore its absence, so stripping it everywhere is safe.
+ */
+function stripJsonSchemaMarker(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		return value.map(stripJsonSchemaMarker);
+	}
+	if (value !== null && typeof value === "object") {
+		const result: Record<string, unknown> = {};
+		for (const [key, entry] of Object.entries(value)) {
+			if (key === "$schema") {
+				continue;
+			}
+			result[key] = stripJsonSchemaMarker(entry);
+		}
+		return result;
+	}
+	return value;
+}
+
+function transformNeonRequestBody(
+	args: Record<string, unknown>,
+): Record<string, unknown> {
+	const transformed = { ...args };
+	if (transformed.tools != null) {
+		transformed.tools = stripJsonSchemaMarker(transformed.tools);
+	}
+	if (transformed.response_format != null) {
+		transformed.response_format = stripJsonSchemaMarker(
+			transformed.response_format,
+		);
+	}
+	return transformed;
+}
+
+export interface NeonProviderSettings {
+	/**
+	 * Neon AI Gateway base URL — the branch-scoped host root, e.g.
+	 * `https://<branch-id>-api.ai.<region>.aws.neon.tech`. The gateway paths are
+	 * appended internally. Falls back to the `NEON_AI_GATEWAY_BASE_URL` env var.
+	 */
+	baseURL?: string;
+
+	/**
+	 * Neon AI Gateway platform token (the `nt_live_...` value). Falls back to the
+	 * `NEON_AI_GATEWAY_TOKEN` env var.
+	 */
+	apiKey?: string;
+
+	/** Custom headers to include in the requests. */
+	headers?: Record<string, string>;
+
+	/** Custom fetch implementation (e.g. for testing or middleware). */
+	fetch?: FetchFunction;
+}
+
+export interface NeonProvider extends ProviderV4 {
+	/** Creates a Neon AI Gateway model for text generation. */
+	(modelId: NeonChatModelId): LanguageModelV4;
+
+	/** Creates a Neon AI Gateway model for text generation. */
+	languageModel(modelId: NeonChatModelId): LanguageModelV4;
+
+	/** Creates a Neon AI Gateway chat model for text generation. */
+	chat(modelId: NeonChatModelId): LanguageModelV4;
+
+	/** @deprecated Use `embeddingModel` instead. */
+	textEmbeddingModel(modelId: string): never;
+}
+
+export function createNeon(options: NeonProviderSettings = {}): NeonProvider {
+	// Resolved lazily so that `createNeon()` and the default `neon` instance do
+	// not throw at import time when configuration comes from the environment.
+	const getHost = () =>
+		withoutTrailingSlash(
+			loadSetting({
+				settingValue: options.baseURL,
+				environmentVariableName: "NEON_AI_GATEWAY_BASE_URL",
+				settingName: "baseURL",
+				description: "Neon AI Gateway base URL",
+			}),
+		);
+
+	const getHeaders = (extra?: Record<string, string>) =>
+		withUserAgentSuffix(
+			{
+				Authorization: `Bearer ${loadApiKey({
+					apiKey: options.apiKey,
+					environmentVariableName: "NEON_AI_GATEWAY_TOKEN",
+					description: "Neon AI Gateway token",
+				})}`,
+				...extra,
+				...options.headers,
+			},
+			`neondatabase/ai-sdk-provider/${VERSION}`,
+		);
+
+	// Anthropic models -> native Messages API.
+	const createAnthropicModel = (modelId: NeonChatModelId) =>
+		new NeonAnthropicLanguageModel(modelId, {
+			provider: "neon.anthropic",
+			baseURL: `${getHost()}/ai-gateway/anthropic/v1`,
+			headers: () => getHeaders({ "anthropic-version": "2023-06-01" }),
+			fetch: options.fetch,
+			generateId,
+		});
+
+	// OpenAI models (incl. Codex, only served natively) -> Responses API.
+	const createOpenAIModel = (modelId: NeonChatModelId) =>
+		new NeonResponsesLanguageModel(modelId, {
+			provider: "neon.openai.responses",
+			url: ({ path }) => `${getHost()}/ai-gateway/openai/v1${path}`,
+			headers: getHeaders,
+			fetch: options.fetch,
+			fileIdPrefixes: ["file-"],
+		});
+
+	// Everything else (Gemini, Llama, Qwen, gpt-oss, ...) -> unified MLflow
+	// endpoint. Gemini is here because its native endpoint can't stream.
+	const createChatModel = (modelId: NeonChatModelId) =>
+		new NeonChatLanguageModel(modelId, {
+			provider: "neon.chat",
+			url: ({ path }) => `${getHost()}/ai-gateway/mlflow/v1${path}`,
+			headers: getHeaders,
+			fetch: options.fetch,
+			errorStructure: neonErrorStructure,
+			transformRequestBody: transformNeonRequestBody,
+			supportsStructuredOutputs: true,
+		});
+
+	const createLanguageModel = (modelId: NeonChatModelId): LanguageModelV4 => {
+		switch (getNeonModelRoute(modelId)) {
+			case "anthropic":
+				return createAnthropicModel(modelId);
+			case "openai":
+				return createOpenAIModel(modelId);
+			default:
+				return createChatModel(modelId);
+		}
+	};
+
+	const provider = (modelId: NeonChatModelId) => createLanguageModel(modelId);
+
+	provider.specificationVersion = "v4" as const;
+	provider.languageModel = createLanguageModel;
+	provider.chat = createLanguageModel;
+
+	provider.embeddingModel = (modelId: string) => {
+		throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
+	};
+	provider.textEmbeddingModel = provider.embeddingModel;
+	provider.imageModel = (modelId: string) => {
+		throw new NoSuchModelError({ modelId, modelType: "imageModel" });
+	};
+
+	return provider;
+}
+
+/** Default Neon provider instance (reads `NEON_AI_GATEWAY_*` env vars). */
+export const neon = createNeon();

package/src/lib/version.ts

@@ -0,0 +1,2 @@
+// Package version, used in the User-Agent suffix sent to the gateway.
+export const VERSION = "0.0.0";

package/src/v1.ts

@@ -0,0 +1,26 @@
+/**
+ * `@neondatabase/ai-sdk-provider/v1` — community Vercel AI SDK provider for the
+ * Neon AI Gateway.
+ *
+ * - `createNeon()` / `neon` — the provider. Routes each model to the best
+ *   gateway endpoint (Anthropic → native Messages, OpenAI → native Responses
+ *   incl. Codex, everything else → unified MLflow).
+ */
+export { NeonAnthropicLanguageModel } from "./lib/neon-anthropic-language-model.js";
+export { NeonChatLanguageModel } from "./lib/neon-chat-language-model.js";
+export type { NeonChatModelId } from "./lib/neon-chat-options.js";
+export {
+	getNeonModelCapabilities,
+	getNeonModelRoute,
+	type NeonModelCapabilities,
+	type NeonModelFamily,
+	type NeonModelRoute,
+} from "./lib/neon-model-capabilities.js";
+export { NeonResponsesLanguageModel } from "./lib/neon-responses-language-model.js";
+export {
+	createNeon,
+	type NeonErrorData,
+	type NeonProvider,
+	type NeonProviderSettings,
+	neon,
+} from "./lib/provider.js";

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"include": ["src", "vitest.config.ts", "tsdown.config.ts"]
+}

package/tsdown.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+	name: "@neondatabase/ai-sdk-provider",
+	bundle: false,
+	clean: true,
+	dts: true,
+	entry: ["src/index.ts", "src/v1.ts", "src/lib/**/*.ts", "!src/**/*.test.*"],
+	format: "esm",
+	outDir: "dist",
+	treeshake: true,
+});

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		clearMocks: true,
+		mockReset: true,
+		unstubEnvs: true,
+		coverage: {
+			all: true,
+			include: ["src"],
+			exclude: ["src/**/*.test.ts"],
+			reporter: ["html", "lcov"],
+		},
+		exclude: ["lib", "node_modules", "dist"],
+		setupFiles: ["console-fail-test/setup"],
+	},
+});