@coder/ai-sdk-provider 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   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

@@ -0,0 +1,123 @@
+# @coder/ai-sdk-provider
+
+[![CI](https://github.com/coder/ai-sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/coder/ai-sdk/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@coder/ai-sdk-provider.svg)](https://www.npmjs.com/package/@coder/ai-sdk-provider)
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](./LICENSE)
+
+A **Vercel AI SDK provider that routes requests through your Coder deployment's
+[AI Gateway](https://coder.com/docs/ai-coder/ai-gateway)** (formerly "AI Bridge" — the URL path is still `aibridge`). Point it
+at your deployment URL, hand it a Coder API token, and use any model your
+deployment proxies with the AI SDK's `generateText` / `streamText` — the same way
+you'd use [OpenRouter](https://ai-sdk.dev/providers/community-providers/openrouter)
+or any other provider.
+
+```ts
+import { generateText } from "ai";
+import { createCoder } from "@coder/ai-sdk-provider";
+
+const coder = createCoder({
+  baseURL: "https://coder.example.com",
+  apiKey: process.env.CODER_API_TOKEN!,
+});
+
+const { text } = await generateText({
+  model: coder("claude-sonnet-4-6"),
+  prompt: "What is Coder?",
+});
+```
+
+## Why
+
+**AI Gateway** is Coder's LLM gateway: it sits between your AI tooling and the
+upstream providers (Anthropic, OpenAI, Bedrock, Copilot, …), authenticates each
+request against a Coder identity, injects the centrally-managed provider keys, and
+audits usage per user. This package lets the Vercel AI SDK speak to it natively, so
+your developers never handle raw provider keys — they authenticate with their Coder
+token and the deployment decides which models and providers are available.
+
+## Install
+
+```bash
+pnpm add @coder/ai-sdk-provider ai zod
+```
+
+Requires Node ≥ 20, `ai` v6, and a Coder deployment with **AI Gateway enabled**
+(stable since Coder **v2.29**, GA in v2.30, on by default in v2.34; requires the
+AI Governance Add-On).
+
+## The two surfaces
+
+AI Gateway exposes **two provider-namespaced surfaces** on your deployment, and
+routing is **by URL path, not by model id** — so each surface reaches a fixed set
+of upstreams:
+
+| Surface                                                 | Reaches                                                                                               | Accessor                                     |
+| ------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | -------------------------------------------- |
+| **OpenAI-compatible** (`/api/v2/aibridge/openai/v1`)    | OpenAI, Azure, Google, OpenRouter, Vercel, openai-compat — and **Copilot** (incl. Claude via Copilot) | `coder.openai(id)` / `coder.chat(id)`        |
+| **Anthropic-compatible** (`/api/v2/aibridge/anthropic`) | **native Claude** + **Bedrock-hosted Claude**                                                         | `coder.anthropic(id)` / `coder.messages(id)` |
+
+The bare call `coder(modelId)` picks a surface by heuristic — model ids starting
+with `claude`/`anthropic` go to the Anthropic surface, everything else to the
+OpenAI surface. Use the explicit accessors to override (e.g. to reach Claude
+through a Copilot-typed provider on the OpenAI surface):
+
+```ts
+coder("gpt-4o"); // → OpenAI surface
+coder("claude-sonnet-4-6"); // → Anthropic surface (heuristic)
+coder.openai("claude-sonnet-4"); // → OpenAI surface (e.g. Copilot)
+coder.anthropic("claude-opus-4-5"); // → Anthropic surface (explicit)
+coder.textEmbeddingModel("text-embedding-3-small"); // → OpenAI surface
+```
+
+Model ids are passed through **unchanged** to the upstream provider (no
+`vendor/model` namespacing) — use whatever ids your deployment's providers accept.
+
+## Authentication
+
+**Centralized mode (default).** Pass your Coder API token as `apiKey`. AI Gateway
+holds the upstream provider keys and brokers the call — this is all you need:
+
+```ts
+createCoder({ baseURL: "https://coder.example.com", apiKey: coderToken });
+```
+
+**Bring-your-own-key (BYOK) mode.** Set `coderToken` (sent in the
+`X-Coder-AI-Governance-Token` header to authenticate you to the gateway) and pass
+your _upstream_ provider key as `apiKey` (forwarded to the upstream):
+
+```ts
+createCoder({
+  baseURL: "https://coder.example.com",
+  coderToken, // authenticates you to AI Gateway
+  apiKey: upstreamKey, // your own OpenAI/Anthropic key
+});
+```
+
+## Configuration
+
+| Option          | Type                      | Default                | Description                                                                                           |
+| --------------- | ------------------------- | ---------------------- | ----------------------------------------------------------------------------------------------------- |
+| `baseURL`       | `string`                  | — (required)           | Your Coder deployment URL, e.g. `https://coder.example.com`. The AI Gateway path is appended for you. |
+| `apiKey`        | `string`                  | —                      | Coder API token (centralized) or upstream key (BYOK).                                                 |
+| `coderToken`    | `string`                  | —                      | Enables BYOK mode; sent in `X-Coder-AI-Governance-Token`.                                             |
+| `headers`       | `Record<string,string>`   | —                      | Extra headers merged into every request.                                                              |
+| `aiGatewayPath` | `string`                  | `/api/v2/aibridge`     | Override if your deployment uses a different mount path.                                              |
+| `providers`     | `{ openai?, anthropic? }` | `openai` / `anthropic` | Override the admin-configured provider path segments.                                                 |
+| `fetch`         | `typeof fetch`            | global `fetch`         | Custom fetch (testing / middleware).                                                                  |
+
+## Examples
+
+Runnable scripts live in [`examples/`](./examples) (run against a real deployment via `tsx`):
+
+```bash
+export CODER_URL=https://coder.example.com
+export CODER_API_TOKEN=$(coder tokens create --name ai-sdk-provider-example)
+
+pnpm example:generate    # non-streaming generateText
+pnpm example:stream      # streaming streamText
+pnpm example:anthropic   # the Anthropic surface (native Claude)
+```
+
+## License
+
+[Apache-2.0](./LICENSE) © Coder Technologies, Inc.

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+import { AnthropicProvider } from '@ai-sdk/anthropic';
+import { OpenAICompatibleProvider } from '@ai-sdk/openai-compatible';
+import { LanguageModelV3, EmbeddingModelV3 } from '@ai-sdk/provider';
+
+interface CoderProviderSettings {
+    /**
+     * Base URL of your Coder deployment, e.g. `https://coder.example.com`. Do NOT
+     * include the AI Gateway path (`/api/v2/aibridge/...`) — it is appended for you.
+     */
+    baseURL: string;
+    /**
+     * The credential sent to AI Gateway.
+     *
+     * - **Centralized mode (default):** your **Coder API token**. AI Gateway holds
+     *   the upstream provider keys and brokers the call, so this is all you need.
+     * - **BYOK mode** (when {@link CoderProviderSettings.coderToken} is also set):
+     *   your **upstream provider key**, which AI Gateway forwards to the upstream.
+     */
+    apiKey?: string;
+    /**
+     * Enables bring-your-own-key (BYOK) mode. This Coder API token is sent in the
+     * `X-Coder-AI-Governance-Token` header to authenticate you to the gateway,
+     * while {@link CoderProviderSettings.apiKey} carries your upstream provider key.
+     * Leave unset for the default centralized mode.
+     */
+    coderToken?: string;
+    /** Extra headers merged into every request to both surfaces. */
+    headers?: Record<string, string>;
+    /**
+     * Mount path of AI Gateway on the deployment. Defaults to `/api/v2/aibridge`.
+     * Exposed because the `aibridge` path segment may change in a future Coder
+     * release (the feature was renamed "AI Gateway").
+     */
+    aiGatewayPath?: string;
+    /**
+     * Override the provider path segments — the *admin-configured provider names*
+     * on the deployment (e.g. `anthropic-corp`). Default to `openai` / `anthropic`.
+     */
+    providers?: {
+        openai?: string;
+        anthropic?: string;
+    };
+    /** Custom fetch implementation (useful for testing or middleware). */
+    fetch?: typeof globalThis.fetch;
+}
+interface CoderProvider {
+    /** Route a model id to a surface by heuristic (Claude ids → Anthropic surface). */
+    (modelId: string): LanguageModelV3;
+    /** Route a model id to a surface by heuristic (Claude ids → Anthropic surface). */
+    languageModel(modelId: string): LanguageModelV3;
+    /**
+     * AI Gateway's OpenAI-compatible surface (`/aibridge/openai/v1`). Reaches the
+     * OpenAI / Azure / Google / OpenRouter / Vercel / openai-compat and Copilot
+     * upstreams. Routing is by URL, so any model id sent here hits this surface.
+     */
+    openai: OpenAICompatibleProvider;
+    /**
+     * AI Gateway's Anthropic-compatible surface (`/aibridge/anthropic`). Reaches
+     * native Claude and Bedrock-hosted Claude.
+     */
+    anthropic: AnthropicProvider;
+    /** Shorthand for an {@link CoderProvider.openai} chat model. */
+    chat(modelId: string): LanguageModelV3;
+    /** Shorthand for an {@link CoderProvider.anthropic} messages model. */
+    messages(modelId: string): LanguageModelV3;
+    /** Text-embedding model via the OpenAI-compatible surface. */
+    textEmbeddingModel(modelId: string): EmbeddingModelV3;
+}
+/**
+ * Heuristic for the bare {@link CoderProvider} call: which AI Gateway surface
+ * should a model id route to? Claude / Anthropic ids go to the Anthropic
+ * surface; everything else to the OpenAI-compatible surface. Use the explicit
+ * `.openai(id)` / `.anthropic(id)` accessors to override (e.g. to reach Claude
+ * through a Copilot-typed provider on the OpenAI surface).
+ */
+declare function isAnthropicModelId(modelId: string): boolean;
+/**
+ * Create a {@link CoderProvider} that routes Vercel AI SDK calls through a Coder
+ * deployment's AI Gateway (formerly "AI Bridge"). AI Gateway exposes two
+ * provider-namespaced surfaces; this provider fronts both and selects between
+ * them per model.
+ *
+ * @example
+ * ```ts
+ * import { generateText } from "ai";
+ * import { createCoder } from "@coder/ai-sdk-provider";
+ *
+ * const coder = createCoder({
+ *   baseURL: "https://coder.example.com",
+ *   apiKey: process.env.CODER_API_TOKEN!,
+ * });
+ *
+ * await generateText({ model: coder("gpt-4o"), prompt: "Hi" });                 // OpenAI surface
+ * await generateText({ model: coder("claude-sonnet-4-6"), prompt: "Hi" }); // Anthropic surface
+ * ```
+ */
+declare function createCoder(settings: CoderProviderSettings): CoderProvider;
+/** Convenience alias mirroring other AI SDK providers' `createX` naming. */
+declare const coder: typeof createCoder;
+
+export { type CoderProvider, type CoderProviderSettings, coder, createCoder, isAnthropicModelId };

package/dist/index.js

@@ -0,0 +1,65 @@
+// src/provider.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+var DEFAULT_AI_GATEWAY_PATH = "/api/v2/aibridge";
+var DEFAULT_OPENAI_PROVIDER = "openai";
+var DEFAULT_ANTHROPIC_PROVIDER = "anthropic";
+var CODER_TOKEN_HEADER = "X-Coder-AI-Governance-Token";
+function isAnthropicModelId(modelId) {
+  return /^(?:claude|anthropic[./:])/i.test(modelId);
+}
+function trimTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function createCoder(settings) {
+  if (!settings.baseURL) {
+    throw new Error(
+      "createCoder: `baseURL` is required (your Coder deployment URL, e.g. https://coder.example.com)."
+    );
+  }
+  const deployment = trimTrailingSlash(settings.baseURL);
+  const gatewayPath = settings.aiGatewayPath ?? DEFAULT_AI_GATEWAY_PATH;
+  const openaiName = settings.providers?.openai ?? DEFAULT_OPENAI_PROVIDER;
+  const anthropicName = settings.providers?.anthropic ?? DEFAULT_ANTHROPIC_PROVIDER;
+  const openaiBaseURL = `${deployment}${gatewayPath}/${openaiName}/v1`;
+  const anthropicBaseURL = `${deployment}${gatewayPath}/${anthropicName}/v1`;
+  const byok = settings.coderToken !== void 0;
+  const headers = {
+    ...byok ? { [CODER_TOKEN_HEADER]: settings.coderToken } : {},
+    ...settings.headers
+  };
+  const openai = createOpenAICompatible({
+    name: "coder.openai",
+    baseURL: openaiBaseURL,
+    apiKey: settings.apiKey,
+    // → `Authorization: Bearer <apiKey>`
+    headers,
+    fetch: settings.fetch,
+    includeUsage: true
+  });
+  const anthropic = createAnthropic({
+    name: "coder.anthropic",
+    baseURL: anthropicBaseURL,
+    // Centralized: send the Coder token via `Authorization: Bearer` (the
+    // documented path). BYOK: send the upstream key via `x-api-key`.
+    ...byok ? { apiKey: settings.apiKey } : { authToken: settings.apiKey },
+    headers,
+    fetch: settings.fetch
+  });
+  const languageModel = (modelId) => isAnthropicModelId(modelId) ? anthropic(modelId) : openai(modelId);
+  return Object.assign(languageModel, {
+    languageModel,
+    openai,
+    anthropic,
+    chat: (modelId) => openai(modelId),
+    messages: (modelId) => anthropic(modelId),
+    textEmbeddingModel: (modelId) => openai.textEmbeddingModel(modelId)
+  });
+}
+var coder = createCoder;
+export {
+  coder,
+  createCoder,
+  isAnthropicModelId
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/provider.ts"],"sourcesContent":["import { type AnthropicProvider, createAnthropic } from \"@ai-sdk/anthropic\";\nimport { createOpenAICompatible, type OpenAICompatibleProvider } from \"@ai-sdk/openai-compatible\";\nimport type { EmbeddingModelV3, LanguageModelV3 } from \"@ai-sdk/provider\";\n\n/** Default mount path of AI Gateway on a Coder deployment. */\nconst DEFAULT_AI_GATEWAY_PATH = \"/api/v2/aibridge\";\n/** Default provider path segments (the admin-configured provider names). */\nconst DEFAULT_OPENAI_PROVIDER = \"openai\";\nconst DEFAULT_ANTHROPIC_PROVIDER = \"anthropic\";\n/** Header that carries the Coder token to AI Gateway in bring-your-own-key mode. */\nconst CODER_TOKEN_HEADER = \"X-Coder-AI-Governance-Token\";\n\nexport interface CoderProviderSettings {\n  /**\n   * Base URL of your Coder deployment, e.g. `https://coder.example.com`. Do NOT\n   * include the AI Gateway path (`/api/v2/aibridge/...`) — it is appended for you.\n   */\n  baseURL: string;\n  /**\n   * The credential sent to AI Gateway.\n   *\n   * - **Centralized mode (default):** your **Coder API token**. AI Gateway holds\n   *   the upstream provider keys and brokers the call, so this is all you need.\n   * - **BYOK mode** (when {@link CoderProviderSettings.coderToken} is also set):\n   *   your **upstream provider key**, which AI Gateway forwards to the upstream.\n   */\n  apiKey?: string;\n  /**\n   * Enables bring-your-own-key (BYOK) mode. This Coder API token is sent in the\n   * `X-Coder-AI-Governance-Token` header to authenticate you to the gateway,\n   * while {@link CoderProviderSettings.apiKey} carries your upstream provider key.\n   * Leave unset for the default centralized mode.\n   */\n  coderToken?: string;\n  /** Extra headers merged into every request to both surfaces. */\n  headers?: Record<string, string>;\n  /**\n   * Mount path of AI Gateway on the deployment. Defaults to `/api/v2/aibridge`.\n   * Exposed because the `aibridge` path segment may change in a future Coder\n   * release (the feature was renamed \"AI Gateway\").\n   */\n  aiGatewayPath?: string;\n  /**\n   * Override the provider path segments — the *admin-configured provider names*\n   * on the deployment (e.g. `anthropic-corp`). Default to `openai` / `anthropic`.\n   */\n  providers?: {\n    openai?: string;\n    anthropic?: string;\n  };\n  /** Custom fetch implementation (useful for testing or middleware). */\n  fetch?: typeof globalThis.fetch;\n}\n\nexport interface CoderProvider {\n  /** Route a model id to a surface by heuristic (Claude ids → Anthropic surface). */\n  (modelId: string): LanguageModelV3;\n  /** Route a model id to a surface by heuristic (Claude ids → Anthropic surface). */\n  languageModel(modelId: string): LanguageModelV3;\n  /**\n   * AI Gateway's OpenAI-compatible surface (`/aibridge/openai/v1`). Reaches the\n   * OpenAI / Azure / Google / OpenRouter / Vercel / openai-compat and Copilot\n   * upstreams. Routing is by URL, so any model id sent here hits this surface.\n   */\n  openai: OpenAICompatibleProvider;\n  /**\n   * AI Gateway's Anthropic-compatible surface (`/aibridge/anthropic`). Reaches\n   * native Claude and Bedrock-hosted Claude.\n   */\n  anthropic: AnthropicProvider;\n  /** Shorthand for an {@link CoderProvider.openai} chat model. */\n  chat(modelId: string): LanguageModelV3;\n  /** Shorthand for an {@link CoderProvider.anthropic} messages model. */\n  messages(modelId: string): LanguageModelV3;\n  /** Text-embedding model via the OpenAI-compatible surface. */\n  textEmbeddingModel(modelId: string): EmbeddingModelV3;\n}\n\n/**\n * Heuristic for the bare {@link CoderProvider} call: which AI Gateway surface\n * should a model id route to? Claude / Anthropic ids go to the Anthropic\n * surface; everything else to the OpenAI-compatible surface. Use the explicit\n * `.openai(id)` / `.anthropic(id)` accessors to override (e.g. to reach Claude\n * through a Copilot-typed provider on the OpenAI surface).\n */\nexport function isAnthropicModelId(modelId: string): boolean {\n  return /^(?:claude|anthropic[./:])/i.test(modelId);\n}\n\nfunction trimTrailingSlash(url: string): string {\n  return url.replace(/\\/+$/, \"\");\n}\n\n/**\n * Create a {@link CoderProvider} that routes Vercel AI SDK calls through a Coder\n * deployment's AI Gateway (formerly \"AI Bridge\"). AI Gateway exposes two\n * provider-namespaced surfaces; this provider fronts both and selects between\n * them per model.\n *\n * @example\n * ```ts\n * import { generateText } from \"ai\";\n * import { createCoder } from \"@coder/ai-sdk-provider\";\n *\n * const coder = createCoder({\n *   baseURL: \"https://coder.example.com\",\n *   apiKey: process.env.CODER_API_TOKEN!,\n * });\n *\n * await generateText({ model: coder(\"gpt-4o\"), prompt: \"Hi\" });                 // OpenAI surface\n * await generateText({ model: coder(\"claude-sonnet-4-6\"), prompt: \"Hi\" }); // Anthropic surface\n * ```\n */\nexport function createCoder(settings: CoderProviderSettings): CoderProvider {\n  if (!settings.baseURL) {\n    throw new Error(\n      \"createCoder: `baseURL` is required (your Coder deployment URL, e.g. https://coder.example.com).\",\n    );\n  }\n\n  const deployment = trimTrailingSlash(settings.baseURL);\n  const gatewayPath = settings.aiGatewayPath ?? DEFAULT_AI_GATEWAY_PATH;\n  const openaiName = settings.providers?.openai ?? DEFAULT_OPENAI_PROVIDER;\n  const anthropicName = settings.providers?.anthropic ?? DEFAULT_ANTHROPIC_PROVIDER;\n\n  // Both sub-providers append their route to a baseURL that INCLUDES `/v1`:\n  // openai-compatible POSTs `${baseURL}/chat/completions`, and @ai-sdk/anthropic\n  // POSTs `${baseURL}/messages`. AI Gateway's intercepted routes are\n  // `/aibridge/<name>/v1/chat/completions` and `/aibridge/<name>/v1/messages`.\n  const openaiBaseURL = `${deployment}${gatewayPath}/${openaiName}/v1`;\n  const anthropicBaseURL = `${deployment}${gatewayPath}/${anthropicName}/v1`;\n\n  // BYOK mode: the Coder token authenticates via a dedicated header and `apiKey`\n  // carries the upstream key. Centralized mode (default): `apiKey` is the Coder\n  // token itself, sent in the standard provider auth header.\n  const byok = settings.coderToken !== undefined;\n  const headers: Record<string, string> = {\n    ...(byok ? { [CODER_TOKEN_HEADER]: settings.coderToken as string } : {}),\n    ...settings.headers,\n  };\n\n  const openai = createOpenAICompatible({\n    name: \"coder.openai\",\n    baseURL: openaiBaseURL,\n    apiKey: settings.apiKey, // → `Authorization: Bearer <apiKey>`\n    headers,\n    fetch: settings.fetch,\n    includeUsage: true,\n  });\n\n  const anthropic = createAnthropic({\n    name: \"coder.anthropic\",\n    baseURL: anthropicBaseURL,\n    // Centralized: send the Coder token via `Authorization: Bearer` (the\n    // documented path). BYOK: send the upstream key via `x-api-key`.\n    ...(byok ? { apiKey: settings.apiKey } : { authToken: settings.apiKey }),\n    headers,\n    fetch: settings.fetch,\n  });\n\n  const languageModel = (modelId: string): LanguageModelV3 =>\n    isAnthropicModelId(modelId) ? anthropic(modelId) : openai(modelId);\n\n  return Object.assign(languageModel, {\n    languageModel,\n    openai,\n    anthropic,\n    chat: (modelId: string): LanguageModelV3 => openai(modelId),\n    messages: (modelId: string): LanguageModelV3 => anthropic(modelId),\n    textEmbeddingModel: (modelId: string): EmbeddingModelV3 => openai.textEmbeddingModel(modelId),\n  });\n}\n\n/** Convenience alias mirroring other AI SDK providers' `createX` naming. */\nexport const coder = createCoder;\n"],"mappings":";AAAA,SAAiC,uBAAuB;AACxD,SAAS,8BAA6D;AAItE,IAAM,0BAA0B;AAEhC,IAAM,0BAA0B;AAChC,IAAM,6BAA6B;AAEnC,IAAM,qBAAqB;AA2EpB,SAAS,mBAAmB,SAA0B;AAC3D,SAAO,8BAA8B,KAAK,OAAO;AACnD;AAEA,SAAS,kBAAkB,KAAqB;AAC9C,SAAO,IAAI,QAAQ,QAAQ,EAAE;AAC/B;AAsBO,SAAS,YAAY,UAAgD;AAC1E,MAAI,CAAC,SAAS,SAAS;AACrB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,QAAM,aAAa,kBAAkB,SAAS,OAAO;AACrD,QAAM,cAAc,SAAS,iBAAiB;AAC9C,QAAM,aAAa,SAAS,WAAW,UAAU;AACjD,QAAM,gBAAgB,SAAS,WAAW,aAAa;AAMvD,QAAM,gBAAgB,GAAG,UAAU,GAAG,WAAW,IAAI,UAAU;AAC/D,QAAM,mBAAmB,GAAG,UAAU,GAAG,WAAW,IAAI,aAAa;AAKrE,QAAM,OAAO,SAAS,eAAe;AACrC,QAAM,UAAkC;AAAA,IACtC,GAAI,OAAO,EAAE,CAAC,kBAAkB,GAAG,SAAS,WAAqB,IAAI,CAAC;AAAA,IACtE,GAAG,SAAS;AAAA,EACd;AAEA,QAAM,SAAS,uBAAuB;AAAA,IACpC,MAAM;AAAA,IACN,SAAS;AAAA,IACT,QAAQ,SAAS;AAAA;AAAA,IACjB;AAAA,IACA,OAAO,SAAS;AAAA,IAChB,cAAc;AAAA,EAChB,CAAC;AAED,QAAM,YAAY,gBAAgB;AAAA,IAChC,MAAM;AAAA,IACN,SAAS;AAAA;AAAA;AAAA,IAGT,GAAI,OAAO,EAAE,QAAQ,SAAS,OAAO,IAAI,EAAE,WAAW,SAAS,OAAO;AAAA,IACtE;AAAA,IACA,OAAO,SAAS;AAAA,EAClB,CAAC;AAED,QAAM,gBAAgB,CAAC,YACrB,mBAAmB,OAAO,IAAI,UAAU,OAAO,IAAI,OAAO,OAAO;AAEnE,SAAO,OAAO,OAAO,eAAe;AAAA,IAClC;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM,CAAC,YAAqC,OAAO,OAAO;AAAA,IAC1D,UAAU,CAAC,YAAqC,UAAU,OAAO;AAAA,IACjE,oBAAoB,CAAC,YAAsC,OAAO,mBAAmB,OAAO;AAAA,EAC9F,CAAC;AACH;AAGO,IAAM,QAAQ;","names":[]}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@coder/ai-sdk-provider",
+  "version": "0.1.0",
+  "description": "Vercel AI SDK provider for Coder AI Gateway. Point the AI SDK at your Coder deployment with a Coder API token and use any model your deployment proxies — across AI Gateway's OpenAI- and Anthropic-compatible surfaces.",
+  "keywords": [
+    "ai",
+    "ai-gateway",
+    "ai-sdk",
+    "aibridge",
+    "anthropic",
+    "coder",
+    "llm",
+    "openai",
+    "provider",
+    "vercel-ai-sdk"
+  ],
+  "homepage": "https://github.com/coder/ai-sdk/tree/main/packages/provider#readme",
+  "bugs": {
+    "url": "https://github.com/coder/ai-sdk/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "Coder Technologies, Inc. (https://coder.com)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coder/ai-sdk.git",
+    "directory": "packages/provider"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.85",
+    "@ai-sdk/openai-compatible": "^2.0.51",
+    "@ai-sdk/provider": "3.0.10"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.0",
+    "@types/node": "^25.9.3",
+    "@vitest/coverage-v8": "^4.1.9",
+    "ai": "^6.0.206",
+    "publint": "^0.3.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9",
+    "zod": "4.4.3"
+  },
+  "peerDependencies": {
+    "ai": "^6.0.0",
+    "zod": "^3.25.76 || ^4.1.8"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "attw": "attw --pack --ignore-rules cjs-resolves-to-esm",
+    "example:generate": "tsx examples/01-generate.ts",
+    "example:stream": "tsx examples/02-stream.ts",
+    "example:anthropic": "tsx examples/03-anthropic.ts"
+  }
+}