@neondatabase/ai-sdk-provider 0.0.0 → 0.4.0

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

@@ -1,51 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,48 +0,0 @@
-// 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

@@ -1,66 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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));
-	}
-}