@neondatabase/ai-sdk-provider 0.0.0 → 0.1.1

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));
-	}
-}

package/src/lib/provider.ts

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

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

package/src/v1.ts

@@ -1,26 +0,0 @@
-/**
- * `@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

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

package/tsdown.config.ts

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

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