@neon/ai-sdk-provider 0.7.2 → 0.7.3

package/{LICENSE.md → LICENSE}

@@ -1,6 +1,5 @@
-# Apache License 2.0
 
-                                Apache License
+                                 Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
 
@@ -175,4 +174,29 @@
       incurred by, or claims asserted against, such Contributor by reason
       of your accepting any such warranty or additional liability.
 
-   END OF TERMS AND CONDITIONS
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -2,9 +2,9 @@
 
 Community [Vercel AI SDK](https://ai-sdk.dev) provider for the [Neon](https://neon.com) AI Gateway. Supports **AI SDK v6 and v7** (`ai@^6` or `ai@^7`).
 
-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('claude-...')` call reaches the whole catalog.
+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. Use the same `neon(modelId)` API across the branch's model catalog; the provider selects Anthropic Messages, OpenAI Responses, or Chat Completions for each model.
 
-Model ids use the canonical Neon (unprefixed) form — `claude-sonnet-4-6`, `gpt-5`, `gemini-2-5-flash` — matching the [`neon` provider on models.dev](https://models.dev). The typed catalog mirrors that provider exactly (kept in sync by a scheduled drift check), plus a few extra gateway-served ids that models.dev doesn't list yet (e.g. Codex, Llama, Qwen). Any other id — including the legacy `databricks-` prefixed form (`databricks-claude-sonnet-4-6`) — is still accepted as a plain string, so existing code keeps working.
+Use canonical model ids such as `gpt-5-mini`, `llama-4-maverick`, and `gemini-3-flash`, matching the [`neon` provider on models.dev](https://models.dev). The typed catalog includes the known model ids, and arbitrary strings are accepted so newly available models work before the types update.
 
 ## Install
 
@@ -31,7 +31,7 @@ import { generateText } from "ai";
 
 // Reads NEON_AI_GATEWAY_BASE_URL + NEON_AI_GATEWAY_TOKEN from the environment.
 const { text } = await generateText({
-  model: neon("claude-haiku-4-5"), // or 'gpt-5-3-codex', etc.
+  model: neon("gpt-5-mini"), // or "llama-4-maverick", "gemini-3-flash", …
   prompt: "Summarize Postgres for me.",
 });
 ```
@@ -51,17 +51,19 @@ const neon = createNeon({
 
 | Model family | Endpoint | Why |
 | --- | --- | --- |
-| Anthropic (`claude-*`) | native Messages API | streaming structured output + native reasoning |
-| OpenAI (`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 |
+| Anthropic (`claude-*`) | Messages API | Anthropic tools, structured output, and reasoning |
+| OpenAI (`gpt-*`, `*-codex`) | Responses API | Codex, reasoning, and built-in tools such as image generation |
+| Everything else (Gemini, Llama, Qwen, gpt-oss, ...) | Chat Completions API | one streaming interface across the remaining model families |
 
-Routing matches on the model id, so both the canonical (`gpt-5`) and the legacy `databricks-`-prefixed (`databricks-gpt-5`) forms route identically.
+Routing matches on the model id.
 
 ## 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.
+`generateText` and `streamText` work with any model available to your branch. `generateObject`, `streamObject`, and single- or multi-step tool calls work with OpenAI (including Codex), Meta, and Alibaba models. Gemini currently supports `generateText` and `streamText`; structured output and multi-step tools are not supported. Vision input works on models that accept images.
 
-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.
+Claude models use the Messages API when `claude-*` ids are available. For models using Chat Completions, the provider removes unsupported options such as penalties or `seed` for Llama and `reasoningEffort` for Gemini, then reports them in `result.warnings` instead of failing the request. Unsupported Responses API storage options throw before a request is sent — see [Errors](#errors).
+
+Which ids your branch serves is account-specific during the beta; `GET $NEON_AI_GATEWAY_BASE_URL/v1/models` is the authoritative list.
 
 ## Image generation
 
@@ -85,11 +87,90 @@ for await (const part of result.fullStream) {
 }
 ```
 
+### Edit a generated image
+
+The gateway does not support stored Responses API items (`store: true`, `previousResponseId`, or `conversation`), which the Responses API uses to reuse tool results across turns. For image edits, pass the returned bytes back as image input; otherwise the model does not receive the original image and generates a new one.
+
+```ts
+const first = await generateText({
+  model: neon("gpt-5-mini"),
+  prompt: "Generate an image of a plain red square.",
+  tools: { image_generation: neon.tools.imageGeneration({ outputFormat: "jpeg" }) },
+});
+
+const generated = first.steps
+  .flatMap((step) => step.toolResults)
+  .find((result) => result.toolName === "image_generation");
+const output = generated?.output;
+if (
+  !output ||
+  typeof output !== "object" ||
+  !("result" in output) ||
+  typeof output.result !== "string"
+) {
+  throw new Error("Image generation did not return image bytes.");
+}
+
+// Pass it back as image content, not as conversation history.
+await generateText({
+  model: neon("gpt-5-mini"),
+  tools: { image_generation: neon.tools.imageGeneration({ outputFormat: "jpeg" }) },
+  messages: [
+    {
+      role: "user",
+      content: [
+        { type: "image", image: output.result, mediaType: "image/jpeg" },
+        { type: "text", text: "Make that same square blue instead." },
+      ],
+    },
+  ],
+});
+```
+
+The same stateless limitation applies to other built-in Responses tools such as web search and code interpreter.
+
+## Errors
+
+A failed call rejects with the AI SDK's `APICallError`, and `error.message` carries the gateway's own reason rather than the bare HTTP status line:
+
+```ts
+import { APICallError, generateText } from "ai";
+
+try {
+  await generateText({ model: neon("gpt-5-mini"), maxOutputTokens: 1, prompt });
+} catch (error) {
+  if (APICallError.isInstance(error)) {
+    error.message;      // "Invalid 'max_output_tokens': integer below minimum
+                        //  value. Expected a value >= 16, but got 1 instead."
+    error.responseBody; // the gateway's original body, including its error_code
+  }
+}
+```
+
+The provider normalizes JSON error responses so the gateway's reason lands on `error.message`. Errors delivered inside an open stream and non-JSON responses keep the HTTP status line; inspect `error.responseBody` for their payload.
+
+Requests that cannot work are refused before they leave, with `UnsupportedFunctionalityError`:
+
+| `providerOptions.openai` | Why |
+| --- | --- |
+| `store: true` or `store: null` | The Responses route is stateless and never persists items. `null` is not "omitted" — the AI SDK reads it as `true`. |
+| `previousResponseId`, `conversation` | Nothing is stored for them to refer to. Send the full message history instead. |
+
+Provider options are namespaced per route, which decides where the SDK reads them from:
+
+| Route | Models | Namespace |
+| --- | --- | --- |
+| Responses | `gpt-*` (incl. Codex) | `openai` |
+| Chat Completions | Gemini, Llama, Qwen, gpt-oss, … | `neon` |
+| Anthropic Messages | `claude-*` | `anthropic` |
+
+So `store` is only refused on the Responses route; the same option is ignored elsewhere.
+
 ## 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 (`message.content` as an array of reasoning/text parts instead of a string). The provider normalizes this to the OpenAI Chat Completions contract (string `content` + `reasoning_content`) so `generateText`/`streamText` work and reasoning is surfaced. See neondatabase/neon-pkgs#308.
-- OpenAI Responses multi-turn tool flows (`generateText` + `stepCountIs`) can return 502 from the gateway; tool calling is covered on Anthropic/Google/Meta in e2e.
+- The gateway does not offer image or embedding model endpoints, so `generateImage()`, `embed()`, and `embedMany()` throw `NoSuchModelError`. Image generation is available through the Responses API's built-in `image_generation` tool with `neon.tools.imageGeneration()`.
+- Results from provider-executed tools (`neon.tools.imageGeneration`, and the other Responses built-ins) are not replayed to the gateway on a later step — see [Edit a generated image](#edit-a-generated-image).
+- The Responses route is stateless, so the provider sends `store: false` and refuses `store: true`, `store: null`, `previousResponseId`, or `conversation` — see [Errors](#errors).
 
 ## End-to-end tests
 
@@ -100,4 +181,4 @@ cp .env.example .env   # fill NEON_AI_GATEWAY_BASE_URL + NEON_AI_GATEWAY_TOKEN f
 pnpm test:e2e
 ```
 
-The matrix covers one models.dev `neon` model per family (Anthropic, OpenAI, Codex, Gemini, Meta) across `generateText`, `streamText`, `generateObject`, tool calling, and `neon.tools.imageGeneration`. It also fetches the live `/v1/models` catalog and calls every currently enabled model with both AI SDK 6 and AI SDK 7. Tests are skipped when gateway env vars are absent.
+The matrix covers one models.dev `neon` model per family (Anthropic, OpenAI, Codex, Gemini, Meta, Alibaba) across `generateText`, `streamText`, `generateObject`, tool calling, and `neon.tools.imageGeneration`. `generateObject` and tool calling run on the subset of families where they are verified (see [Capabilities](#capabilities)); a family whose representative id the branch does not serve is skipped rather than failed. It also fetches the live `/v1/models` catalog and calls every currently enabled model with both AI SDK 6 and AI SDK 7. Tests are skipped when gateway env vars are absent.

package/dist/lib/neon-gateway-error.d.ts

@@ -0,0 +1,56 @@
+import { FetchFunction } from "@ai-sdk/provider-utils";
+
+//#region src/lib/neon-gateway-error.d.ts
+
+/**
+ * Give every route of this provider the error envelope its model knows how to
+ * read, so a failed call surfaces the gateway's reason on `error.message`
+ * instead of a bare HTTP status line.
+ *
+ * The gateway emits several error shapes, and which one you get depends on
+ * which layer rejected the request rather than on which route you called:
+ *
+ * 1. The gateway's own rejection, in OpenAI shape:
+ *      { "error": { "message": "unknown model \"nope\"" } }
+ *
+ * 2. A Databricks rejection, flat and with its own code:
+ *      { "error_code": "BAD_REQUEST", "message": "service_tier='flex' is …" }
+ *
+ * 3. A Databricks rejection wrapping an upstream error as a JSON *string*:
+ *      { "error_code": "BAD_REQUEST", "message": "{\"error\":{\"message\":…}}" }
+ *
+ * Meanwhile each underlying model parses a different schema: the OpenAI and
+ * OpenAI-compatible models want `{ error: { message } }`, the Anthropic model
+ * wants `{ type: "error", error: { type, message } }`. Anything that does not
+ * match is dropped and the AI SDK falls back to the status text, which is how
+ * `AI_APICallError: Bad Request` reaches a caller with the real explanation
+ * stranded on `responseBody`.
+ *
+ * So the shape a body needs is a property of the route, not of the gateway:
+ * this reads any of the above into one reason and re-emits it in the dialect
+ * that route's model expects. Cross-dialect conversion is covered too, since
+ * nothing guarantees a given layer answers in the dialect of the route it was
+ * reached through. A body already valid for the target dialect is left alone,
+ * as is any successful response and anything unrecognised.
+ *
+ * The Anthropic direction is unverified against a live gateway: that endpoint
+ * currently answers every request with a plain-text 404, so no JSON envelope
+ * can be observed on it at all.
+ *
+ * None of the models expose an error hook (`OpenAIConfig` has none, and the
+ * Anthropic one takes a fixed handler), so this rides on `fetch` — the same
+ * lever `wrapFetchWithHarmonyNormalization` uses. The two are disjoint: that
+ * one returns early on a failed response, this one only acts on failures.
+ */
+/** The error envelope a route's model can parse. */
+type GatewayErrorDialect = "openai" | "anthropic";
+/**
+ * Map a gateway error body into `dialect`, or return null when it already
+ * parses there (or is not a shape we recognise).
+ */
+declare function normalizeGatewayErrorBody(body: unknown, dialect: GatewayErrorDialect): unknown | null;
+/** Wrap a fetch so failed responses reach the model in its own dialect. */
+declare function wrapFetchWithGatewayErrorNormalization(baseFetch: FetchFunction | undefined, dialect: GatewayErrorDialect): FetchFunction;
+//#endregion
+export { GatewayErrorDialect, normalizeGatewayErrorBody, wrapFetchWithGatewayErrorNormalization };
+//# sourceMappingURL=neon-gateway-error.d.ts.map

package/dist/lib/neon-gateway-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neon-gateway-error.d.ts","names":[],"sources":["../../src/lib/neon-gateway-error.ts"],"mappings":";;;;;;AA4CA;AAqHA;AAiBA;AAAsD;AAC1C;AACF;AACP;AAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAzIJ,mBAAA;;;;;iBAqHI,yBAAA,yBAEN;;iBAeM,sCAAA,YACJ,oCACF,sBACP"}

package/dist/lib/neon-gateway-error.js

@@ -0,0 +1,102 @@
+//#region src/lib/neon-gateway-error.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asOpenAIEnvelope(value) {
+	if (isRecord(value) && isRecord(value.error) && typeof value.error.message === "string") return value.error;
+	return null;
+}
+function asAnthropicEnvelope(value) {
+	if (isRecord(value) && value.type === "error" && isRecord(value.error) && typeof value.error.message === "string" && typeof value.error.type === "string") return value.error;
+	return null;
+}
+/** Read any envelope the gateway emits into a single reason. */
+function extractReason(body) {
+	const anthropic = asAnthropicEnvelope(body);
+	if (anthropic) return {
+		message: anthropic.message,
+		type: anthropic.type
+	};
+	const openai = asOpenAIEnvelope(body);
+	if (openai) return {
+		message: openai.message,
+		openaiFields: openai,
+		type: typeof openai.type === "string" ? openai.type : void 0
+	};
+	if (!isRecord(body) || typeof body.message !== "string") return null;
+	const code = typeof body.error_code === "string" ? body.error_code : void 0;
+	if (body.message.trimStart().startsWith("{")) try {
+		const nested = extractReason(JSON.parse(body.message));
+		if (nested) return {
+			...nested,
+			type: nested.type ?? code
+		};
+	} catch {}
+	return {
+		message: body.message,
+		type: code
+	};
+}
+/**
+* Overlay the target envelope on the original body rather than replacing it,
+* so whatever else the gateway sent — `error_code`, request ids, the encoded
+* original message — still reaches the caller on `APICallError.responseBody`.
+*/
+function emit(body, reason, dialect) {
+	const original = isRecord(body) ? body : {};
+	if (dialect === "anthropic") return {
+		...original,
+		type: "error",
+		error: {
+			...reason.openaiFields,
+			type: reason.type ?? "api_error",
+			message: reason.message
+		}
+	};
+	return {
+		...original,
+		error: {
+			...reason.openaiFields,
+			message: reason.message,
+			code: reason.openaiFields?.code ?? reason.type ?? null
+		}
+	};
+}
+/**
+* Map a gateway error body into `dialect`, or return null when it already
+* parses there (or is not a shape we recognise).
+*/
+function normalizeGatewayErrorBody(body, dialect) {
+	if (dialect === "anthropic" ? asAnthropicEnvelope(body) !== null : asOpenAIEnvelope(body) !== null) return null;
+	const reason = extractReason(body);
+	return reason === null ? null : emit(body, reason, dialect);
+}
+/** Wrap a fetch so failed responses reach the model in its own dialect. */
+function wrapFetchWithGatewayErrorNormalization(baseFetch, dialect) {
+	const inner = baseFetch ?? ((...args) => globalThis.fetch(...args));
+	return async (input, init) => {
+		const response = await inner(input, init);
+		if (response.ok) return response;
+		if (!(response.headers.get("content-type") ?? "").includes("application/json")) return response;
+		let parsed;
+		try {
+			parsed = JSON.parse(await response.clone().text());
+		} catch {
+			return response;
+		}
+		const normalized = normalizeGatewayErrorBody(parsed, dialect);
+		if (normalized === null) return response;
+		const headers = new Headers(response.headers);
+		headers.delete("content-length");
+		headers.delete("content-encoding");
+		return new Response(JSON.stringify(normalized), {
+			status: response.status,
+			statusText: response.statusText,
+			headers
+		});
+	};
+}
+//#endregion
+export { normalizeGatewayErrorBody, wrapFetchWithGatewayErrorNormalization };
+
+//# sourceMappingURL=neon-gateway-error.js.map

package/dist/lib/neon-gateway-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"neon-gateway-error.js","names":[],"sources":["../../src/lib/neon-gateway-error.ts"],"sourcesContent":["import type { FetchFunction } from \"@ai-sdk/provider-utils\";\n\n/**\n * Give every route of this provider the error envelope its model knows how to\n * read, so a failed call surfaces the gateway's reason on `error.message`\n * instead of a bare HTTP status line.\n *\n * The gateway emits several error shapes, and which one you get depends on\n * which layer rejected the request rather than on which route you called:\n *\n * 1. The gateway's own rejection, in OpenAI shape:\n *      { \"error\": { \"message\": \"unknown model \\\"nope\\\"\" } }\n *\n * 2. A Databricks rejection, flat and with its own code:\n *      { \"error_code\": \"BAD_REQUEST\", \"message\": \"service_tier='flex' is …\" }\n *\n * 3. A Databricks rejection wrapping an upstream error as a JSON *string*:\n *      { \"error_code\": \"BAD_REQUEST\", \"message\": \"{\\\"error\\\":{\\\"message\\\":…}}\" }\n *\n * Meanwhile each underlying model parses a different schema: the OpenAI and\n * OpenAI-compatible models want `{ error: { message } }`, the Anthropic model\n * wants `{ type: \"error\", error: { type, message } }`. Anything that does not\n * match is dropped and the AI SDK falls back to the status text, which is how\n * `AI_APICallError: Bad Request` reaches a caller with the real explanation\n * stranded on `responseBody`.\n *\n * So the shape a body needs is a property of the route, not of the gateway:\n * this reads any of the above into one reason and re-emits it in the dialect\n * that route's model expects. Cross-dialect conversion is covered too, since\n * nothing guarantees a given layer answers in the dialect of the route it was\n * reached through. A body already valid for the target dialect is left alone,\n * as is any successful response and anything unrecognised.\n *\n * The Anthropic direction is unverified against a live gateway: that endpoint\n * currently answers every request with a plain-text 404, so no JSON envelope\n * can be observed on it at all.\n *\n * None of the models expose an error hook (`OpenAIConfig` has none, and the\n * Anthropic one takes a fixed handler), so this rides on `fetch` — the same\n * lever `wrapFetchWithHarmonyNormalization` uses. The two are disjoint: that\n * one returns early on a failed response, this one only acts on failures.\n */\n\n/** The error envelope a route's model can parse. */\nexport type GatewayErrorDialect = \"openai\" | \"anthropic\";\n\ninterface Reason {\n\tmessage: string;\n\t/** Preserved verbatim when the source was already an OpenAI envelope. */\n\topenaiFields?: Record<string, unknown>;\n\t/** An Anthropic `error.type`, or a Databricks `error_code`. */\n\ttype?: string;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n\treturn typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nfunction asOpenAIEnvelope(value: unknown): Record<string, unknown> | null {\n\tif (\n\t\tisRecord(value) &&\n\t\tisRecord(value.error) &&\n\t\ttypeof value.error.message === \"string\"\n\t) {\n\t\treturn value.error;\n\t}\n\treturn null;\n}\n\nfunction asAnthropicEnvelope(value: unknown): Record<string, unknown> | null {\n\tif (\n\t\tisRecord(value) &&\n\t\tvalue.type === \"error\" &&\n\t\tisRecord(value.error) &&\n\t\ttypeof value.error.message === \"string\" &&\n\t\ttypeof value.error.type === \"string\"\n\t) {\n\t\treturn value.error;\n\t}\n\treturn null;\n}\n\n/** Read any envelope the gateway emits into a single reason. */\nfunction extractReason(body: unknown): Reason | null {\n\tconst anthropic = asAnthropicEnvelope(body);\n\tif (anthropic) {\n\t\treturn {\n\t\t\tmessage: anthropic.message as string,\n\t\t\ttype: anthropic.type as string,\n\t\t};\n\t}\n\n\tconst openai = asOpenAIEnvelope(body);\n\tif (openai) {\n\t\treturn {\n\t\t\tmessage: openai.message as string,\n\t\t\topenaiFields: openai,\n\t\t\ttype: typeof openai.type === \"string\" ? openai.type : undefined,\n\t\t};\n\t}\n\n\tif (!isRecord(body) || typeof body.message !== \"string\") {\n\t\treturn null;\n\t}\n\tconst code =\n\t\ttypeof body.error_code === \"string\" ? body.error_code : undefined;\n\n\t// Shape 3: an upstream envelope encoded into `message`. Prefer it — it\n\t// names the offending parameter, which the outer wrapper does not.\n\tif (body.message.trimStart().startsWith(\"{\")) {\n\t\ttry {\n\t\t\tconst inner: unknown = JSON.parse(body.message);\n\t\t\tconst nested = extractReason(inner);\n\t\t\tif (nested) {\n\t\t\t\treturn { ...nested, type: nested.type ?? code };\n\t\t\t}\n\t\t} catch {\n\t\t\t// Not JSON after all; fall through to shape 2.\n\t\t}\n\t}\n\n\t// Shape 2: a flat Databricks rejection.\n\treturn { message: body.message, type: code };\n}\n\n/**\n * Overlay the target envelope on the original body rather than replacing it,\n * so whatever else the gateway sent — `error_code`, request ids, the encoded\n * original message — still reaches the caller on `APICallError.responseBody`.\n */\nfunction emit(\n\tbody: unknown,\n\treason: Reason,\n\tdialect: GatewayErrorDialect,\n): unknown {\n\tconst original = isRecord(body) ? body : {};\n\tif (dialect === \"anthropic\") {\n\t\treturn {\n\t\t\t...original,\n\t\t\ttype: \"error\",\n\t\t\terror: {\n\t\t\t\t...reason.openaiFields,\n\t\t\t\ttype: reason.type ?? \"api_error\",\n\t\t\t\tmessage: reason.message,\n\t\t\t},\n\t\t};\n\t}\n\treturn {\n\t\t...original,\n\t\terror: {\n\t\t\t...reason.openaiFields,\n\t\t\tmessage: reason.message,\n\t\t\tcode: reason.openaiFields?.code ?? reason.type ?? null,\n\t\t},\n\t};\n}\n\n/**\n * Map a gateway error body into `dialect`, or return null when it already\n * parses there (or is not a shape we recognise).\n */\nexport function normalizeGatewayErrorBody(\n\tbody: unknown,\n\tdialect: GatewayErrorDialect,\n): unknown | null {\n\tconst alreadyValid =\n\t\tdialect === \"anthropic\"\n\t\t\t? asAnthropicEnvelope(body) !== null\n\t\t\t: asOpenAIEnvelope(body) !== null;\n\tif (alreadyValid) {\n\t\treturn null;\n\t}\n\n\tconst reason = extractReason(body);\n\treturn reason === null ? null : emit(body, reason, dialect);\n}\n\n/** Wrap a fetch so failed responses reach the model in its own dialect. */\nexport function wrapFetchWithGatewayErrorNormalization(\n\tbaseFetch: FetchFunction | undefined,\n\tdialect: GatewayErrorDialect,\n): FetchFunction {\n\tconst inner: FetchFunction =\n\t\tbaseFetch ?? ((...args) => globalThis.fetch(...args));\n\n\treturn async (input, init) => {\n\t\tconst response = await inner(input, init);\n\t\tif (response.ok) {\n\t\t\treturn response;\n\t\t}\n\t\tconst contentType = response.headers.get(\"content-type\") ?? \"\";\n\t\tif (!contentType.includes(\"application/json\")) {\n\t\t\treturn response;\n\t\t}\n\n\t\tlet parsed: unknown;\n\t\ttry {\n\t\t\tparsed = JSON.parse(await response.clone().text());\n\t\t} catch {\n\t\t\treturn response;\n\t\t}\n\n\t\tconst normalized = normalizeGatewayErrorBody(parsed, dialect);\n\t\tif (normalized === null) {\n\t\t\treturn response;\n\t\t}\n\n\t\t// Rewriting the body invalidates both of these.\n\t\tconst headers = new Headers(response.headers);\n\t\theaders.delete(\"content-length\");\n\t\theaders.delete(\"content-encoding\");\n\n\t\treturn new Response(JSON.stringify(normalized), {\n\t\t\tstatus: response.status,\n\t\t\tstatusText: response.statusText,\n\t\t\theaders,\n\t\t});\n\t};\n}\n"],"mappings":";AAsDA,SAAS,SAAS,OAAkD;CACnE,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC3E;AAEA,SAAS,iBAAiB,OAAgD;CACzE,IACC,SAAS,KAAK,KACd,SAAS,MAAM,KAAK,KACpB,OAAO,MAAM,MAAM,YAAY,UAE/B,OAAO,MAAM;CAEd,OAAO;AACR;AAEA,SAAS,oBAAoB,OAAgD;CAC5E,IACC,SAAS,KAAK,KACd,MAAM,SAAS,WACf,SAAS,MAAM,KAAK,KACpB,OAAO,MAAM,MAAM,YAAY,YAC/B,OAAO,MAAM,MAAM,SAAS,UAE5B,OAAO,MAAM;CAEd,OAAO;AACR;;AAGA,SAAS,cAAc,MAA8B;CACpD,MAAM,YAAY,oBAAoB,IAAI;CAC1C,IAAI,WACH,OAAO;EACN,SAAS,UAAU;EACnB,MAAM,UAAU;CACjB;CAGD,MAAM,SAAS,iBAAiB,IAAI;CACpC,IAAI,QACH,OAAO;EACN,SAAS,OAAO;EAChB,cAAc;EACd,MAAM,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO,KAAA;CACvD;CAGD,IAAI,CAAC,SAAS,IAAI,KAAK,OAAO,KAAK,YAAY,UAC9C,OAAO;CAER,MAAM,OACL,OAAO,KAAK,eAAe,WAAW,KAAK,aAAa,KAAA;CAIzD,IAAI,KAAK,QAAQ,UAAU,CAAC,CAAC,WAAW,GAAG,GAC1C,IAAI;EAEH,MAAM,SAAS,cADQ,KAAK,MAAM,KAAK,OACN,CAAC;EAClC,IAAI,QACH,OAAO;GAAE,GAAG;GAAQ,MAAM,OAAO,QAAQ;EAAK;CAEhD,QAAQ,CAER;CAID,OAAO;EAAE,SAAS,KAAK;EAAS,MAAM;CAAK;AAC5C;;;;;;AAOA,SAAS,KACR,MACA,QACA,SACU;CACV,MAAM,WAAW,SAAS,IAAI,IAAI,OAAO,CAAC;CAC1C,IAAI,YAAY,aACf,OAAO;EACN,GAAG;EACH,MAAM;EACN,OAAO;GACN,GAAG,OAAO;GACV,MAAM,OAAO,QAAQ;GACrB,SAAS,OAAO;EACjB;CACD;CAED,OAAO;EACN,GAAG;EACH,OAAO;GACN,GAAG,OAAO;GACV,SAAS,OAAO;GAChB,MAAM,OAAO,cAAc,QAAQ,OAAO,QAAQ;EACnD;CACD;AACD;;;;;AAMA,SAAgB,0BACf,MACA,SACiB;CAKjB,IAHC,YAAY,cACT,oBAAoB,IAAI,MAAM,OAC9B,iBAAiB,IAAI,MAAM,MAE9B,OAAO;CAGR,MAAM,SAAS,cAAc,IAAI;CACjC,OAAO,WAAW,OAAO,OAAO,KAAK,MAAM,QAAQ,OAAO;AAC3D;;AAGA,SAAgB,uCACf,WACA,SACgB;CAChB,MAAM,QACL,eAAe,GAAG,SAAS,WAAW,MAAM,GAAG,IAAI;CAEpD,OAAO,OAAO,OAAO,SAAS;EAC7B,MAAM,WAAW,MAAM,MAAM,OAAO,IAAI;EACxC,IAAI,SAAS,IACZ,OAAO;EAGR,IAAI,EADgB,SAAS,QAAQ,IAAI,cAAc,KAAK,GAAA,CAC3C,SAAS,kBAAkB,GAC3C,OAAO;EAGR,IAAI;EACJ,IAAI;GACH,SAAS,KAAK,MAAM,MAAM,SAAS,MAAM,CAAC,CAAC,KAAK,CAAC;EAClD,QAAQ;GACP,OAAO;EACR;EAEA,MAAM,aAAa,0BAA0B,QAAQ,OAAO;EAC5D,IAAI,eAAe,MAClB,OAAO;EAIR,MAAM,UAAU,IAAI,QAAQ,SAAS,OAAO;EAC5C,QAAQ,OAAO,gBAAgB;EAC/B,QAAQ,OAAO,kBAAkB;EAEjC,OAAO,IAAI,SAAS,KAAK,UAAU,UAAU,GAAG;GAC/C,QAAQ,SAAS;GACjB,YAAY,SAAS;GACrB;EACD,CAAC;CACF;AACD"}

package/dist/lib/neon-responses-language-model.d.ts

@@ -5,20 +5,14 @@ import { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateRes
 
 /**
  * Language model for OpenAI models served via the Neon AI Gateway's native
- * Responses API (`/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.
+ * Responses API (`/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 its detection is brittle here: the gateway also
- * accepts the legacy `databricks-` prefix, which defeats the upstream bare-id
- * (`gpt-5`) match. For the GPT-5 reasoning family we set the model's own
- * `forceReasoning` provider option so it applies the correct reasoning behavior
- * for both id forms. Users can still override it.
+ * The request shaping lives in `neon-responses-options.ts`, which documents
+ * what this route requires and why.
  */
 declare class NeonResponsesLanguageModel extends OpenAIResponsesLanguageModel implements LanguageModelV3 {
-  private get isReasoningFamily();
-  private withForcedReasoning;
   doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult>;
   doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult>;
 }

package/dist/lib/neon-responses-language-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"neon-responses-language-model.d.ts","names":[],"sources":["../../src/lib/neon-responses-language-model.ts"],"mappings":";;;;;;;AAqBA;AACC;AA4BU;AACC;AAAR;AAKO;AACC;AAAR;AAnCK;AACG;AAAe;cAFd,0BAAA,SACJ,4BAAA,YACG;;;sBA2BD,6BACP,QAAQ;oBAKD,6BACP,QAAQ"}
+{"version":3,"file":"neon-responses-language-model.d.ts","names":[],"sources":["../../src/lib/neon-responses-language-model.ts"],"mappings":";;;;;;;AAkBA;AACC;AAIU;AACC;AAAR;AAOO;AACC;AAAR,cAdS,0BAAA,SACJ,4BAAA,YACG,eAYR,CAAA;EAbK,UAAA,CAAA,OAAA,EAIE,0BAJF,CAAA,EAKL,OALK,CAKG,6BALH,CAAA;EACG,QAAA,CAAA,OAAA,EAWD,0BAXC,CAAA,EAYR,OAZQ,CAYA,2BAZA,CAAA;AAAe"}

package/dist/lib/neon-responses-language-model.js

@@ -1,42 +1,21 @@
+import { withResponsesGatewayDefaults } from "./neon-responses-options.js";
 import { OpenAIResponsesLanguageModel } from "@ai-sdk/openai/internal";
 //#region src/lib/neon-responses-language-model.ts
 /**
 * Language model for OpenAI models served via the Neon AI Gateway's native
-* Responses API (`/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.
+* Responses API (`/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 its detection is brittle here: the gateway also
-* accepts the legacy `databricks-` prefix, which defeats the upstream bare-id
-* (`gpt-5`) match. For the GPT-5 reasoning family we set the model's own
-* `forceReasoning` provider option so it applies the correct reasoning behavior
-* for both id forms. Users can still override it.
+* The request shaping lives in `neon-responses-options.ts`, which documents
+* what this route requires and why.
 */
 var NeonResponsesLanguageModel = class extends OpenAIResponsesLanguageModel {
-	get isReasoningFamily() {
-		return /gpt-5/.test(this.modelId.toLowerCase());
-	}
-	withForcedReasoning(options) {
-		if (!this.isReasoningFamily) return options;
-		const openai = options.providerOptions?.openai;
-		if (openai != null && "forceReasoning" in openai) return options;
-		return {
-			...options,
-			providerOptions: {
-				...options.providerOptions,
-				openai: {
-					...openai,
-					forceReasoning: true
-				}
-			}
-		};
-	}
 	doGenerate(options) {
-		return super.doGenerate(this.withForcedReasoning(options));
+		return super.doGenerate(withResponsesGatewayDefaults(this.modelId, options));
 	}
 	doStream(options) {
-		return super.doStream(this.withForcedReasoning(options));
+		return super.doStream(withResponsesGatewayDefaults(this.modelId, options));
 	}
 };
 //#endregion

package/dist/lib/neon-responses-language-model.js.map

@@ -1 +1 @@
-{"version":3,"file":"neon-responses-language-model.js","names":[],"sources":["../../src/lib/neon-responses-language-model.ts"],"sourcesContent":["import { OpenAIResponsesLanguageModel } from \"@ai-sdk/openai/internal\";\nimport type {\n\tLanguageModelV3,\n\tLanguageModelV3CallOptions,\n\tLanguageModelV3GenerateResult,\n\tLanguageModelV3StreamResult,\n} from \"@ai-sdk/provider\";\n\n/**\n * Language model for OpenAI models served via the Neon AI Gateway's native\n * Responses API (`/openai/v1/responses`). This route is required for\n * models that are only served natively (e.g. Codex) and unlocks native\n * reasoning and the image-generation tool.\n *\n * The shared OpenAI Responses model shapes a request based on whether the model\n * is a reasoning model, but its detection is brittle here: the gateway also\n * accepts the legacy `databricks-` prefix, which defeats the upstream bare-id\n * (`gpt-5`) match. For the GPT-5 reasoning family we set the model's own\n * `forceReasoning` provider option so it applies the correct reasoning behavior\n * for both id forms. Users can still override it.\n */\nexport class NeonResponsesLanguageModel\n\textends OpenAIResponsesLanguageModel\n\timplements LanguageModelV3\n{\n\tprivate get isReasoningFamily(): boolean {\n\t\treturn /gpt-5/.test(this.modelId.toLowerCase());\n\t}\n\n\tprivate withForcedReasoning(\n\t\toptions: LanguageModelV3CallOptions,\n\t): LanguageModelV3CallOptions {\n\t\tif (!this.isReasoningFamily) {\n\t\t\treturn options;\n\t\t}\n\t\tconst openai = options.providerOptions?.openai;\n\t\t// Respect an explicit user setting.\n\t\tif (openai != null && \"forceReasoning\" in openai) {\n\t\t\treturn options;\n\t\t}\n\t\treturn {\n\t\t\t...options,\n\t\t\tproviderOptions: {\n\t\t\t\t...options.providerOptions,\n\t\t\t\topenai: { ...openai, forceReasoning: true },\n\t\t\t},\n\t\t};\n\t}\n\n\toverride doGenerate(\n\t\toptions: LanguageModelV3CallOptions,\n\t): Promise<LanguageModelV3GenerateResult> {\n\t\treturn super.doGenerate(this.withForcedReasoning(options));\n\t}\n\n\toverride doStream(\n\t\toptions: LanguageModelV3CallOptions,\n\t): Promise<LanguageModelV3StreamResult> {\n\t\treturn super.doStream(this.withForcedReasoning(options));\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;AAqBA,IAAa,6BAAb,cACS,6BAET;CACC,IAAY,oBAA6B;EACxC,OAAO,QAAQ,KAAK,KAAK,QAAQ,YAAY,CAAC;CAC/C;CAEA,oBACC,SAC6B;EAC7B,IAAI,CAAC,KAAK,mBACT,OAAO;EAER,MAAM,SAAS,QAAQ,iBAAiB;EAExC,IAAI,UAAU,QAAQ,oBAAoB,QACzC,OAAO;EAER,OAAO;GACN,GAAG;GACH,iBAAiB;IAChB,GAAG,QAAQ;IACX,QAAQ;KAAE,GAAG;KAAQ,gBAAgB;IAAK;GAC3C;EACD;CACD;CAEA,WACC,SACyC;EACzC,OAAO,MAAM,WAAW,KAAK,oBAAoB,OAAO,CAAC;CAC1D;CAEA,SACC,SACuC;EACvC,OAAO,MAAM,SAAS,KAAK,oBAAoB,OAAO,CAAC;CACxD;AACD"}
+{"version":3,"file":"neon-responses-language-model.js","names":[],"sources":["../../src/lib/neon-responses-language-model.ts"],"sourcesContent":["import { OpenAIResponsesLanguageModel } from \"@ai-sdk/openai/internal\";\nimport type {\n\tLanguageModelV3,\n\tLanguageModelV3CallOptions,\n\tLanguageModelV3GenerateResult,\n\tLanguageModelV3StreamResult,\n} from \"@ai-sdk/provider\";\nimport { withResponsesGatewayDefaults } from \"./neon-responses-options.js\";\n\n/**\n * Language model for OpenAI models served via the Neon AI Gateway's native\n * Responses API (`/openai/v1/responses`). This route is required for models\n * that are only served natively (e.g. Codex) and unlocks native reasoning and\n * the image-generation tool.\n *\n * The request shaping lives in `neon-responses-options.ts`, which documents\n * what this route requires and why.\n */\nexport class NeonResponsesLanguageModel\n\textends OpenAIResponsesLanguageModel\n\timplements LanguageModelV3\n{\n\toverride doGenerate(\n\t\toptions: LanguageModelV3CallOptions,\n\t): Promise<LanguageModelV3GenerateResult> {\n\t\treturn super.doGenerate(\n\t\t\twithResponsesGatewayDefaults(this.modelId, options),\n\t\t);\n\t}\n\n\toverride doStream(\n\t\toptions: LanguageModelV3CallOptions,\n\t): Promise<LanguageModelV3StreamResult> {\n\t\treturn super.doStream(\n\t\t\twithResponsesGatewayDefaults(this.modelId, options),\n\t\t);\n\t}\n}\n"],"mappings":";;;;;;;;;;;;AAkBA,IAAa,6BAAb,cACS,6BAET;CACC,WACC,SACyC;EACzC,OAAO,MAAM,WACZ,6BAA6B,KAAK,SAAS,OAAO,CACnD;CACD;CAEA,SACC,SACuC;EACvC,OAAO,MAAM,SACZ,6BAA6B,KAAK,SAAS,OAAO,CACnD;CACD;AACD"}

package/dist/lib/neon-responses-options.d.ts

@@ -0,0 +1,14 @@
+import { LanguageModelV3CallOptions } from "@ai-sdk/provider";
+
+//#region src/lib/neon-responses-options.d.ts
+/** Models the gateway serves as reasoning models on this route. */
+declare function isReasoningModelId(modelId: string): boolean;
+/**
+ * Apply the route's defaults to one call, or throw when a caller asked for
+ * something the gateway cannot do. Returns the options unchanged when there is
+ * nothing to add.
+ */
+declare function withResponsesGatewayDefaults(modelId: string, options: LanguageModelV3CallOptions): LanguageModelV3CallOptions;
+//#endregion
+export { isReasoningModelId, withResponsesGatewayDefaults };
+//# sourceMappingURL=neon-responses-options.d.ts.map

package/dist/lib/neon-responses-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neon-responses-options.d.ts","names":[],"sources":["../../src/lib/neon-responses-options.ts"],"mappings":";;;;iBAmCgB,kBAAA;AAAhB;AASA;AAA4C;AAElC;AACP;AAA0B,iBAHb,4BAAA,CAGa,OAAA,EAAA,MAAA,EAAA,OAAA,EADnB,0BACmB,CAAA,EAA1B,0BAA0B"}

package/dist/lib/neon-responses-options.js

@@ -0,0 +1,66 @@
+import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
+//#region src/lib/neon-responses-options.ts
+/**
+* Request defaults for the Neon AI Gateway's Responses route.
+*
+* `store: false` is the one value this gateway accepts, not a preference. It
+* serves the Responses API statelessly and keeps no items — a response comes
+* back with `"store": false` even when the request never set it. Left alone the
+* shared OpenAI model assumes stored-item semantics and replays earlier
+* reasoning as `{ type: "item_reference", id }`, which nothing upstream can
+* resolve; the gateway answers `502 INTERNAL_ERROR` on the second step of a
+* tool loop, after the first has already succeeded. Sending `false` makes the
+* model inline the encrypted reasoning instead.
+*
+* Since no other value can work, an explicit `store` that is not `false` is
+* refused rather than sent: the request would come back `400
+* INVALID_PARAMETER_VALUE` after a round trip, and quietly forcing it to
+* `false` would be the wrong kind of quiet for a data-retention flag. A
+* type-level constraint is not available — `providerOptions` is
+* `Record<string, JSONObject>`, so a provider cannot narrow it at the call
+* site.
+*
+* `forceReasoning: true` covers a gap in the shared model's own detection,
+* which matches a bare `gpt-5` prefix. The gateway also accepts the legacy
+* `databricks-` form, and `databricks-gpt-5-2` fails that match while still
+* being a reasoning model.
+*/
+const STATELESS_HELP = "See https://github.com/neondatabase/neon-pkgs/tree/main/packages/ai-sdk-provider#errors";
+/** Models the gateway serves as reasoning models on this route. */
+function isReasoningModelId(modelId) {
+	return /gpt-5/.test(modelId.toLowerCase());
+}
+/**
+* Apply the route's defaults to one call, or throw when a caller asked for
+* something the gateway cannot do. Returns the options unchanged when there is
+* nothing to add.
+*/
+function withResponsesGatewayDefaults(modelId, options) {
+	const openai = options.providerOptions?.openai;
+	const defaults = {};
+	if (openai?.store === void 0) defaults.store = false;
+	else if (openai.store === true || openai.store === null) throw new UnsupportedFunctionalityError({
+		functionality: "storing responses (providerOptions.openai.store)",
+		message: `\`store: ${String(openai.store)}\` is not available on the Neon AI Gateway, which serves the Responses API statelessly and never persists response items. Remove \`providerOptions.openai.store\`, or set it to \`false\`.` + (openai.store === null ? " `null` is not the same as omitting it — the AI SDK reads a null `store` as `true`." : "") + ` ${STATELESS_HELP}`
+	});
+	for (const option of ["previousResponseId", "conversation"]) if (openai?.[option] != null) throw new UnsupportedFunctionalityError({
+		functionality: `server-side conversation state (providerOptions.openai.${option})`,
+		message: `\`${option}\` is not available on the Neon AI Gateway, which serves the Responses API statelessly and never persists response items, so there is nothing for \`${option}\` to refer to. Send the full message history instead. ${STATELESS_HELP}`
+	});
+	if (isReasoningModelId(modelId) && openai?.forceReasoning === void 0) defaults.forceReasoning = true;
+	if (Object.keys(defaults).length === 0) return options;
+	return {
+		...options,
+		providerOptions: {
+			...options.providerOptions,
+			openai: {
+				...openai,
+				...defaults
+			}
+		}
+	};
+}
+//#endregion
+export { isReasoningModelId, withResponsesGatewayDefaults };
+
+//# sourceMappingURL=neon-responses-options.js.map

package/dist/lib/neon-responses-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"neon-responses-options.js","names":[],"sources":["../../src/lib/neon-responses-options.ts"],"sourcesContent":["import {\n\ttype LanguageModelV3CallOptions,\n\tUnsupportedFunctionalityError,\n} from \"@ai-sdk/provider\";\n\n/**\n * Request defaults for the Neon AI Gateway's Responses route.\n *\n * `store: false` is the one value this gateway accepts, not a preference. It\n * serves the Responses API statelessly and keeps no items — a response comes\n * back with `\"store\": false` even when the request never set it. Left alone the\n * shared OpenAI model assumes stored-item semantics and replays earlier\n * reasoning as `{ type: \"item_reference\", id }`, which nothing upstream can\n * resolve; the gateway answers `502 INTERNAL_ERROR` on the second step of a\n * tool loop, after the first has already succeeded. Sending `false` makes the\n * model inline the encrypted reasoning instead.\n *\n * Since no other value can work, an explicit `store` that is not `false` is\n * refused rather than sent: the request would come back `400\n * INVALID_PARAMETER_VALUE` after a round trip, and quietly forcing it to\n * `false` would be the wrong kind of quiet for a data-retention flag. A\n * type-level constraint is not available — `providerOptions` is\n * `Record<string, JSONObject>`, so a provider cannot narrow it at the call\n * site.\n *\n * `forceReasoning: true` covers a gap in the shared model's own detection,\n * which matches a bare `gpt-5` prefix. The gateway also accepts the legacy\n * `databricks-` form, and `databricks-gpt-5-2` fails that match while still\n * being a reasoning model.\n */\n\nconst STATELESS_HELP =\n\t\"See https://github.com/neondatabase/neon-pkgs/tree/main/packages/ai-sdk-provider#errors\";\n\n/** Models the gateway serves as reasoning models on this route. */\nexport function isReasoningModelId(modelId: string): boolean {\n\treturn /gpt-5/.test(modelId.toLowerCase());\n}\n\n/**\n * Apply the route's defaults to one call, or throw when a caller asked for\n * something the gateway cannot do. Returns the options unchanged when there is\n * nothing to add.\n */\nexport function withResponsesGatewayDefaults(\n\tmodelId: string,\n\toptions: LanguageModelV3CallOptions,\n): LanguageModelV3CallOptions {\n\tconst openai = options.providerOptions?.openai;\n\tconst defaults: Record<string, boolean> = {};\n\n\t// `undefined` counts as unset rather than as a choice: it serializes away,\n\t// so `{ store: undefined }` and `{}` are the same request on the wire.\n\tif (openai?.store === undefined) {\n\t\tdefaults.store = false;\n\t} else if (openai.store === true || openai.store === null) {\n\t\t// `null` reads as \"omitted\" but is not: the shared model resolves it\n\t\t// with `store ?? true`, so it asks for storage just as `true` does.\n\t\tthrow new UnsupportedFunctionalityError({\n\t\t\tfunctionality: \"storing responses (providerOptions.openai.store)\",\n\t\t\tmessage:\n\t\t\t\t`\\`store: ${String(openai.store)}\\` is not available on the Neon AI ` +\n\t\t\t\t\"Gateway, which serves the Responses API statelessly and never \" +\n\t\t\t\t\"persists response items. Remove `providerOptions.openai.store`, or \" +\n\t\t\t\t\"set it to `false`.\" +\n\t\t\t\t(openai.store === null\n\t\t\t\t\t? \" `null` is not the same as omitting it — the AI SDK reads a null\" +\n\t\t\t\t\t\t\" `store` as `true`.\"\n\t\t\t\t\t: \"\") +\n\t\t\t\t` ${STATELESS_HELP}`,\n\t\t});\n\t}\n\n\t// Any other type is left for the shared model's own provider-option schema\n\t// (`store: z.boolean().nullish()`), which rejects it locally with a type\n\t// error. Only `true` and `null` pass that schema and are refused by the\n\t// gateway, so only they need saying something about here.\n\n\t// The same statelessness rules these out, and they belong to the same set:\n\t// refusing one and forwarding the others would read as an oversight.\n\tfor (const option of [\"previousResponseId\", \"conversation\"] as const) {\n\t\tif (openai?.[option] != null) {\n\t\t\tthrow new UnsupportedFunctionalityError({\n\t\t\t\tfunctionality: `server-side conversation state (providerOptions.openai.${option})`,\n\t\t\t\tmessage:\n\t\t\t\t\t`\\`${option}\\` is not available on the Neon AI Gateway, which ` +\n\t\t\t\t\t\"serves the Responses API statelessly and never persists response \" +\n\t\t\t\t\t`items, so there is nothing for \\`${option}\\` to refer to. Send ` +\n\t\t\t\t\t`the full message history instead. ${STATELESS_HELP}`,\n\t\t\t});\n\t\t}\n\t}\n\n\tif (isReasoningModelId(modelId) && openai?.forceReasoning === undefined) {\n\t\tdefaults.forceReasoning = true;\n\t}\n\n\tif (Object.keys(defaults).length === 0) {\n\t\treturn options;\n\t}\n\treturn {\n\t\t...options,\n\t\tproviderOptions: {\n\t\t\t...options.providerOptions,\n\t\t\topenai: { ...openai, ...defaults },\n\t\t},\n\t};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAM,iBACL;;AAGD,SAAgB,mBAAmB,SAA0B;CAC5D,OAAO,QAAQ,KAAK,QAAQ,YAAY,CAAC;AAC1C;;;;;;AAOA,SAAgB,6BACf,SACA,SAC6B;CAC7B,MAAM,SAAS,QAAQ,iBAAiB;CACxC,MAAM,WAAoC,CAAC;CAI3C,IAAI,QAAQ,UAAU,KAAA,GACrB,SAAS,QAAQ;MACX,IAAI,OAAO,UAAU,QAAQ,OAAO,UAAU,MAGpD,MAAM,IAAI,8BAA8B;EACvC,eAAe;EACf,SACC,YAAY,OAAO,OAAO,KAAK,EAAE,+LAIhC,OAAO,UAAU,OACf,wFAEA,MACH,IAAI;CACN,CAAC;CAUF,KAAK,MAAM,UAAU,CAAC,sBAAsB,cAAc,GACzD,IAAI,SAAS,WAAW,MACvB,MAAM,IAAI,8BAA8B;EACvC,eAAe,0DAA0D,OAAO;EAChF,SACC,KAAK,OAAO,sJAEwB,OAAO,yDACN;CACvC,CAAC;CAIH,IAAI,mBAAmB,OAAO,KAAK,QAAQ,mBAAmB,KAAA,GAC7D,SAAS,iBAAiB;CAG3B,IAAI,OAAO,KAAK,QAAQ,CAAC,CAAC,WAAW,GACpC,OAAO;CAER,OAAO;EACN,GAAG;EACH,iBAAiB;GAChB,GAAG,QAAQ;GACX,QAAQ;IAAE,GAAG;IAAQ,GAAG;GAAS;EAClC;CACD;AACD"}

package/dist/lib/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","names":[],"sources":["../../src/lib/provider.ts"],"mappings":";;;;;;;cAoCM,iBAAe,CAAA,CAAA;;IAAf,OAAA,aAOJ;IAAA,IAAA,eAAA,cAAA,YAAA,CAAA,CAAA;;;;GAAA,CAAA,CAAA,IAAA,CAAA;KAEU,aAAA,GAAgB,CAAA,CAAE,aAAa;UA4C1B,oBAAA;;;;;;;EA9Cf;AAPmB;AAAA;AASrB;EAAyB,MAAA,CAAA,EAAA,MAAA;EAAkB;EAAf,OAAE,CAAA,EA2DnB,MA3DmB,CAAA,MAAA,EAAA,MAAA,CAAA;EAAK;EA4ClB,KAAA,CAAA,EAkBR,aAlBQ;AAAoB;AAe1B,UAMM,YAAA,SAAqB,UAN3B,CAAA;EAGF;EAAa,CAAA,OAAA,EAKX,eALW,CAAA,EAKO,eALP;EAGL;EAAa,aAAA,CAAA,OAAA,EAKN,eALM,CAAA,EAKY,eALZ;EAEnB;EAAkB,IAAA,CAAA,OAAA,EAMd,eANc,CAAA,EAMI,eANJ;EAGL;EAAkB,KAAA,EAAA,OAM3B,eAN2B;EAG3B;EAAkB,kBAAA,CAAA,OAAA,EAAA,MAAA,CAAA,EAAA,KAAA;AAGlB;AAXuB,iBAiBtB,UAAA,CAjBsB,OAAA,CAAA,EAiBF,oBAjBE,CAAA,EAiB0B,YAjB1B;AAAU;AAiBhC,cA+FH,IA/Fa,EA+FT,YA/FS"}
+{"version":3,"file":"provider.d.ts","names":[],"sources":["../../src/lib/provider.ts"],"mappings":";;;;;;;cAqCM,iBAAe,CAAA,CAAA;;IAAf,OAAA,aAOJ;IAAA,IAAA,eAAA,cAAA,YAAA,CAAA,CAAA;;;;GAAA,CAAA,CAAA,IAAA,CAAA;KAEU,aAAA,GAAgB,CAAA,CAAE,aAAa;UA4C1B,oBAAA;;;;;;;EA9Cf;AAPmB;AAAA;AASrB;EAAyB,MAAA,CAAA,EAAA,MAAA;EAAkB;EAAf,OAAE,CAAA,EA2DnB,MA3DmB,CAAA,MAAA,EAAA,MAAA,CAAA;EAAK;EA4ClB,KAAA,CAAA,EAkBR,aAlBQ;AAAoB;AAe1B,UAMM,YAAA,SAAqB,UAN3B,CAAA;EAGF;EAAa,CAAA,OAAA,EAKX,eALW,CAAA,EAKO,eALP;EAGL;EAAa,aAAA,CAAA,OAAA,EAKN,eALM,CAAA,EAKY,eALZ;EAEnB;EAAkB,IAAA,CAAA,OAAA,EAMd,eANc,CAAA,EAMI,eANJ;EAGL;EAAkB,KAAA,EAAA,OAM3B,eAN2B;EAG3B;EAAkB,kBAAA,CAAA,OAAA,EAAA,MAAA,CAAA,EAAA,KAAA;AAGlB;AAXuB,iBAiBtB,UAAA,CAjBsB,OAAA,CAAA,EAiBF,oBAjBE,CAAA,EAiB0B,YAjB1B;AAAU;AAiBhC,cAiHH,IAjHa,EAiHT,YAjHS"}

package/dist/lib/provider.js

@@ -2,6 +2,7 @@ import { NeonAnthropicLanguageModel } from "./neon-anthropic-language-model.js";
 import { getNeonModelRoute } from "./neon-model-capabilities.js";
 import { NeonChatLanguageModel } from "./neon-chat-language-model.js";
 import { NeonResponsesLanguageModel } from "./neon-responses-language-model.js";
+import { wrapFetchWithGatewayErrorNormalization } from "./neon-gateway-error.js";
 import { wrapFetchWithHarmonyNormalization } from "./neon-harmony-normalize.js";
 import { neonOpenAITools } from "./neon-openai-tools.js";
 import { VERSION } from "./version.js";
@@ -61,21 +62,21 @@ function createNeon(options = {}) {
 		provider: "neon.anthropic",
 		baseURL: `${getHost()}/anthropic/v1`,
 		headers: () => getHeaders({ "anthropic-version": "2023-06-01" }),
-		fetch: options.fetch,
+		fetch: wrapFetchWithGatewayErrorNormalization(options.fetch, "anthropic"),
 		generateId
 	});
 	const createOpenAIModel = (modelId) => new NeonResponsesLanguageModel(modelId, {
 		provider: "neon.openai.responses",
 		url: ({ path }) => `${getHost()}/openai/v1${path}`,
 		headers: getHeaders,
-		fetch: options.fetch,
+		fetch: wrapFetchWithGatewayErrorNormalization(options.fetch, "openai"),
 		fileIdPrefixes: ["file-"]
 	});
 	const createChatModel = (modelId) => new NeonChatLanguageModel(modelId, {
 		provider: "neon.chat",
 		url: ({ path }) => `${getHost()}/v1${path}`,
 		headers: getHeaders,
-		fetch: wrapFetchWithHarmonyNormalization(options.fetch),
+		fetch: wrapFetchWithHarmonyNormalization(wrapFetchWithGatewayErrorNormalization(options.fetch, "openai")),
 		errorStructure: neonErrorStructure,
 		transformRequestBody: transformNeonRequestBody,
 		supportsStructuredOutputs: true

package/dist/lib/provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"provider.js","names":[],"sources":["../../src/lib/provider.ts"],"sourcesContent":["/**\n * Community Vercel AI SDK provider for the Neon AI Gateway.\n *\n * `createNeon()` returns a provider that routes each model to the best gateway\n * endpoint based on its id (Anthropic → native Messages, OpenAI → native\n * Responses incl. Codex, everything else → unified Chat Completions), so a single\n * `neon('claude-...')` call (same base URL + token) reaches the whole catalog.\n * Ids use the canonical Neon (unprefixed) form; the legacy `databricks-` prefix\n * is also accepted. Configure with the branch-scoped `NEON_AI_GATEWAY_BASE_URL` +\n * `NEON_AI_GATEWAY_TOKEN` emitted by `neonctl env pull` / `neon dev`, or pass\n * `baseURL` / `apiKey` explicitly.\n */\nimport type { ProviderErrorStructure } from \"@ai-sdk/openai-compatible\";\nimport {\n\ttype LanguageModelV3,\n\tNoSuchModelError,\n\ttype ProviderV3,\n} from \"@ai-sdk/provider\";\nimport {\n\ttype FetchFunction,\n\tgenerateId,\n\tloadApiKey,\n\tloadSetting,\n\twithoutTrailingSlash,\n\twithUserAgentSuffix,\n} from \"@ai-sdk/provider-utils\";\nimport { z } from \"zod/v4\";\nimport { NeonAnthropicLanguageModel } from \"./neon-anthropic-language-model.js\";\nimport { NeonChatLanguageModel } from \"./neon-chat-language-model.js\";\nimport type { NeonChatModelId } from \"./neon-chat-options.js\";\nimport { wrapFetchWithHarmonyNormalization } from \"./neon-harmony-normalize.js\";\nimport { getNeonModelRoute } from \"./neon-model-capabilities.js\";\nimport { neonOpenAITools } from \"./neon-openai-tools.js\";\nimport { NeonResponsesLanguageModel } from \"./neon-responses-language-model.js\";\nimport { VERSION } from \"./version.js\";\n\nconst neonErrorSchema = z.object({\n\terror: z.object({\n\t\tmessage: z.string(),\n\t\ttype: z.string().nullish(),\n\t\tparam: z.unknown().nullish(),\n\t\tcode: z.unknown().nullish(),\n\t}),\n});\n\nexport type NeonErrorData = z.infer<typeof neonErrorSchema>;\n\nconst neonErrorStructure: ProviderErrorStructure<NeonErrorData> = {\n\terrorSchema: neonErrorSchema,\n\terrorToMessage: (data) => data.error.message,\n};\n\n/**\n * Recursively remove the JSON Schema `$schema` marker, which some gateway\n * backends (notably Gemini) reject in tool/structured-output schemas. Other\n * backends ignore its absence, so stripping it everywhere is safe.\n */\nfunction stripJsonSchemaMarker(value: unknown): unknown {\n\tif (Array.isArray(value)) {\n\t\treturn value.map(stripJsonSchemaMarker);\n\t}\n\tif (value !== null && typeof value === \"object\") {\n\t\tconst result: Record<string, unknown> = {};\n\t\tfor (const [key, entry] of Object.entries(value)) {\n\t\t\tif (key === \"$schema\") {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tresult[key] = stripJsonSchemaMarker(entry);\n\t\t}\n\t\treturn result;\n\t}\n\treturn value;\n}\n\nfunction transformNeonRequestBody(\n\targs: Record<string, unknown>,\n): Record<string, unknown> {\n\tconst transformed = { ...args };\n\tif (transformed.tools != null) {\n\t\ttransformed.tools = stripJsonSchemaMarker(transformed.tools);\n\t}\n\tif (transformed.response_format != null) {\n\t\ttransformed.response_format = stripJsonSchemaMarker(\n\t\t\ttransformed.response_format,\n\t\t);\n\t}\n\treturn transformed;\n}\n\nexport interface NeonProviderSettings {\n\t/**\n\t * Neon AI Gateway base URL — the branch-scoped host root, e.g.\n\t * `https://<branch-id>-api.ai.<region>.aws.neon.tech`. The gateway paths are\n\t * appended internally. Falls back to the `NEON_AI_GATEWAY_BASE_URL` env var.\n\t */\n\tbaseURL?: string;\n\n\t/**\n\t * Neon AI Gateway platform token (the `nt_live_...` value). Falls back to the\n\t * `NEON_AI_GATEWAY_TOKEN` env var.\n\t */\n\tapiKey?: string;\n\n\t/** Custom headers to include in the requests. */\n\theaders?: Record<string, string>;\n\n\t/** Custom fetch implementation (e.g. for testing or middleware). */\n\tfetch?: FetchFunction;\n}\n\nexport interface NeonProvider extends ProviderV3 {\n\t/** Creates a Neon AI Gateway model for text generation. */\n\t(modelId: NeonChatModelId): LanguageModelV3;\n\n\t/** Creates a Neon AI Gateway model for text generation. */\n\tlanguageModel(modelId: NeonChatModelId): LanguageModelV3;\n\n\t/** Creates a Neon AI Gateway chat model for text generation. */\n\tchat(modelId: NeonChatModelId): LanguageModelV3;\n\n\t/** OpenAI Responses tools (e.g. `imageGeneration`) for OpenAI-routed models. */\n\ttools: typeof neonOpenAITools;\n\n\t/** @deprecated Use `embeddingModel` instead. */\n\ttextEmbeddingModel(modelId: string): never;\n}\n\nexport function createNeon(options: NeonProviderSettings = {}): NeonProvider {\n\t// Resolved lazily so that `createNeon()` and the default `neon` instance do\n\t// not throw at import time when configuration comes from the environment.\n\tconst getHost = () =>\n\t\twithoutTrailingSlash(\n\t\t\tloadSetting({\n\t\t\t\tsettingValue: options.baseURL,\n\t\t\t\tenvironmentVariableName: \"NEON_AI_GATEWAY_BASE_URL\",\n\t\t\t\tsettingName: \"baseURL\",\n\t\t\t\tdescription: \"Neon AI Gateway base URL\",\n\t\t\t}),\n\t\t);\n\n\tconst getHeaders = (extra?: Record<string, string>) =>\n\t\twithUserAgentSuffix(\n\t\t\t{\n\t\t\t\tAuthorization: `Bearer ${loadApiKey({\n\t\t\t\t\tapiKey: options.apiKey,\n\t\t\t\t\tenvironmentVariableName: \"NEON_AI_GATEWAY_TOKEN\",\n\t\t\t\t\tdescription: \"Neon AI Gateway token\",\n\t\t\t\t})}`,\n\t\t\t\t...extra,\n\t\t\t\t...options.headers,\n\t\t\t},\n\t\t\t`neondatabase/ai-sdk-provider/${VERSION}`,\n\t\t);\n\n\t// Anthropic models -> native Messages API.\n\tconst createAnthropicModel = (modelId: NeonChatModelId) =>\n\t\tnew NeonAnthropicLanguageModel(modelId, {\n\t\t\tprovider: \"neon.anthropic\",\n\t\t\tbaseURL: `${getHost()}/anthropic/v1`,\n\t\t\theaders: () => getHeaders({ \"anthropic-version\": \"2023-06-01\" }),\n\t\t\tfetch: options.fetch,\n\t\t\tgenerateId,\n\t\t});\n\n\t// OpenAI models (incl. Codex, only served natively) -> Responses API.\n\tconst createOpenAIModel = (modelId: NeonChatModelId) =>\n\t\tnew NeonResponsesLanguageModel(modelId, {\n\t\t\tprovider: \"neon.openai.responses\",\n\t\t\turl: ({ path }) => `${getHost()}/openai/v1${path}`,\n\t\t\theaders: getHeaders,\n\t\t\tfetch: options.fetch,\n\t\t\tfileIdPrefixes: [\"file-\"],\n\t\t});\n\n\t// Everything else (Gemini, Llama, Qwen, gpt-oss, ...) -> unified Chat\n\t// Completions endpoint. Gemini is here because its native endpoint can't stream.\n\tconst createChatModel = (modelId: NeonChatModelId) =>\n\t\tnew NeonChatLanguageModel(modelId, {\n\t\t\tprovider: \"neon.chat\",\n\t\t\turl: ({ path }) => `${getHost()}/v1${path}`,\n\t\t\theaders: getHeaders,\n\t\t\t// TODO(#308): Temporary workaround for gpt-oss. The gateway returns a\n\t\t\t// non-compliant \"harmony\" content-array shape; this wrapper normalizes it\n\t\t\t// to the Chat Completions contract and is a transparent pass-through for\n\t\t\t// every compliant response. Remove it (and neon-harmony-normalize.ts) once\n\t\t\t// the gateway returns spec-compliant gpt-oss responses.\n\t\t\tfetch: wrapFetchWithHarmonyNormalization(options.fetch),\n\t\t\terrorStructure: neonErrorStructure,\n\t\t\ttransformRequestBody: transformNeonRequestBody,\n\t\t\tsupportsStructuredOutputs: true,\n\t\t});\n\n\tconst createLanguageModel = (modelId: NeonChatModelId): LanguageModelV3 => {\n\t\tswitch (getNeonModelRoute(modelId)) {\n\t\t\tcase \"anthropic\":\n\t\t\t\treturn createAnthropicModel(modelId);\n\t\t\tcase \"openai\":\n\t\t\t\treturn createOpenAIModel(modelId);\n\t\t\tdefault:\n\t\t\t\treturn createChatModel(modelId);\n\t\t}\n\t};\n\n\tconst provider = (modelId: NeonChatModelId) => createLanguageModel(modelId);\n\n\tprovider.specificationVersion = \"v3\" as const;\n\tprovider.languageModel = createLanguageModel;\n\tprovider.chat = createLanguageModel;\n\tprovider.tools = neonOpenAITools;\n\n\tprovider.embeddingModel = (modelId: string) => {\n\t\tthrow new NoSuchModelError({ modelId, modelType: \"embeddingModel\" });\n\t};\n\tprovider.textEmbeddingModel = provider.embeddingModel;\n\tprovider.imageModel = (modelId: string) => {\n\t\tthrow new NoSuchModelError({ modelId, modelType: \"imageModel\" });\n\t};\n\n\treturn provider;\n}\n\n/** Default Neon provider instance (reads `NEON_AI_GATEWAY_*` env vars). */\nexport const neon = createNeon();\n"],"mappings":";;;;;;;;;;;AA+CA,MAAM,qBAA4D;CACjE,aAZuB,EAAE,OAAO,EAChC,OAAO,EAAE,OAAO;EACf,SAAS,EAAE,OAAO;EAClB,MAAM,EAAE,OAAO,CAAC,CAAC,QAAQ;EACzB,OAAO,EAAE,QAAQ,CAAC,CAAC,QAAQ;EAC3B,MAAM,EAAE,QAAQ,CAAC,CAAC,QAAQ;CAC3B,CAAC,EACF,CAK4B;CAC3B,iBAAiB,SAAS,KAAK,MAAM;AACtC;;;;;;AAOA,SAAS,sBAAsB,OAAyB;CACvD,IAAI,MAAM,QAAQ,KAAK,GACtB,OAAO,MAAM,IAAI,qBAAqB;CAEvC,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;EAChD,MAAM,SAAkC,CAAC;EACzC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAAG;GACjD,IAAI,QAAQ,WACX;GAED,OAAO,OAAO,sBAAsB,KAAK;EAC1C;EACA,OAAO;CACR;CACA,OAAO;AACR;AAEA,SAAS,yBACR,MAC0B;CAC1B,MAAM,cAAc,EAAE,GAAG,KAAK;CAC9B,IAAI,YAAY,SAAS,MACxB,YAAY,QAAQ,sBAAsB,YAAY,KAAK;CAE5D,IAAI,YAAY,mBAAmB,MAClC,YAAY,kBAAkB,sBAC7B,YAAY,eACb;CAED,OAAO;AACR;AAwCA,SAAgB,WAAW,UAAgC,CAAC,GAAiB;CAG5E,MAAM,gBACL,qBACC,YAAY;EACX,cAAc,QAAQ;EACtB,yBAAyB;EACzB,aAAa;EACb,aAAa;CACd,CAAC,CACF;CAED,MAAM,cAAc,UACnB,oBACC;EACC,eAAe,UAAU,WAAW;GACnC,QAAQ,QAAQ;GAChB,yBAAyB;GACzB,aAAa;EACd,CAAC;EACD,GAAG;EACH,GAAG,QAAQ;CACZ,GACA,gCAAgC,SACjC;CAGD,MAAM,wBAAwB,YAC7B,IAAI,2BAA2B,SAAS;EACvC,UAAU;EACV,SAAS,GAAG,QAAQ,EAAE;EACtB,eAAe,WAAW,EAAE,qBAAqB,aAAa,CAAC;EAC/D,OAAO,QAAQ;EACf;CACD,CAAC;CAGF,MAAM,qBAAqB,YAC1B,IAAI,2BAA2B,SAAS;EACvC,UAAU;EACV,MAAM,EAAE,WAAW,GAAG,QAAQ,EAAE,YAAY;EAC5C,SAAS;EACT,OAAO,QAAQ;EACf,gBAAgB,CAAC,OAAO;CACzB,CAAC;CAIF,MAAM,mBAAmB,YACxB,IAAI,sBAAsB,SAAS;EAClC,UAAU;EACV,MAAM,EAAE,WAAW,GAAG,QAAQ,EAAE,KAAK;EACrC,SAAS;EAMT,OAAO,kCAAkC,QAAQ,KAAK;EACtD,gBAAgB;EAChB,sBAAsB;EACtB,2BAA2B;CAC5B,CAAC;CAEF,MAAM,uBAAuB,YAA8C;EAC1E,QAAQ,kBAAkB,OAAO,GAAjC;GACC,KAAK,aACJ,OAAO,qBAAqB,OAAO;GACpC,KAAK,UACJ,OAAO,kBAAkB,OAAO;GACjC,SACC,OAAO,gBAAgB,OAAO;EAChC;CACD;CAEA,MAAM,YAAY,YAA6B,oBAAoB,OAAO;CAE1E,SAAS,uBAAuB;CAChC,SAAS,gBAAgB;CACzB,SAAS,OAAO;CAChB,SAAS,QAAQ;CAEjB,SAAS,kBAAkB,YAAoB;EAC9C,MAAM,IAAI,iBAAiB;GAAE;GAAS,WAAW;EAAiB,CAAC;CACpE;CACA,SAAS,qBAAqB,SAAS;CACvC,SAAS,cAAc,YAAoB;EAC1C,MAAM,IAAI,iBAAiB;GAAE;GAAS,WAAW;EAAa,CAAC;CAChE;CAEA,OAAO;AACR;;AAGA,MAAa,OAAO,WAAW"}
+{"version":3,"file":"provider.js","names":[],"sources":["../../src/lib/provider.ts"],"sourcesContent":["/**\n * Community Vercel AI SDK provider for the Neon AI Gateway.\n *\n * `createNeon()` returns a provider that routes each model to the best gateway\n * endpoint based on its id (Anthropic → native Messages, OpenAI → native\n * Responses incl. Codex, everything else → unified Chat Completions), so a single\n * `neon('claude-...')` call (same base URL + token) reaches the whole catalog.\n * Ids use the canonical Neon (unprefixed) form; the legacy `databricks-` prefix\n * is also accepted. Configure with the branch-scoped `NEON_AI_GATEWAY_BASE_URL` +\n * `NEON_AI_GATEWAY_TOKEN` emitted by `neonctl env pull` / `neon dev`, or pass\n * `baseURL` / `apiKey` explicitly.\n */\nimport type { ProviderErrorStructure } from \"@ai-sdk/openai-compatible\";\nimport {\n\ttype LanguageModelV3,\n\tNoSuchModelError,\n\ttype ProviderV3,\n} from \"@ai-sdk/provider\";\nimport {\n\ttype FetchFunction,\n\tgenerateId,\n\tloadApiKey,\n\tloadSetting,\n\twithoutTrailingSlash,\n\twithUserAgentSuffix,\n} from \"@ai-sdk/provider-utils\";\nimport { z } from \"zod/v4\";\nimport { NeonAnthropicLanguageModel } from \"./neon-anthropic-language-model.js\";\nimport { NeonChatLanguageModel } from \"./neon-chat-language-model.js\";\nimport type { NeonChatModelId } from \"./neon-chat-options.js\";\nimport { wrapFetchWithGatewayErrorNormalization } from \"./neon-gateway-error.js\";\nimport { wrapFetchWithHarmonyNormalization } from \"./neon-harmony-normalize.js\";\nimport { getNeonModelRoute } from \"./neon-model-capabilities.js\";\nimport { neonOpenAITools } from \"./neon-openai-tools.js\";\nimport { NeonResponsesLanguageModel } from \"./neon-responses-language-model.js\";\nimport { VERSION } from \"./version.js\";\n\nconst neonErrorSchema = z.object({\n\terror: z.object({\n\t\tmessage: z.string(),\n\t\ttype: z.string().nullish(),\n\t\tparam: z.unknown().nullish(),\n\t\tcode: z.unknown().nullish(),\n\t}),\n});\n\nexport type NeonErrorData = z.infer<typeof neonErrorSchema>;\n\nconst neonErrorStructure: ProviderErrorStructure<NeonErrorData> = {\n\terrorSchema: neonErrorSchema,\n\terrorToMessage: (data) => data.error.message,\n};\n\n/**\n * Recursively remove the JSON Schema `$schema` marker, which some gateway\n * backends (notably Gemini) reject in tool/structured-output schemas. Other\n * backends ignore its absence, so stripping it everywhere is safe.\n */\nfunction stripJsonSchemaMarker(value: unknown): unknown {\n\tif (Array.isArray(value)) {\n\t\treturn value.map(stripJsonSchemaMarker);\n\t}\n\tif (value !== null && typeof value === \"object\") {\n\t\tconst result: Record<string, unknown> = {};\n\t\tfor (const [key, entry] of Object.entries(value)) {\n\t\t\tif (key === \"$schema\") {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tresult[key] = stripJsonSchemaMarker(entry);\n\t\t}\n\t\treturn result;\n\t}\n\treturn value;\n}\n\nfunction transformNeonRequestBody(\n\targs: Record<string, unknown>,\n): Record<string, unknown> {\n\tconst transformed = { ...args };\n\tif (transformed.tools != null) {\n\t\ttransformed.tools = stripJsonSchemaMarker(transformed.tools);\n\t}\n\tif (transformed.response_format != null) {\n\t\ttransformed.response_format = stripJsonSchemaMarker(\n\t\t\ttransformed.response_format,\n\t\t);\n\t}\n\treturn transformed;\n}\n\nexport interface NeonProviderSettings {\n\t/**\n\t * Neon AI Gateway base URL — the branch-scoped host root, e.g.\n\t * `https://<branch-id>-api.ai.<region>.aws.neon.tech`. The gateway paths are\n\t * appended internally. Falls back to the `NEON_AI_GATEWAY_BASE_URL` env var.\n\t */\n\tbaseURL?: string;\n\n\t/**\n\t * Neon AI Gateway platform token (the `nt_live_...` value). Falls back to the\n\t * `NEON_AI_GATEWAY_TOKEN` env var.\n\t */\n\tapiKey?: string;\n\n\t/** Custom headers to include in the requests. */\n\theaders?: Record<string, string>;\n\n\t/** Custom fetch implementation (e.g. for testing or middleware). */\n\tfetch?: FetchFunction;\n}\n\nexport interface NeonProvider extends ProviderV3 {\n\t/** Creates a Neon AI Gateway model for text generation. */\n\t(modelId: NeonChatModelId): LanguageModelV3;\n\n\t/** Creates a Neon AI Gateway model for text generation. */\n\tlanguageModel(modelId: NeonChatModelId): LanguageModelV3;\n\n\t/** Creates a Neon AI Gateway chat model for text generation. */\n\tchat(modelId: NeonChatModelId): LanguageModelV3;\n\n\t/** OpenAI Responses tools (e.g. `imageGeneration`) for OpenAI-routed models. */\n\ttools: typeof neonOpenAITools;\n\n\t/** @deprecated Use `embeddingModel` instead. */\n\ttextEmbeddingModel(modelId: string): never;\n}\n\nexport function createNeon(options: NeonProviderSettings = {}): NeonProvider {\n\t// Resolved lazily so that `createNeon()` and the default `neon` instance do\n\t// not throw at import time when configuration comes from the environment.\n\tconst getHost = () =>\n\t\twithoutTrailingSlash(\n\t\t\tloadSetting({\n\t\t\t\tsettingValue: options.baseURL,\n\t\t\t\tenvironmentVariableName: \"NEON_AI_GATEWAY_BASE_URL\",\n\t\t\t\tsettingName: \"baseURL\",\n\t\t\t\tdescription: \"Neon AI Gateway base URL\",\n\t\t\t}),\n\t\t);\n\n\tconst getHeaders = (extra?: Record<string, string>) =>\n\t\twithUserAgentSuffix(\n\t\t\t{\n\t\t\t\tAuthorization: `Bearer ${loadApiKey({\n\t\t\t\t\tapiKey: options.apiKey,\n\t\t\t\t\tenvironmentVariableName: \"NEON_AI_GATEWAY_TOKEN\",\n\t\t\t\t\tdescription: \"Neon AI Gateway token\",\n\t\t\t\t})}`,\n\t\t\t\t...extra,\n\t\t\t\t...options.headers,\n\t\t\t},\n\t\t\t`neondatabase/ai-sdk-provider/${VERSION}`,\n\t\t);\n\n\t// Anthropic models -> native Messages API.\n\tconst createAnthropicModel = (modelId: NeonChatModelId) =>\n\t\tnew NeonAnthropicLanguageModel(modelId, {\n\t\t\tprovider: \"neon.anthropic\",\n\t\t\tbaseURL: `${getHost()}/anthropic/v1`,\n\t\t\theaders: () => getHeaders({ \"anthropic-version\": \"2023-06-01\" }),\n\t\t\tfetch: wrapFetchWithGatewayErrorNormalization(\n\t\t\t\toptions.fetch,\n\t\t\t\t\"anthropic\",\n\t\t\t),\n\t\t\tgenerateId,\n\t\t});\n\n\t// OpenAI models (incl. Codex, only served natively) -> Responses API.\n\tconst createOpenAIModel = (modelId: NeonChatModelId) =>\n\t\tnew NeonResponsesLanguageModel(modelId, {\n\t\t\tprovider: \"neon.openai.responses\",\n\t\t\turl: ({ path }) => `${getHost()}/openai/v1${path}`,\n\t\t\theaders: getHeaders,\n\t\t\t// This route returns Databricks error envelopes the OpenAI schema\n\t\t\t// cannot read, which reach the caller as a bare \"Bad Request\".\n\t\t\t// `OpenAIConfig` has no error hook, so the rewrite rides on fetch.\n\t\t\tfetch: wrapFetchWithGatewayErrorNormalization(\n\t\t\t\toptions.fetch,\n\t\t\t\t\"openai\",\n\t\t\t),\n\t\t\tfileIdPrefixes: [\"file-\"],\n\t\t});\n\n\t// Everything else (Gemini, Llama, Qwen, gpt-oss, ...) -> unified Chat\n\t// Completions endpoint. Gemini is here because its native endpoint can't stream.\n\tconst createChatModel = (modelId: NeonChatModelId) =>\n\t\tnew NeonChatLanguageModel(modelId, {\n\t\t\tprovider: \"neon.chat\",\n\t\t\turl: ({ path }) => `${getHost()}/v1${path}`,\n\t\t\theaders: getHeaders,\n\t\t\t// Two wrappers, on disjoint halves of the response: the harmony one\n\t\t\t// rewrites successful gpt-oss bodies and returns early on any error,\n\t\t\t// the error one only touches non-2xx bodies. This route emits the\n\t\t\t// same flat `{ error_code, message }` Databricks envelope as the\n\t\t\t// Responses route (an out-of-range `temperature`, say), which\n\t\t\t// `errorStructure` below cannot read on its own.\n\t\t\t//\n\t\t\t// TODO(#308): Temporary workaround for gpt-oss. The gateway returns a\n\t\t\t// non-compliant \"harmony\" content-array shape; this wrapper normalizes it\n\t\t\t// to the Chat Completions contract and is a transparent pass-through for\n\t\t\t// every compliant response. Remove it (and neon-harmony-normalize.ts) once\n\t\t\t// the gateway returns spec-compliant gpt-oss responses.\n\t\t\tfetch: wrapFetchWithHarmonyNormalization(\n\t\t\t\twrapFetchWithGatewayErrorNormalization(options.fetch, \"openai\"),\n\t\t\t),\n\t\t\terrorStructure: neonErrorStructure,\n\t\t\ttransformRequestBody: transformNeonRequestBody,\n\t\t\tsupportsStructuredOutputs: true,\n\t\t});\n\n\tconst createLanguageModel = (modelId: NeonChatModelId): LanguageModelV3 => {\n\t\tswitch (getNeonModelRoute(modelId)) {\n\t\t\tcase \"anthropic\":\n\t\t\t\treturn createAnthropicModel(modelId);\n\t\t\tcase \"openai\":\n\t\t\t\treturn createOpenAIModel(modelId);\n\t\t\tdefault:\n\t\t\t\treturn createChatModel(modelId);\n\t\t}\n\t};\n\n\tconst provider = (modelId: NeonChatModelId) => createLanguageModel(modelId);\n\n\tprovider.specificationVersion = \"v3\" as const;\n\tprovider.languageModel = createLanguageModel;\n\tprovider.chat = createLanguageModel;\n\tprovider.tools = neonOpenAITools;\n\n\tprovider.embeddingModel = (modelId: string) => {\n\t\tthrow new NoSuchModelError({ modelId, modelType: \"embeddingModel\" });\n\t};\n\tprovider.textEmbeddingModel = provider.embeddingModel;\n\tprovider.imageModel = (modelId: string) => {\n\t\tthrow new NoSuchModelError({ modelId, modelType: \"imageModel\" });\n\t};\n\n\treturn provider;\n}\n\n/** Default Neon provider instance (reads `NEON_AI_GATEWAY_*` env vars). */\nexport const neon = createNeon();\n"],"mappings":";;;;;;;;;;;;AAgDA,MAAM,qBAA4D;CACjE,aAZuB,EAAE,OAAO,EAChC,OAAO,EAAE,OAAO;EACf,SAAS,EAAE,OAAO;EAClB,MAAM,EAAE,OAAO,CAAC,CAAC,QAAQ;EACzB,OAAO,EAAE,QAAQ,CAAC,CAAC,QAAQ;EAC3B,MAAM,EAAE,QAAQ,CAAC,CAAC,QAAQ;CAC3B,CAAC,EACF,CAK4B;CAC3B,iBAAiB,SAAS,KAAK,MAAM;AACtC;;;;;;AAOA,SAAS,sBAAsB,OAAyB;CACvD,IAAI,MAAM,QAAQ,KAAK,GACtB,OAAO,MAAM,IAAI,qBAAqB;CAEvC,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;EAChD,MAAM,SAAkC,CAAC;EACzC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAAG;GACjD,IAAI,QAAQ,WACX;GAED,OAAO,OAAO,sBAAsB,KAAK;EAC1C;EACA,OAAO;CACR;CACA,OAAO;AACR;AAEA,SAAS,yBACR,MAC0B;CAC1B,MAAM,cAAc,EAAE,GAAG,KAAK;CAC9B,IAAI,YAAY,SAAS,MACxB,YAAY,QAAQ,sBAAsB,YAAY,KAAK;CAE5D,IAAI,YAAY,mBAAmB,MAClC,YAAY,kBAAkB,sBAC7B,YAAY,eACb;CAED,OAAO;AACR;AAwCA,SAAgB,WAAW,UAAgC,CAAC,GAAiB;CAG5E,MAAM,gBACL,qBACC,YAAY;EACX,cAAc,QAAQ;EACtB,yBAAyB;EACzB,aAAa;EACb,aAAa;CACd,CAAC,CACF;CAED,MAAM,cAAc,UACnB,oBACC;EACC,eAAe,UAAU,WAAW;GACnC,QAAQ,QAAQ;GAChB,yBAAyB;GACzB,aAAa;EACd,CAAC;EACD,GAAG;EACH,GAAG,QAAQ;CACZ,GACA,gCAAgC,SACjC;CAGD,MAAM,wBAAwB,YAC7B,IAAI,2BAA2B,SAAS;EACvC,UAAU;EACV,SAAS,GAAG,QAAQ,EAAE;EACtB,eAAe,WAAW,EAAE,qBAAqB,aAAa,CAAC;EAC/D,OAAO,uCACN,QAAQ,OACR,WACD;EACA;CACD,CAAC;CAGF,MAAM,qBAAqB,YAC1B,IAAI,2BAA2B,SAAS;EACvC,UAAU;EACV,MAAM,EAAE,WAAW,GAAG,QAAQ,EAAE,YAAY;EAC5C,SAAS;EAIT,OAAO,uCACN,QAAQ,OACR,QACD;EACA,gBAAgB,CAAC,OAAO;CACzB,CAAC;CAIF,MAAM,mBAAmB,YACxB,IAAI,sBAAsB,SAAS;EAClC,UAAU;EACV,MAAM,EAAE,WAAW,GAAG,QAAQ,EAAE,KAAK;EACrC,SAAS;EAaT,OAAO,kCACN,uCAAuC,QAAQ,OAAO,QAAQ,CAC/D;EACA,gBAAgB;EAChB,sBAAsB;EACtB,2BAA2B;CAC5B,CAAC;CAEF,MAAM,uBAAuB,YAA8C;EAC1E,QAAQ,kBAAkB,OAAO,GAAjC;GACC,KAAK,aACJ,OAAO,qBAAqB,OAAO;GACpC,KAAK,UACJ,OAAO,kBAAkB,OAAO;GACjC,SACC,OAAO,gBAAgB,OAAO;EAChC;CACD;CAEA,MAAM,YAAY,YAA6B,oBAAoB,OAAO;CAE1E,SAAS,uBAAuB;CAChC,SAAS,gBAAgB;CACzB,SAAS,OAAO;CAChB,SAAS,QAAQ;CAEjB,SAAS,kBAAkB,YAAoB;EAC9C,MAAM,IAAI,iBAAiB;GAAE;GAAS,WAAW;EAAiB,CAAC;CACpE;CACA,SAAS,qBAAqB,SAAS;CACvC,SAAS,cAAc,YAAoB;EAC1C,MAAM,IAAI,iBAAiB;GAAE;GAAS,WAAW;EAAa,CAAC;CAChE;CAEA,OAAO;AACR;;AAGA,MAAa,OAAO,WAAW"}

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.7.2";
+var version = "0.7.3";
 //#endregion
 export { version };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neon/ai-sdk-provider",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Community Vercel AI SDK provider for the Neon AI Gateway.",
   "keywords": [
     "neon",