@mcarvin/smart-diff 1.0.5 → 2.0.0

package/README.md

@@ -3,14 +3,16 @@
 [![NPM](https://img.shields.io/npm/v/@mcarvin/smart-diff.svg?label=smart-diff)](https://www.npmjs.com/package/@mcarvin/smart-diff)
 [![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://raw.githubusercontent.com/mcarvin8/smart-diff/main/LICENSE.md)
 [![Downloads/week](https://img.shields.io/npm/dw/@mcarvin/smart-diff.svg)](https://npmjs.org/package/@mcarvin/smart-diff)
+[![Maintainability](https://qlty.sh/gh/mcarvin8/projects/smart-diff/maintainability.svg)](https://qlty.sh/gh/mcarvin8/projects/smart-diff)
 [![codecov](https://codecov.io/gh/mcarvin8/smart-diff/graph/badge.svg?token=H3ZWAGG7S9)](https://codecov.io/gh/mcarvin8/smart-diff)
 
-TypeScript library that turns a **git revision range** into a **Markdown summary** using an OpenAI-compatible Chat Completions API. It uses [`simple-git`](https://github.com/steveukx/git-js) to read the repo, respects **path includes/excludes** and **commit message include/exclude regexes**, and sends commits, paths, structured diff stats, and unified diff text to the model.
+TypeScript library that turns a **git revision range** into a **Markdown summary** using any LLM provider supported by the [Vercel AI SDK](https://sdk.vercel.ai) — OpenAI, Anthropic, Google Gemini, Amazon Bedrock, Mistral, Cohere, Groq, xAI, DeepSeek, or any OpenAI-compatible gateway. It uses [`simple-git`](https://github.com/steveukx/git-js) to read the repo, respects **path includes/excludes** and **commit message include/exclude regexes**, and sends commits, paths, structured diff stats, and unified diff text to the model.
 
 ## Requirements
 
 - **Node.js** 20+
-- [Git Bash](https://git-scm.com/install/)
+- An LLM provider credential (see [Provider configuration](#provider-configuration))
+- [Git](https://git-scm.com/) on the `PATH`
 
 ## Installation
 
@@ -18,25 +20,70 @@ TypeScript library that turns a **git revision range** into a **Markdown summary
 npm install @mcarvin/smart-diff
 ```
 
-## LLM configuration
+`@ai-sdk/openai` and `@ai-sdk/openai-compatible` ship as direct dependencies. Every other provider (`@ai-sdk/anthropic`, `@ai-sdk/google`, `@ai-sdk/amazon-bedrock`, `@ai-sdk/mistral`, `@ai-sdk/cohere`, `@ai-sdk/groq`, `@ai-sdk/xai`, `@ai-sdk/deepseek`) is declared as an **optional peer** and only needs to be installed when you actually use that provider. If the package is missing, smart-diff throws a clear error telling you which one to install.
 
-The library is considered “configured” when `shouldUseLlmGateway()` is true: API key, base URL, and/or JSON default headers are set. Otherwise `summarizeGitDiff` / `generateSummary` throw with `LLM_GATEWAY_REQUIRED_MESSAGE` unless you pass **`openAiClientProvider`**.
+## Provider configuration
+
+smart-diff is "configured" when [`isLlmProviderConfigured()`](#lower-level-api) returns true — i.e. at least one supported provider can be resolved from env vars — **or** you pass your own `llmModelProvider` factory. Otherwise `summarizeGitDiff` / `generateSummary` throw with `LLM_GATEWAY_REQUIRED_MESSAGE`.
+
+### Selecting a provider
+
+`LLM_PROVIDER` explicitly selects a provider. When unset, the resolver auto-detects in this order: `LLM_BASE_URL`/`OPENAI_BASE_URL` → `openai-compatible`, `OPENAI_API_KEY`/`LLM_API_KEY` → `openai`, then `ANTHROPIC_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY` (or `GOOGLE_API_KEY`), `MISTRAL_API_KEY`, `COHERE_API_KEY`, `GROQ_API_KEY`, `XAI_API_KEY`, `DEEPSEEK_API_KEY`, and finally `OPENAI_DEFAULT_HEADERS`/`LLM_DEFAULT_HEADERS` → `openai`.
+
+| Provider (`LLM_PROVIDER`) | Package | Credential env vars | Default model |
+|---|---|---|---|
+| `openai` | `@ai-sdk/openai` | `OPENAI_API_KEY` or `LLM_API_KEY` | `gpt-4o-mini` |
+| `openai-compatible` | `@ai-sdk/openai-compatible` | `LLM_BASE_URL` or `OPENAI_BASE_URL` (required); `OPENAI_API_KEY`/`LLM_API_KEY` or custom headers | `gpt-4o-mini` |
+| `anthropic` | `@ai-sdk/anthropic` | `ANTHROPIC_API_KEY` | `claude-3-5-haiku-latest` |
+| `google` | `@ai-sdk/google` | `GOOGLE_GENERATIVE_AI_API_KEY` or `GOOGLE_API_KEY` | `gemini-2.0-flash` |
+| `bedrock` | `@ai-sdk/amazon-bedrock` | Standard AWS credential chain (env / profile / role) | `anthropic.claude-3-5-haiku-20241022-v1:0` |
+| `mistral` | `@ai-sdk/mistral` | `MISTRAL_API_KEY` | `mistral-small-latest` |
+| `cohere` | `@ai-sdk/cohere` | `COHERE_API_KEY` | `command-r-08-2024` |
+| `groq` | `@ai-sdk/groq` | `GROQ_API_KEY` | `llama-3.1-8b-instant` |
+| `xai` | `@ai-sdk/xai` | `XAI_API_KEY` | `grok-2-latest` |
+| `deepseek` | `@ai-sdk/deepseek` | `DEEPSEEK_API_KEY` | `deepseek-chat` |
+
+> `LLM_*` wins over `OPENAI_*` where both exist.
+
+### Common env vars
 
 | Variable | Purpose |
-|----------|---------|
-| `OPENAI_API_KEY` or `LLM_API_KEY` | API key (`LLM_*` wins over `OPENAI_*` where both exist). |
-| `OPENAI_BASE_URL` or `LLM_BASE_URL` | Base URL for an OpenAI-compatible gateway (`LLM_*` overrides). |
-| `OPENAI_DEFAULT_HEADERS` / `LLM_DEFAULT_HEADERS` | JSON object of extra headers; `LLM_*` merges on top of `OPENAI_*`. Can supply `Authorization` (e.g. raw `sk-…`) when no env key is set. |
-| `LLM_MAX_DIFF_CHARS` | Max size of unified diff text sent to the model (default ~120k characters). |
-| `LLM_MAX_TOKENS` or `OPENAI_MAX_TOKENS` | Max completion tokens (default 4000). |
+|---|---|
+| `LLM_PROVIDER` | Explicit provider id from the table above. |
+| `LLM_MODEL` | Overrides the per-provider default model id. |
+| `OPENAI_BASE_URL` / `LLM_BASE_URL` | Base URL for an OpenAI-compatible gateway; presence alone auto-selects the `openai-compatible` provider. |
+| `OPENAI_DEFAULT_HEADERS` / `LLM_DEFAULT_HEADERS` | JSON object of extra headers merged onto OpenAI / OpenAI-compatible requests (e.g. RBAC tokens, raw `Authorization`). `LLM_*` overrides `OPENAI_*` key-by-key. |
+| `LLM_PROVIDER_NAME` | Display name used when `openai-compatible` is active (defaults to `openai-compatible`). |
+| `OPENAI_MAX_DIFF_CHARS` / `LLM_MAX_DIFF_CHARS` | Max size of unified diff text sent to the model (default ~120k characters). |
+| `OPENAI_MAX_TOKENS` / `LLM_MAX_TOKENS` | Max completion tokens (default 4000). |
+
+### Example: native OpenAI
+
+```powershell
+$env:OPENAI_API_KEY = "sk-..."
+# Optional: $env:LLM_MODEL = "gpt-4o"
+```
 
-The client is created with the official [`openai`](https://www.npmjs.com/package/openai) SDK via `createOpenAiLikeClient()`; use a compatible endpoint and model ID for your provider.
+### Example: Anthropic Claude
+
+```powershell
+$env:ANTHROPIC_API_KEY = "sk-ant-..."
+$env:LLM_MODEL = "claude-3-5-sonnet-latest"   # optional override
+```
 
-Example using a company-managed OpenAI-compatible gateway:
+### Example: company-managed OpenAI-compatible gateway
 
 ```powershell
-$env:LLM_DEFAULT_HEADERS = '{"x-company-rbac":"your-rbac-token-here","Authorization":"sk-your-api-key-here"}'
-$env:LLM_BASE_URL = "https://llm-gateway.example.com"
+$env:OPENAI_BASE_URL = "https://llm-gateway.example.com"
+$env:OPENAI_DEFAULT_HEADERS = '{"x-company-rbac":"your-rbac-token-here","Authorization":"Bearer sk-your-api-key-here"}'
+# LLM_PROVIDER is auto-detected as "openai-compatible" because LLM_BASE_URL/OPENAI_BASE_URL is set.
+```
+
+### Example: Google Gemini
+
+```powershell
+$env:GOOGLE_GENERATIVE_AI_API_KEY = "..."
+$env:LLM_MODEL = "gemini-2.0-flash"
 ```
 
 ## Usage
@@ -55,9 +102,10 @@ const markdown = await summarizeGitDiff({
   commitMessageExcludeRegexes: ['^\\[bot\\]'],
   commitMessageIncludeRegexes: ['^feat:'], // optional; OR across patterns
   teamName: 'Platform',
-  systemPrompt: undefined, // optional; overrides DEFAULT_GIT_DIFF_SYSTEM_PROMPT
-  model: 'gpt-4o-mini', // optional
-  maxDiffChars: 120_000, // optional; also see LLM_MAX_DIFF_CHARS
+  systemPrompt: undefined,   // optional; overrides DEFAULT_GIT_DIFF_SYSTEM_PROMPT
+  provider: 'anthropic',     // optional; overrides LLM_PROVIDER env + auto-detection
+  model: 'claude-3-5-sonnet-latest', // optional
+  maxDiffChars: 120_000,     // optional; also see LLM_MAX_DIFF_CHARS
 });
 ```
 
@@ -71,9 +119,27 @@ const markdown = await summarizeGitDiff({
 | `commitMessageExcludeRegexes` | Drop commits whose message matches **any** of these patterns. |
 | `teamName` | Adds a `Team:` line to the user payload for the model. |
 | `systemPrompt` | Replaces the default system prompt. |
-| `model` | Chat model id (default `gpt-4o-mini`). |
+| `provider` | `LlmProviderId` — wins over `LLM_PROVIDER` env and auto-detection. |
+| `model` | Chat model id; overrides `LLM_MODEL` and the provider default. |
 | `maxDiffChars` | Caps unified diff size for the request. |
-| `openAiClientProvider` | `() => Promise<OpenAiLikeClient>` — bypasses env-based client creation (required in tests or when you wire the SDK yourself). |
+| `llmModelProvider` | `() => Promise<LanguageModel>` — bypass env-based resolution entirely; hand-wire a Vercel AI SDK `LanguageModel` (required in tests or custom setups). |
+
+### Injecting your own `LanguageModel`
+
+If you want full control — for example, to configure retries, middlewares, or hit an in-process mock — pass `llmModelProvider`:
+
+```ts
+import { summarizeGitDiff } from '@mcarvin/smart-diff';
+import { createAnthropic } from '@ai-sdk/anthropic';
+
+const md = await summarizeGitDiff({
+  from: 'origin/main',
+  llmModelProvider: async () =>
+    createAnthropic({ apiKey: process.env.MY_ANTHROPIC_KEY })(
+      'claude-3-5-sonnet-latest',
+    ),
+});
+```
 
 ### Diff shape: single range vs per-commit
 
@@ -82,13 +148,28 @@ const markdown = await summarizeGitDiff({
 
 ### Lower-level API
 
-The package also exports helpers such as `createGitClient`, `getCommits`, `getDiff`, `getDiffSummary`, `getChangedFiles`, `filterCommitsByMessageRegexes`, `buildDiffPathspecs`, `generateSummary`, and OpenAI config utilities (`resolveLlmBaseUrl`, `shouldUseLlmGateway`, `createOpenAiLikeClient`, …). Use these if you build a custom pipeline but still want the same git and LLM behavior.
+The package also exports helpers for building a custom pipeline on top of the same git and LLM behavior:
+
+- **Git**: `createGitClient`, `getRepoRoot`, `getCommits`, `getDiff`, `getDiffSummary`, `getChangedFiles`, `filterCommitsByMessageRegexes`, `buildDiffPathspecs`
+- **AI**: `generateSummary`, `resolveLlmMaxDiffChars`, `truncateUnifiedDiffForLlm`
+- **Provider resolution**: `resolveLanguageModel`, `detectLlmProvider`, `isLlmProviderConfigured`, `defaultModelForProvider`, `resolveLlmBaseUrl`, `parseLlmDefaultHeadersFromEnv`
+- **Constants / types**: `DEFAULT_GIT_DIFF_SYSTEM_PROMPT`, `LLM_GATEWAY_REQUIRED_MESSAGE`, `LlmProviderId`, `LlmModelProvider`, `ResolveLanguageModelOptions`, `GenerateSummaryInput`, `SummarizeFlags`
+
+## Migrating from 1.x → 2.x
+
+v2 replaces the direct `openai` SDK dependency with the Vercel AI SDK. If you only rely on env-var configuration, your setup keeps working — `OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_DEFAULT_HEADERS`, `LLM_*` equivalents, `OPENAI_MAX_DIFF_CHARS`, and `OPENAI_MAX_TOKENS` are all still honored.
+
+Breaking changes:
+
+- **Removed `openAiClientProvider` option** on `summarizeGitDiff`/`generateSummary`. Use `llmModelProvider: () => Promise<LanguageModel>` returning a Vercel AI SDK model instead.
+- **Removed `OpenAiLikeClient` and `createOpenAiLikeClient` exports**, along with `shouldUseLlmGateway`. Use `isLlmProviderConfigured()` / `resolveLanguageModel()` instead.
+- **`openai` npm package is no longer a dependency.** Remove it from your own `package.json` if you only depended on it transitively via smart-diff.
 
 ## Used By
 
 This package is used by:
 
-- [sf-git-ai-meta-insights](https://github.com/mcarvin8/sf-git-ai-meta-insights) = Salesforce metadata wrapper compatible with Salesforce DX projects
+- [sf-git-ai-meta-insights](https://github.com/mcarvin8/sf-git-ai-meta-insights) — Salesforce metadata wrapper compatible with Salesforce DX projects
 
 ## License
 

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var ai = require('ai');
 var node_path = require('node:path');
 var simpleGit = require('simple-git');
 
@@ -35,9 +36,55 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+const DEFAULT_LLM_MAX_DIFF_CHARS = 120000;
+const DEFAULT_GIT_DIFF_SYSTEM_PROMPT = `You are a senior software engineer helping developers understand code and configuration changes from the git context they supplied.
+You receive: commit subject lines (when available), changed file paths, and unified git patch(es)—either one range diff or concatenated per-commit patches, depending on how the diff was produced. Patches may be truncated mid-section with an explicit marker—do not infer changes beyond visible lines.
+Explain what changed in terms of behavior, APIs, data, configuration, security, and operational risk. Tie claims to the patch when possible.
+Produce a concise, developer-focused summary in Markdown.
+Use sections that fit the change (for example: Highlights, Breaking or risky changes, API / contract changes, Data & schema, Configuration & infra, Security & auth, Tests & quality). Omit empty sections.
+Group related changes; do not list every individual file. When multiple commits appear in the context, briefly separate notable themes by commit when helpful.
+If the user message includes a Team line, use that exact team name in the summary title (for example: "## <Team> – Change summary" or similar).`;
+const LLM_GATEWAY_REQUIRED_MESSAGE = "No LLM provider configured. Set LLM_PROVIDER (openai | openai-compatible | anthropic | google | bedrock | mistral | cohere | groq | xai | deepseek), " +
+    "or a provider API key (OPENAI_API_KEY, LLM_API_KEY, ANTHROPIC_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, MISTRAL_API_KEY, COHERE_API_KEY, GROQ_API_KEY, XAI_API_KEY, DEEPSEEK_API_KEY), " +
+    "or LLM_BASE_URL / OPENAI_BASE_URL for an OpenAI-compatible gateway, " +
+    "or JSON in OPENAI_DEFAULT_HEADERS / LLM_DEFAULT_HEADERS. " +
+    "Alternatively pass llmModelProvider or openAiClientProvider to generateSummary or summarizeGitDiff.";
+
+const DEFAULT_MODEL_BY_PROVIDER = {
+    openai: "gpt-4o-mini",
+    "openai-compatible": "gpt-4o-mini",
+    anthropic: "claude-3-5-haiku-latest",
+    google: "gemini-2.0-flash",
+    bedrock: "anthropic.claude-3-5-haiku-20241022-v1:0",
+    mistral: "mistral-small-latest",
+    cohere: "command-r-08-2024",
+    groq: "llama-3.1-8b-instant",
+    xai: "grok-2-latest",
+    deepseek: "deepseek-chat",
+};
+const VALID_PROVIDERS = new Set([
+    "openai",
+    "openai-compatible",
+    "anthropic",
+    "google",
+    "bedrock",
+    "mistral",
+    "cohere",
+    "groq",
+    "xai",
+    "deepseek",
+]);
+function readEnv(name) {
+    var _a;
+    const value = (_a = process.env[name]) === null || _a === void 0 ? void 0 : _a.trim();
+    return value && value.length > 0 ? value : undefined;
+}
+function isValidProviderId(value) {
+    return VALID_PROVIDERS.has(value);
+}
 function resolveLlmBaseUrl() {
-    var _a, _b, _c;
-    return ((_b = (_a = process.env.LLM_BASE_URL) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : (_c = process.env.OPENAI_BASE_URL) === null || _c === void 0 ? void 0 : _c.trim());
+    var _a;
+    return (_a = readEnv("LLM_BASE_URL")) !== null && _a !== void 0 ? _a : readEnv("OPENAI_BASE_URL");
 }
 function parseHeaderJsonObject(raw) {
     const trimmed = raw === null || raw === void 0 ? void 0 : raw.trim();
@@ -68,87 +115,187 @@ function parseLlmDefaultHeadersFromEnv() {
     const merged = Object.assign(Object.assign({}, base), override);
     return Object.keys(merged).length > 0 ? merged : undefined;
 }
-function findAuthorizationHeaderName(headers) {
-    return Object.keys(headers).find((k) => k.toLowerCase() === "authorization");
-}
-function stripBearerPrefix(value) {
+function resolveOpenAiApiKey() {
     var _a;
-    const trimmed = value.trim();
-    const match = /^Bearer\s+(\S+)/i.exec(trimmed);
-    return (_a = match === null || match === void 0 ? void 0 : match[1]) !== null && _a !== void 0 ? _a : trimmed;
-}
-function splitPromotableAuthorizationFromHeaders(headers) {
-    const authName = findAuthorizationHeaderName(headers);
-    if (!authName) {
-        return { defaultHeaders: headers };
-    }
-    const raw = headers[authName];
-    if (!raw) {
-        return { defaultHeaders: headers };
-    }
-    const token = stripBearerPrefix(raw);
-    const looksBearer = /^Bearer\s+\S+/i.test(raw.trim());
-    const looksOpenAiKey = /^sk-/i.test(token);
-    if (!looksBearer && !looksOpenAiKey) {
-        return { defaultHeaders: headers };
-    }
-    const next = Object.assign({}, headers);
-    delete next[authName];
-    return { defaultHeaders: next, apiKeyFromAuthHeader: token };
-}
-function shouldUseLlmGateway() {
-    var _a, _b, _c;
-    const apiKey = (_b = (_a = process.env.LLM_API_KEY) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : (_c = process.env.OPENAI_API_KEY) === null || _c === void 0 ? void 0 : _c.trim();
-    if (apiKey)
-        return true;
-    if (resolveLlmBaseUrl())
-        return true;
-    const jsonHeaders = parseLlmDefaultHeadersFromEnv();
-    if (jsonHeaders && Object.keys(jsonHeaders).length > 0)
-        return true;
-    return false;
-}
-function resolveOpenAiLikeClientInit() {
-    var _a, _b, _c, _d, _e;
-    const baseURL = resolveLlmBaseUrl();
-    const mergedHeaders = (_a = parseLlmDefaultHeadersFromEnv()) !== null && _a !== void 0 ? _a : {};
-    const envApiKey = (_e = (_c = (_b = process.env.LLM_API_KEY) === null || _b === void 0 ? void 0 : _b.trim()) !== null && _c !== void 0 ? _c : (_d = process.env.OPENAI_API_KEY) === null || _d === void 0 ? void 0 : _d.trim()) !== null && _e !== void 0 ? _e : "";
-    let defaultHeaders;
-    let apiKey = envApiKey;
-    if (apiKey.length === 0) {
-        const split = splitPromotableAuthorizationFromHeaders(mergedHeaders);
-        if (split.apiKeyFromAuthHeader) {
-            apiKey = split.apiKeyFromAuthHeader;
+    return (_a = readEnv("LLM_API_KEY")) !== null && _a !== void 0 ? _a : readEnv("OPENAI_API_KEY");
+}
+function detectLlmProvider() {
+    var _a, _b;
+    const explicit = (_a = readEnv("LLM_PROVIDER")) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (explicit && isValidProviderId(explicit)) {
+        return explicit;
+    }
+    if (resolveLlmBaseUrl()) {
+        return "openai-compatible";
+    }
+    if (resolveOpenAiApiKey()) {
+        return "openai";
+    }
+    if (readEnv("ANTHROPIC_API_KEY"))
+        return "anthropic";
+    if ((_b = readEnv("GOOGLE_GENERATIVE_AI_API_KEY")) !== null && _b !== void 0 ? _b : readEnv("GOOGLE_API_KEY"))
+        return "google";
+    if (readEnv("MISTRAL_API_KEY"))
+        return "mistral";
+    if (readEnv("COHERE_API_KEY"))
+        return "cohere";
+    if (readEnv("GROQ_API_KEY"))
+        return "groq";
+    if (readEnv("XAI_API_KEY"))
+        return "xai";
+    if (readEnv("DEEPSEEK_API_KEY"))
+        return "deepseek";
+    if (parseLlmDefaultHeadersFromEnv())
+        return "openai";
+    return undefined;
+}
+function isLlmProviderConfigured() {
+    return detectLlmProvider() !== undefined;
+}
+function defaultModelForProvider(provider) {
+    return DEFAULT_MODEL_BY_PROVIDER[provider];
+}
+function createOpenAiModel(modelId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { createOpenAI } = yield import('@ai-sdk/openai');
+        const apiKey = resolveOpenAiApiKey();
+        const headers = parseLlmDefaultHeadersFromEnv();
+        const provider = createOpenAI(Object.assign(Object.assign({}, (apiKey ? { apiKey } : {})), (headers ? { headers } : {})));
+        return provider(modelId);
+    });
+}
+function createOpenAiCompatibleModel(modelId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { createOpenAICompatible } = yield import('@ai-sdk/openai-compatible');
+        const baseURL = resolveLlmBaseUrl();
+        if (!baseURL) {
+            throw new Error("openai-compatible provider requires LLM_BASE_URL or OPENAI_BASE_URL to be set.");
         }
-        defaultHeaders =
-            Object.keys(split.defaultHeaders).length > 0
-                ? split.defaultHeaders
-                : undefined;
-    }
-    else {
-        defaultHeaders =
-            Object.keys(mergedHeaders).length > 0 ? mergedHeaders : undefined;
-    }
-    return Object.assign(Object.assign({ apiKey: apiKey.length > 0 ? apiKey : "unused" }, (baseURL ? { baseURL } : {})), (defaultHeaders ? { defaultHeaders } : {}));
+        const apiKey = resolveOpenAiApiKey();
+        const headers = parseLlmDefaultHeadersFromEnv();
+        const provider = createOpenAICompatible(Object.assign(Object.assign({ name: (_a = readEnv("LLM_PROVIDER_NAME")) !== null && _a !== void 0 ? _a : "openai-compatible", baseURL }, (apiKey ? { apiKey } : {})), (headers ? { headers } : {})));
+        return provider(modelId);
+    });
+}
+function wrapMissingPeer(failure) {
+    const err = new Error(`Failed to load optional provider package "${failure.pkg}" for LLM_PROVIDER="${failure.provider}". ` +
+        `Install it with \`npm install ${failure.pkg}\`.`);
+    err.cause = failure.cause;
+    return err;
 }
-function createOpenAiLikeClient() {
+function importOptional(provider, pkg, loader) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { default: OpenAI } = yield import('openai');
-        return new OpenAI(resolveOpenAiLikeClientInit());
+        try {
+            return yield loader();
+        }
+        catch (cause) {
+            throw wrapMissingPeer({ provider, pkg, cause });
+        }
+    });
+}
+function createAnthropicModel(modelId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mod = yield importOptional("anthropic", "@ai-sdk/anthropic", () => import('@ai-sdk/anthropic'));
+        const apiKey = readEnv("ANTHROPIC_API_KEY");
+        const provider = mod.createAnthropic(apiKey ? { apiKey } : undefined);
+        return provider(modelId);
+    });
+}
+function createGoogleModel(modelId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const mod = yield importOptional("google", "@ai-sdk/google", () => import('@ai-sdk/google'));
+        const apiKey = (_a = readEnv("GOOGLE_GENERATIVE_AI_API_KEY")) !== null && _a !== void 0 ? _a : readEnv("GOOGLE_API_KEY");
+        const provider = mod.createGoogleGenerativeAI(apiKey ? { apiKey } : undefined);
+        return provider(modelId);
+    });
+}
+function createBedrockModel(modelId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mod = yield importOptional("bedrock", "@ai-sdk/amazon-bedrock", () => import('@ai-sdk/amazon-bedrock'));
+        const provider = mod.createAmazonBedrock();
+        return provider(modelId);
+    });
+}
+function createMistralModel(modelId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mod = yield importOptional("mistral", "@ai-sdk/mistral", () => import('@ai-sdk/mistral'));
+        const apiKey = readEnv("MISTRAL_API_KEY");
+        const provider = mod.createMistral(apiKey ? { apiKey } : undefined);
+        return provider(modelId);
+    });
+}
+function createCohereModel(modelId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mod = yield importOptional("cohere", "@ai-sdk/cohere", () => import('@ai-sdk/cohere'));
+        const apiKey = readEnv("COHERE_API_KEY");
+        const provider = mod.createCohere(apiKey ? { apiKey } : undefined);
+        return provider(modelId);
+    });
+}
+function createGroqModel(modelId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mod = yield importOptional("groq", "@ai-sdk/groq", () => import('@ai-sdk/groq'));
+        const apiKey = readEnv("GROQ_API_KEY");
+        const provider = mod.createGroq(apiKey ? { apiKey } : undefined);
+        return provider(modelId);
+    });
+}
+function createXaiModel(modelId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mod = yield importOptional("xai", "@ai-sdk/xai", () => import('@ai-sdk/xai'));
+        const apiKey = readEnv("XAI_API_KEY");
+        const provider = mod.createXai(apiKey ? { apiKey } : undefined);
+        return provider(modelId);
+    });
+}
+function createDeepseekModel(modelId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mod = yield importOptional("deepseek", "@ai-sdk/deepseek", () => import('@ai-sdk/deepseek'));
+        const apiKey = readEnv("DEEPSEEK_API_KEY");
+        const provider = mod.createDeepSeek(apiKey ? { apiKey } : undefined);
+        return provider(modelId);
+    });
+}
+function resolveLanguageModel() {
+    return __awaiter(this, arguments, void 0, function* (options = {}) {
+        var _a, _b, _c;
+        const provider = (_a = options.provider) !== null && _a !== void 0 ? _a : detectLlmProvider();
+        if (!provider) {
+            throw new Error("No LLM provider could be resolved. Set LLM_PROVIDER or a provider API key " +
+                "(OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, MISTRAL_API_KEY, " +
+                "COHERE_API_KEY, GROQ_API_KEY, XAI_API_KEY, DEEPSEEK_API_KEY), or LLM_BASE_URL for an OpenAI-compatible gateway.");
+        }
+        const modelId = (_c = (_b = options.model) !== null && _b !== void 0 ? _b : readEnv("LLM_MODEL")) !== null && _c !== void 0 ? _c : defaultModelForProvider(provider);
+        switch (provider) {
+            case "openai":
+                return createOpenAiModel(modelId);
+            case "openai-compatible":
+                return createOpenAiCompatibleModel(modelId);
+            case "anthropic":
+                return createAnthropicModel(modelId);
+            case "google":
+                return createGoogleModel(modelId);
+            case "bedrock":
+                return createBedrockModel(modelId);
+            case "mistral":
+                return createMistralModel(modelId);
+            case "cohere":
+                return createCohereModel(modelId);
+            case "groq":
+                return createGroqModel(modelId);
+            case "xai":
+                return createXaiModel(modelId);
+            case "deepseek":
+                return createDeepseekModel(modelId);
+            default: {
+                const _exhaustive = provider;
+                throw new Error(`Unhandled LLM provider: ${String(_exhaustive)}`);
+            }
+        }
     });
 }
-
-const DEFAULT_LLM_MAX_DIFF_CHARS = 120000;
-const DEFAULT_GIT_DIFF_SYSTEM_PROMPT = `You are a senior software engineer helping developers understand code and configuration changes from the git context they supplied.
-You receive: commit subject lines (when available), changed file paths, and unified git patch(es)—either one range diff or concatenated per-commit patches, depending on how the diff was produced. Patches may be truncated mid-section with an explicit marker—do not infer changes beyond visible lines.
-Explain what changed in terms of behavior, APIs, data, configuration, security, and operational risk. Tie claims to the patch when possible.
-Produce a concise, developer-focused summary in Markdown.
-Use sections that fit the change (for example: Highlights, Breaking or risky changes, API / contract changes, Data & schema, Configuration & infra, Security & auth, Tests & quality). Omit empty sections.
-Group related changes; do not list every individual file. When multiple commits appear in the context, briefly separate notable themes by commit when helpful.
-If the user message includes a Team line, use that exact team name in the summary title (for example: "## <Team> – Change summary" or similar).`;
-const LLM_GATEWAY_REQUIRED_MESSAGE = "No LLM gateway configured. Set OPENAI_API_KEY or LLM_API_KEY, and/or LLM_BASE_URL or OPENAI_BASE_URL, " +
-    "and/or JSON in OPENAI_DEFAULT_HEADERS or LLM_DEFAULT_HEADERS. " +
-    "Alternatively pass openAiClientProvider to generateSummary or summarizeGitDiff.";
 
 function resolveLlmMaxDiffChars(cliOverride) {
     var _a;
@@ -173,17 +320,33 @@ function truncateUnifiedDiffForLlm(diffText, maxChars) {
     const marker = `\n\n--- TRUNCATED: unified diff was ${diffText.length} characters; only the first ${maxChars} were sent. Narrow the ref range, adjust commit/path filters, or raise maxDiffChars / LLM_MAX_DIFF_CHARS only if your model context allows. ---\n`;
     return diffText.slice(0, maxChars) + marker;
 }
+function markdownDiffTruncationNotice(originalChars, maxChars) {
+    return `> **Truncated diff:** The unified diff was ${originalChars} characters; only the first ${maxChars} were sent to the model. The summary may not reflect the full change set. Narrow the ref range, adjust path filters, or raise \`maxDiffChars\` / \`LLM_MAX_DIFF_CHARS\`—often together with switching to a model whose context window can fit a larger prompt.\n\n`;
+}
+function resolveMaxOutputTokens() {
+    var _a;
+    const raw = (_a = process.env.LLM_MAX_TOKENS) !== null && _a !== void 0 ? _a : process.env.OPENAI_MAX_TOKENS;
+    const parsed = raw !== undefined ? Number.parseInt(raw, 10) : 4000;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 4000;
+}
 function generateSummary(input) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const { diffText, fileNames, commits, flags, openAiClientProvider, diffSummary, } = input;
-        if (!shouldUseLlmGateway() && openAiClientProvider === undefined) {
+        var _a;
+        const { diffText, fileNames, commits, flags, llmModelProvider, diffSummary, } = input;
+        if (!llmModelProvider && !isLlmProviderConfigured()) {
             throw new Error(LLM_GATEWAY_REQUIRED_MESSAGE);
         }
         const maxDiffChars = resolveLlmMaxDiffChars(flags.maxDiffChars);
+        const diffTruncated = diffText.length > maxDiffChars;
         const diffForLlm = truncateUnifiedDiffForLlm(diffText, maxDiffChars);
-        const userContent = buildOpenAiUserContent(flags, commits, fileNames, diffForLlm, diffSummary);
-        return callOpenAi(userContent, (_a = flags.model) !== null && _a !== void 0 ? _a : "gpt-4o-mini", (_b = flags.systemPrompt) !== null && _b !== void 0 ? _b : DEFAULT_GIT_DIFF_SYSTEM_PROMPT, openAiClientProvider !== null && openAiClientProvider !== void 0 ? openAiClientProvider : (() => __awaiter(this, void 0, void 0, function* () { return createOpenAiLikeClient(); })));
+        const userContent = buildUserContent(flags, commits, fileNames, diffForLlm, diffSummary);
+        const systemPrompt = (_a = flags.systemPrompt) !== null && _a !== void 0 ? _a : DEFAULT_GIT_DIFF_SYSTEM_PROMPT;
+        const maxOutputTokens = resolveMaxOutputTokens();
+        const summary = yield callLlm(userContent, systemPrompt, maxOutputTokens, llmModelProvider, flags);
+        if (!diffTruncated) {
+            return summary;
+        }
+        return markdownDiffTruncationNotice(diffText.length, maxDiffChars) + summary;
     });
 }
 function formatRegexFilterLines(flags) {
@@ -206,7 +369,7 @@ function formatRegexFilterLines(flags) {
     return (`${incLine}${excLine}` +
         "Git context shape: concatenated per-commit unified patches for commits that pass the message filters.\n");
 }
-function buildOpenAiUserContent(flags, commits, fileNames, diffText, diffSummary) {
+function buildUserContent(flags, commits, fileNames, diffText, diffSummary) {
     var _a, _b;
     const from = flags.from;
     const to = (_a = flags.to) !== null && _a !== void 0 ? _a : "HEAD";
@@ -236,31 +399,21 @@ function buildOpenAiUserContent(flags, commits, fileNames, diffText, diffSummary
         "=== Git context (unified diff(s); patches may be truncated with an explicit marker) ===\n" +
         diffText);
 }
-function callOpenAi(userContent, model, systemPrompt, openAiClientProvider) {
+function callLlm(userContent, systemPrompt, maxOutputTokens, llmModelProvider, flags) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f;
-        const client = yield openAiClientProvider();
-        const maxTokensRaw = (_a = process.env.LLM_MAX_TOKENS) !== null && _a !== void 0 ? _a : process.env.OPENAI_MAX_TOKENS;
-        const parsed = maxTokensRaw !== undefined ? Number.parseInt(maxTokensRaw, 10) : 4000;
-        const maxTokens = Number.isFinite(parsed) && parsed > 0 ? parsed : 4000;
-        const response = yield client.chat.completions.create({
+        var _a, _b;
+        const model = llmModelProvider
+            ? yield llmModelProvider()
+            : yield resolveLanguageModel(Object.assign(Object.assign({}, (flags.provider ? { provider: flags.provider } : {})), (flags.model ? { model: flags.model } : {})));
+        const result = yield ai.generateText({
             model,
-            messages: [
-                {
-                    role: "system",
-                    content: systemPrompt,
-                },
-                {
-                    role: "user",
-                    content: userContent,
-                },
-            ],
+            system: systemPrompt,
+            prompt: userContent,
             temperature: 0.2,
-            max_tokens: maxTokens,
+            maxOutputTokens,
         });
-        const typedResponse = response;
-        const text = (_f = (_e = (_d = (_c = (_b = typedResponse.choices) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.message) === null || _d === void 0 ? void 0 : _d.content) === null || _e === void 0 ? void 0 : _e.trim()) !== null && _f !== void 0 ? _f : "";
-        return text.length > 0 ? text : "No summary generated by OpenAI.";
+        const text = (_b = (_a = result.text) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : "";
+        return text.length > 0 ? text : "No summary generated by the model.";
     });
 }
 
@@ -704,6 +857,7 @@ function summarizeGitDiff(options) {
             to,
             team: options.teamName,
             model: options.model,
+            provider: options.provider,
             maxDiffChars: options.maxDiffChars,
             systemPrompt: options.systemPrompt,
             commitMessageIncludeRegexes: options.commitMessageIncludeRegexes,
@@ -714,7 +868,7 @@ function summarizeGitDiff(options) {
             fileNames,
             commits: filteredCommits,
             flags: summarizeFlags,
-            openAiClientProvider: options.openAiClientProvider,
+            llmModelProvider: options.llmModelProvider,
             diffSummary,
         });
     });
@@ -724,7 +878,8 @@ exports.DEFAULT_GIT_DIFF_SYSTEM_PROMPT = DEFAULT_GIT_DIFF_SYSTEM_PROMPT;
 exports.LLM_GATEWAY_REQUIRED_MESSAGE = LLM_GATEWAY_REQUIRED_MESSAGE;
 exports.buildDiffPathspecs = buildDiffPathspecs;
 exports.createGitClient = createGitClient;
-exports.createOpenAiLikeClient = createOpenAiLikeClient;
+exports.defaultModelForProvider = defaultModelForProvider;
+exports.detectLlmProvider = detectLlmProvider;
 exports.filterCommitsByMessageRegexes = filterCommitsByMessageRegexes;
 exports.generateSummary = generateSummary;
 exports.getChangedFiles = getChangedFiles;
@@ -732,12 +887,11 @@ exports.getCommits = getCommits;
 exports.getDiff = getDiff;
 exports.getDiffSummary = getDiffSummary;
 exports.getRepoRoot = getRepoRoot;
+exports.isLlmProviderConfigured = isLlmProviderConfigured;
 exports.parseLlmDefaultHeadersFromEnv = parseLlmDefaultHeadersFromEnv;
+exports.resolveLanguageModel = resolveLanguageModel;
 exports.resolveLlmBaseUrl = resolveLlmBaseUrl;
 exports.resolveLlmMaxDiffChars = resolveLlmMaxDiffChars;
-exports.resolveOpenAiLikeClientInit = resolveOpenAiLikeClientInit;
-exports.shouldUseLlmGateway = shouldUseLlmGateway;
-exports.splitPromotableAuthorizationFromHeaders = splitPromotableAuthorizationFromHeaders;
 exports.summarizeGitDiff = summarizeGitDiff;
 exports.truncateUnifiedDiffForLlm = truncateUnifiedDiffForLlm;
 //# sourceMappingURL=index.cjs.map