@macpaw/ai-sdk 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,39 @@
+# @macpaw/ai-sdk
+
+> Changelog is maintained by [semantic-release](https://github.com/semantic-release/semantic-release). Versions and entries are added automatically on release; do not edit version headings manually.
+
+## Unreleased
+
+### Changed
+
+- Flat `src/` architecture — no `src/api/` or `src/client/` subdirectories.
+- `createGatewayFetch` replaces the old low-level client as the escape-hatch for custom HTTP calls.
+- `@ai-sdk/openai` is now a required peer dependency (used directly in `gateway-provider.ts`).
+- `withRetry` now accepts `Required<RetryConfig>` (already-normalised config); callers must not pass un-normalised objects.
+- Auth retry guard: requests with a streaming body (`ReadableStream`) throw `AuthError` immediately instead of attempting a silent re-play of the consumed stream.
+- Test coverage added for `gateway-errors`, `gateway-retry`, `gateway-request` internals, and NestJS decorators.
+- Removed `@macpaw/ai-sdk/types` subpath — domain types are exported from the root entry.
+- Removed `@macpaw/ai-sdk/runtime` subpath — there is no separate runtime surface.
+- Removed lifecycle hooks (`onRequest`, `onResponse`, `onError`, `onRetry`) — not part of the public API.
+- Removed pluggable transport layer — `GatewayProviderSettings.fetch` covers custom fetch injection.
+- Removed `autoRefreshToken` / `tokenCacheTTL` options — token refresh is handled automatically on 401.
+- Vitest fails when no tests are discovered, tightening release-time verification.
+
+## 0.1.0
+
+### Added
+
+- `createAIGatewayProvider` / `createGatewayProvider` — Vercel AI SDK provider for the MacPaw AI Gateway.
+- `GATEWAY_PROVIDERS` — map of supported model providers.
+- `createGatewayFetch` / `GATEWAY_PLACEHOLDER_API_KEY` — escape-hatch for custom HTTP calls to the gateway.
+- Error class hierarchy: `AIGatewayError`, `AuthError`, `CreditsError`, `RateLimitError`, `ModelNotAllowedError`, `GatewayValidationError`.
+- `parseErrorResponse` / `parseStreamErrorPayload` / `parseErrorResponseFromResponse` — normalise both Gateway API and OpenAI proxy error shapes.
+- Auth via `getAuthToken` callback; automatic token refresh on 401 with a single retry.
+- Retry with exponential backoff and jitter (`withRetry`, `RetryConfig`).
+- Middleware pipeline (`Middleware` type, applied per-request).
+- Per-request timeout via `AbortController`; combined `AbortSignal` support via `anySignal`.
+- `X-Request-ID` auto-generation and propagation.
+- NestJS integration: `AIGatewayModule`, `AI_GATEWAY_CONFIG` token, `@InjectAIGateway()` decorator, `AIGatewayExceptionFilter`.
+- Exported types: `GatewayProviderSettings`, `RetryConfig`, `Middleware`, `ErrorCode`, `NormalizedErrorMetadata`, etc.
+- Dual ESM + CJS output via tsup.
+- Strict TypeScript targeting ES2022.

package/LICENSE

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

package/MIGRATION.md

@@ -0,0 +1,52 @@
+# Integration guide — `@macpaw/ai-sdk`
+
+This package is a **small Vercel AI SDK extension** for MacPaw AI Gateway. Upstream **`ai`**, **`@ai-sdk/openai`**, **`@ai-sdk/react`** (or **`ai/react`**) stay the source for core APIs and hooks.
+
+## Entry points
+
+| Path                      | Role                                                                                                                                            |
+| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@macpaw/ai-sdk`          | **Use this** — `createAIGatewayProvider`, `createGatewayProvider`, `createGatewayFetch`, `GATEWAY_PROVIDERS`, errors, `GatewayProviderSettings` |
+| `@macpaw/ai-sdk/provider` | **Compatibility alias** — same bundle and exports as the root                                                                                   |
+| `@macpaw/ai-sdk/nestjs`   | NestJS module, `@InjectAIGateway()`, `AIGatewayExceptionFilter`                                                                                 |
+
+The following paths are **not** published in current versions:
+
+- `@macpaw/ai-sdk/client`
+- `@macpaw/ai-sdk/runtime`
+- `@macpaw/ai-sdk/types`
+- `@macpaw/ai-sdk/testing`
+
+## If you used the old HTTP client
+
+Replace `createAIGatewayClient` with:
+
+1. **Vercel flows** — `createAIGatewayProvider` / `createGatewayProvider` + `generateText` / `streamText` / `embed` from `ai` where the OpenAI-compatible surface is enough.
+2. **Raw JSON or multipart** — `createGatewayFetch({ baseURL, getAuthToken, ... })` then `gatewayFetch('/api/v1/...', { method, headers, body })` (e.g. `FormData` for image edits or audio).
+
+Types for request/response bodies can come from your app, from OpenAI SDK types, or from gateway OpenAPI — they are not re-exported from this package today.
+
+## If you used `@macpaw/ai-sdk/runtime`
+
+Internals (`executeRequestPipeline`, etc.) are not part of the public API. Prefer `createGatewayFetch` or provider options (`middleware`, `retry`, `timeout`, `fetch`).
+
+## Quick import cheatsheet
+
+```ts
+import { generateText } from 'ai';
+import { createAIGatewayProvider } from '@macpaw/ai-sdk';
+```
+
+Equivalent legacy path:
+
+```ts
+import { createAIGatewayProvider } from '@macpaw/ai-sdk/provider';
+```
+
+## NestJS
+
+`@InjectAIGateway()` provides **`GatewayProviderSettings`**. Build `createAIGatewayProvider(config)` (or `createGatewayFetch`) inside services — there is no injected `AIGatewayClient` type in this package.
+
+## React
+
+Keep `useChat`, `useCompletion`, etc. on **`@ai-sdk/react`** or **`ai/react`**. Configure the server route to use a gateway-backed model from `createAIGatewayProvider`.

package/README.md

@@ -0,0 +1,272 @@
+# @macpaw/ai-sdk
+
+[![CI](https://github.com/macpaw/ai-sdk-typescript/actions/workflows/ci.yml/badge.svg)](https://github.com/macpaw/ai-sdk-typescript/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/%40macpaw%2Fai-sdk)](https://www.npmjs.com/package/@macpaw/ai-sdk)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+
+Thin **Vercel AI SDK** extension for **MacPaw AI Gateway**: OpenAI-compatible providers (`createAIGatewayProvider`, `createGatewayProvider`), a **`createGatewayFetch`** bridge for any HTTP client, shared **auth / retry / middleware / errors**, and optional **NestJS** wiring.
+
+Core generation APIs stay on upstream **`ai`** and **`@ai-sdk/*`**. This package only adds Gateway-specific construction and the fetch pipeline.
+
+## Package entry points
+
+| Import                    | Use for                                                               |
+| ------------------------- | --------------------------------------------------------------------- |
+| `@macpaw/ai-sdk`          | **Canonical** — providers, `createGatewayFetch`, errors, config types |
+| `@macpaw/ai-sdk/provider` | **Alias** of the root entry (same `dist`; for older snippets)         |
+| `@macpaw/ai-sdk/nestjs`   | `AIGatewayModule`, `@InjectAIGateway()`, `AIGatewayExceptionFilter`   |
+
+Upstream **`ai`**, **`@ai-sdk/openai`**, **`@ai-sdk/react`** (or **`ai/react`**) remain the home for Vercel primitives and React hooks.
+
+There is **no** published `@macpaw/ai-sdk/client`, `@macpaw/ai-sdk/runtime`, `@macpaw/ai-sdk/types`, or `@macpaw/ai-sdk/testing` in this version — use `createGatewayFetch` + `fetch` (or the OpenAI SDK with custom `fetch`) for raw HTTP and multipart. See [MIGRATION.md](./MIGRATION.md).
+
+## Install
+
+```bash
+pnpm add @macpaw/ai-sdk
+# or
+npm install @macpaw/ai-sdk
+```
+
+Also install upstream packages you call directly, for example `ai`, `@ai-sdk/openai`, `@ai-sdk/react`.
+
+## Quick start (Vercel AI SDK)
+
+```ts
+import { generateText, streamText } from 'ai';
+import { createAIGatewayProvider, ErrorCode } from '@macpaw/ai-sdk';
+
+const gateway = createAIGatewayProvider({
+  env: 'production',
+  getAuthToken: async () => (await getSetappSession()).accessToken,
+});
+
+const { text } = await generateText({
+  model: gateway('openai/gpt-4.1-nano'),
+  prompt: 'Hello from AI Gateway',
+});
+
+const result = streamText({
+  model: gateway('openai/gpt-4.1-nano'),
+  prompt: 'Write a poem',
+});
+for await (const delta of result.textStream) {
+  process.stdout.write(delta);
+}
+```
+
+## Features
+
+- **Vercel-first** — `OpenAIProvider` from `@ai-sdk/openai` + custom `fetch`
+- **Auth** — `getAuthToken(forceRefresh?)`; one automatic retry on **401** with `forceRefresh === true`
+- **Retry** — exponential backoff for **429** and **5xx** (and some network errors); not for 401/402
+- **Middleware** — `(config, next) => Promise<Response>` chain before `fetch`
+- **Errors** — Gateway JSON and OpenAI-shaped bodies → `AIGatewayError` subclasses + `ErrorCode`
+- **Request ID** — `X-Request-ID` on Gateway requests when missing
+- **Timeout** — per attempt, combined with caller `AbortSignal`
+- **Tree-shakeable** — ESM + CJS
+
+## Configuration (`GatewayProviderSettings`)
+
+Used by `createAIGatewayProvider`, `createGatewayProvider`, `createGatewayFetch`, and Nest `AIGatewayModule`.
+
+| Field          | Purpose                                                          |
+| -------------- | ---------------------------------------------------------------- |
+| `getAuthToken` | Required — `Promise<string \| null>`; `true` = refresh after 401 |
+| `env`          | `'production'` → default base URL `https://api.macpaw.com/ai`    |
+| `baseURL`      | Override gateway root (staging, etc.)                            |
+| `headers`      | Extra headers (do not set `Authorization` here)                  |
+| `retry`        | `RetryConfig` or `false`                                         |
+| `timeout`      | ms per attempt (default `60000`)                                 |
+| `middleware`   | Interceptor stack                                                |
+| `fetch`        | Custom `fetch` implementation                                    |
+
+Internal resolution: `resolveConfig()` in `gateway-config.ts`.
+
+## `createGatewayFetch` — raw HTTP / multipart
+
+Same auth, retry, middleware, and error normalization as the provider path. Use **relative** URLs under the gateway root (e.g. `'/api/v1/images/edits'`) or absolute URLs that stay under the same gateway origin.
+
+```ts
+import { createGatewayFetch } from '@macpaw/ai-sdk';
+
+const baseURL = 'https://api.macpaw.com/ai'; // or resolve via env: 'production'
+const gatewayFetch = createGatewayFetch({
+  baseURL,
+  getAuthToken: async () => token,
+});
+
+const form = new FormData();
+form.append('image', imageBlob, 'photo.png');
+form.append('prompt', 'Add a hat');
+form.append('model', 'openai/dall-e-2');
+
+const res = await gatewayFetch('/api/v1/images/edits', { method: 'POST', body: form });
+```
+
+Non-gateway absolute URLs are passed through without injecting Bearer auth (placeholder key is stripped). See `gateway-fetch.ts`.
+
+## `createGatewayProvider` — prefixed model IDs
+
+Bare model IDs get a default Gateway prefix per provider constant; IDs that already contain `/` are unchanged.
+
+| Constant                              | Default prefix                        |
+| ------------------------------------- | ------------------------------------- |
+| `GATEWAY_PROVIDERS.ANTHROPIC`         | `anthropic`                           |
+| `GATEWAY_PROVIDERS.GOOGLE`            | `google`                              |
+| `GATEWAY_PROVIDERS.XAI`               | `xai`                                 |
+| `GATEWAY_PROVIDERS.GROQ`              | `groq`                                |
+| `GATEWAY_PROVIDERS.MISTRAL`           | `mistral`                             |
+| `GATEWAY_PROVIDERS.AMAZON_BEDROCK`    | `bedrock`                             |
+| `GATEWAY_PROVIDERS.AZURE`             | `azure`                               |
+| `GATEWAY_PROVIDERS.COHERE`            | `cohere`                              |
+| `GATEWAY_PROVIDERS.PERPLEXITY`        | `perplexity`                          |
+| `GATEWAY_PROVIDERS.DEEPSEEK`          | `deepseek`                            |
+| `GATEWAY_PROVIDERS.TOGETHERAI`        | `togetherai`                          |
+| `GATEWAY_PROVIDERS.OPENAI_COMPATIBLE` | **requires** `modelPrefix` in options |
+
+```ts
+import { generateText } from 'ai';
+import { createGatewayProvider, GATEWAY_PROVIDERS } from '@macpaw/ai-sdk';
+
+const anthropic = createGatewayProvider(GATEWAY_PROVIDERS.ANTHROPIC, {
+  env: 'production',
+  getAuthToken: async () => token,
+});
+
+await generateText({
+  model: anthropic('claude-sonnet-4-20250514'),
+  prompt: 'Hello',
+});
+```
+
+## Provider options (`AIGatewayProviderOptions`)
+
+Extends `GatewayProviderSettings` plus OpenAI provider settings (without `apiKey` / `baseURL` / `fetch`, which are wired by the SDK):
+
+- `normalizeErrors` — default `true`; non-OK Gateway responses throw typed errors
+- `createOpenAI` — optional override of `createOpenAI` from `@ai-sdk/openai` (tests/advanced)
+
+## Middleware
+
+```ts
+import type { Middleware } from '@macpaw/ai-sdk';
+
+const loggingMiddleware: Middleware = async (config, next) => {
+  const response = await next(config);
+  console.log(config.method, config.url, response.status);
+  return response;
+};
+```
+
+## Error handling
+
+| `ErrorCode`                                   | Typical HTTP | Meaning                                |
+| --------------------------------------------- | ------------ | -------------------------------------- |
+| `AuthRequired`                                | 401          | Token missing / expired                |
+| `InsufficientCredits` / `SubscriptionExpired` | 402          | Billing / subscription                 |
+| `ModelNotAllowed`                             | 403          | Model denied                           |
+| `RateLimited`                                 | 429          | Rate limit (`retryAfter` when present) |
+| `Validation`                                  | 422          | Validation body                        |
+| …                                             | …            | See `gateway-errors.ts`                |
+
+```ts
+import { AIGatewayError, ErrorCode, isAIGatewayError } from '@macpaw/ai-sdk';
+
+try {
+  // ...
+} catch (e) {
+  if (isAIGatewayError(e) && e.code === ErrorCode.InsufficientCredits) {
+    // e.metadata.paymentUrl, e.requestId, etc.
+  }
+}
+```
+
+## NestJS
+
+```bash
+pnpm add @macpaw/ai-sdk @nestjs/common rxjs
+```
+
+Register once (global by default):
+
+```ts
+import { AIGatewayModule } from '@macpaw/ai-sdk/nestjs';
+
+AIGatewayModule.forRoot({
+  env: 'production',
+  getAuthToken: async () => process.env.SETAPP_TOKEN!,
+});
+```
+
+Inject **`GatewayProviderSettings`** (not an HTTP client) and build providers in the service:
+
+```ts
+import { Injectable } from '@nestjs/common';
+import { InjectAIGateway } from '@macpaw/ai-sdk/nestjs';
+import type { GatewayProviderSettings } from '@macpaw/ai-sdk';
+import { createAIGatewayProvider } from '@macpaw/ai-sdk';
+import { generateText } from 'ai';
+
+@Injectable()
+export class ChatService {
+  constructor(@InjectAIGateway() private readonly config: GatewayProviderSettings) {}
+
+  async complete(prompt: string) {
+    const gateway = createAIGatewayProvider(this.config);
+    const { text } = await generateText({
+      model: gateway('openai/gpt-4.1-nano'),
+      prompt,
+    });
+    return text;
+  }
+}
+```
+
+`AIGatewayExceptionFilter` maps `AIGatewayError` to JSON HTTP responses. See `examples/nestjs/` for a copy-paste skeleton.
+
+## Examples
+
+From the repo root:
+
+```bash
+pnpm build
+pnpm example:provider
+```
+
+Set `AI_GATEWAY_TOKEN` or `SETAPP_TOKEN`. Optional: `AI_GATEWAY_BASE_URL`, `AI_GATEWAY_MODEL`.
+
+See [`examples/README.md`](./examples/README.md).
+
+## Release & quality
+
+- CI: `typecheck`, `lint`, `test`, coverage, `build` on Node 18 / 20 / 22
+- `pnpm verify:release` — full local gate before publish
+- `pnpm size:pack` — dry-run npm pack
+
+## AI assistant setup
+
+Templates for **Cursor** (`.cursor/skills/`), **Claude Code** (`CLAUDE.md`), and **OpenAI Codex** (`AGENTS.md`) ship under `templates/`. After installing the package:
+
+```bash
+pnpm exec macpaw-ai-setup
+# or: npx macpaw-ai-setup
+```
+
+Use `macpaw-ai-setup cursor`, `claude`, or `codex` to install only one target. Existing root `CLAUDE.md` / `AGENTS.md` files get Gateway sections appended, not replaced.
+
+The installed instructions enforce the current package surface and the main auth guardrails:
+
+- prefer `@macpaw/ai-sdk` / `@macpaw/ai-sdk/nestjs`
+- keep generation primitives on upstream `ai` / `@ai-sdk/*`
+- do not use removed subpaths such as `client`, `runtime`, `types`, or `testing`
+- do not invent a token source or expose gateway tokens to browser-only code
+- use `baseURL` for staging/custom hosts; `env` supports only `'production'`
+
+## Versioning
+
+[Semantic Versioning](https://semver.org/). Releases via [semantic-release](https://github.com/semantic-release/semantic-release) and Conventional Commits.
+
+## License
+
+MIT © 2026 [MacPaw Way Ltd](https://macpaw.com). See [LICENSE](LICENSE).

package/dist/chunk-KGOVQRMH.js

@@ -0,0 +1,287 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/gateway-errors.ts
+var GatewayApiCode = {
+  BadRequest: "BAD_REQUEST",
+  Unauthorized: "UNAUTHORIZED",
+  InsufficientCredits: "INSUFFICIENT_CREDITS",
+  Forbidden: "FORBIDDEN",
+  Validation: "VALIDATION",
+  RateLimitExceeded: "RATE_LIMIT_EXCEEDED",
+  InternalServerError: "INTERNAL_SERVER_ERROR",
+  ServiceUnavailable: "SERVICE_UNAVAILABLE",
+  Timeout: "TIMEOUT",
+  NotFound: "NOT_FOUND",
+  Conflict: "CONFLICT"
+};
+var ErrorCode = {
+  AuthRequired: "AUTH_REQUIRED",
+  InsufficientCredits: "INSUFFICIENT_CREDITS",
+  SubscriptionExpired: "SUBSCRIPTION_EXPIRED",
+  ModelNotAllowed: "MODEL_NOT_ALLOWED",
+  RateLimited: "RATE_LIMITED",
+  BadRequest: "BAD_REQUEST",
+  Validation: "VALIDATION",
+  Forbidden: "FORBIDDEN",
+  InternalServerError: "INTERNAL_SERVER_ERROR",
+  ServiceUnavailable: "SERVICE_UNAVAILABLE",
+  Timeout: "TIMEOUT",
+  NotFound: "NOT_FOUND",
+  Conflict: "CONFLICT"
+};
+var AIGatewayError = class extends Error {
+  constructor(message, code, statusCode, metadata = {}, options) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "statusCode");
+    __publicField(this, "metadata");
+    this.name = "AIGatewayError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.metadata = metadata;
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  get paymentUrl() {
+    return this.metadata.paymentUrl;
+  }
+  /** Suggested delay before retrying, in seconds. `undefined` if not provided by the server. */
+  get retryAfter() {
+    return this.metadata.retryAfter;
+  }
+  get requestId() {
+    return this.metadata.requestId;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      statusCode: this.statusCode,
+      metadata: this.metadata
+    };
+  }
+};
+var AuthError = class extends AIGatewayError {
+  constructor(message, statusCode, metadata, options) {
+    super(message, ErrorCode.AuthRequired, statusCode, metadata, options);
+    this.name = "AuthError";
+  }
+};
+var CreditsError = class extends AIGatewayError {
+  constructor(message, statusCode, code, metadata, options) {
+    super(message, code, statusCode, metadata, options);
+    this.name = "CreditsError";
+  }
+};
+var RateLimitError = class extends AIGatewayError {
+  constructor(message, statusCode, metadata, options) {
+    super(message, ErrorCode.RateLimited, statusCode, metadata, options);
+    this.name = "RateLimitError";
+  }
+};
+var ModelNotAllowedError = class extends AIGatewayError {
+  constructor(message, statusCode, metadata, options) {
+    super(message, ErrorCode.ModelNotAllowed, statusCode, metadata, options);
+    this.name = "ModelNotAllowedError";
+  }
+};
+var GatewayValidationError = class extends AIGatewayError {
+  constructor(message, statusCode, metadata, options) {
+    super(message, ErrorCode.Validation, statusCode, metadata, options);
+    this.name = "GatewayValidationError";
+  }
+};
+function isAIGatewayError(value) {
+  return value instanceof AIGatewayError;
+}
+function mapGatewayApiCodeToNormalized(code, statusCode) {
+  switch (code) {
+    case GatewayApiCode.Unauthorized:
+      return ErrorCode.AuthRequired;
+    case GatewayApiCode.InsufficientCredits:
+      return statusCode === 402 ? ErrorCode.InsufficientCredits : ErrorCode.SubscriptionExpired;
+    case GatewayApiCode.Forbidden:
+      return ErrorCode.ModelNotAllowed;
+    case GatewayApiCode.RateLimitExceeded:
+      return ErrorCode.RateLimited;
+    case GatewayApiCode.BadRequest:
+      return ErrorCode.BadRequest;
+    case GatewayApiCode.Validation:
+      return ErrorCode.Validation;
+    case GatewayApiCode.InternalServerError:
+      return ErrorCode.InternalServerError;
+    case GatewayApiCode.ServiceUnavailable:
+      return ErrorCode.ServiceUnavailable;
+    case GatewayApiCode.Timeout:
+      return ErrorCode.Timeout;
+    case GatewayApiCode.NotFound:
+      return ErrorCode.NotFound;
+    case GatewayApiCode.Conflict:
+      return ErrorCode.Conflict;
+    default:
+      return statusCode >= 500 ? ErrorCode.InternalServerError : ErrorCode.BadRequest;
+  }
+}
+function mapOpenAIErrorToNormalized(type, statusCode) {
+  if (type === "authentication_error") return ErrorCode.AuthRequired;
+  if (type === "rate_limit_error") return ErrorCode.RateLimited;
+  if (type === "team_model_access_denied") return ErrorCode.ModelNotAllowed;
+  if (type === "api_error") return ErrorCode.InternalServerError;
+  if (type === "invalid_request_error") return ErrorCode.BadRequest;
+  if (statusCode === 401) return ErrorCode.AuthRequired;
+  if (statusCode === 429) return ErrorCode.RateLimited;
+  if (statusCode === 403) return ErrorCode.ModelNotAllowed;
+  return statusCode !== void 0 && statusCode >= 400 && statusCode < 500 ? ErrorCode.BadRequest : ErrorCode.InternalServerError;
+}
+function parseRetryAfterHeader(value) {
+  const seconds = Number(value);
+  if (!Number.isNaN(seconds) && seconds >= 0) return seconds;
+  const date = Date.parse(value);
+  if (!Number.isNaN(date)) {
+    const delta = Math.ceil((date - Date.now()) / 1e3);
+    return delta > 0 ? delta : 0;
+  }
+  return void 0;
+}
+function createTypedError(message, code, statusCode, meta, options) {
+  switch (code) {
+    case ErrorCode.AuthRequired:
+      return new AuthError(message, statusCode, meta, options);
+    case ErrorCode.InsufficientCredits:
+    case ErrorCode.SubscriptionExpired:
+      return new CreditsError(message, statusCode, code, meta, options);
+    case ErrorCode.RateLimited:
+      return new RateLimitError(message, statusCode, meta, options);
+    case ErrorCode.ModelNotAllowed:
+      return new ModelNotAllowedError(message, statusCode, meta, options);
+    case ErrorCode.Validation:
+      return new GatewayValidationError(message, statusCode, meta, options);
+    default:
+      return new AIGatewayError(message, code, statusCode, meta, options);
+  }
+}
+async function parseErrorResponseFromResponse(response) {
+  const contentType = response.headers.get("Content-Type") ?? "";
+  let body;
+  if (contentType.includes("application/json")) {
+    try {
+      body = await response.json();
+    } catch {
+      body = { message: response.statusText };
+    }
+  } else {
+    body = { message: await response.text().catch(() => response.statusText) };
+  }
+  const retryAfterHeader = response.headers.get("Retry-After");
+  let headerRetryAfter;
+  if (retryAfterHeader) {
+    headerRetryAfter = parseRetryAfterHeader(retryAfterHeader);
+  }
+  try {
+    parseErrorResponse(response.status, body);
+  } catch (error) {
+    if (error instanceof AIGatewayError && error.retryAfter == null && headerRetryAfter != null) {
+      throw createTypedError(
+        error.message,
+        error.code,
+        error.statusCode,
+        { ...error.metadata, retryAfter: headerRetryAfter },
+        error.cause != null ? { cause: error.cause } : void 0
+      );
+    }
+    throw error;
+  }
+}
+function parseErrorResponse(statusCode, body) {
+  const meta = {};
+  if (body && typeof body === "object") {
+    if ("request_id" in body && typeof body.request_id === "string") {
+      meta.requestId = body.request_id;
+    }
+    if ("path" in body && typeof body.path === "string") {
+      meta.path = body.path;
+    }
+    if ("timestamp" in body && typeof body.timestamp === "string") {
+      meta.timestamp = body.timestamp;
+    }
+  }
+  const gatewayBody = body;
+  if (gatewayBody?.statusCode != null && typeof gatewayBody.message === "string" && gatewayBody.code) {
+    const code = mapGatewayApiCodeToNormalized(gatewayBody.code, gatewayBody.statusCode);
+    if (gatewayBody.errors?.length) meta.errors = gatewayBody.errors;
+    const firstError = gatewayBody.errors?.[0];
+    if (firstError?.metadata) {
+      if (typeof firstError.metadata.paymentUrl === "string") meta.paymentUrl = firstError.metadata.paymentUrl;
+      if (typeof firstError.metadata.retryAfter === "number") meta.retryAfter = firstError.metadata.retryAfter;
+    }
+    throw createTypedError(gatewayBody.message, code, gatewayBody.statusCode, meta);
+  }
+  const oai = body;
+  if (oai?.error?.message) {
+    const code = mapOpenAIErrorToNormalized(oai.error.type, statusCode);
+    if (oai.request_id) meta.requestId = oai.request_id;
+    throw createTypedError(oai.error.message, code, statusCode, meta);
+  }
+  const message = typeof body?.message === "string" ? body.message : `Request failed with status ${statusCode}`;
+  let fallbackCode;
+  if (statusCode === 401) fallbackCode = ErrorCode.AuthRequired;
+  else if (statusCode === 403) fallbackCode = ErrorCode.Forbidden;
+  else if (statusCode === 429) fallbackCode = ErrorCode.RateLimited;
+  else if (statusCode >= 500) fallbackCode = ErrorCode.InternalServerError;
+  else fallbackCode = ErrorCode.BadRequest;
+  throw createTypedError(message, fallbackCode, statusCode, meta);
+}
+
+export { AIGatewayError, AuthError, CreditsError, ErrorCode, GatewayApiCode, GatewayValidationError, ModelNotAllowedError, RateLimitError, __decorateElement, __decoratorStart, __runInitializers, isAIGatewayError, parseErrorResponse, parseErrorResponseFromResponse };
+//# sourceMappingURL=chunk-KGOVQRMH.js.map
+//# sourceMappingURL=chunk-KGOVQRMH.js.map