@hifullmoon/aicommit 1.4.0

package/src/provider-presets.js

@@ -0,0 +1,361 @@
+import { createRequire } from 'node:module';
+import { lstat, mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { isProviderType } from './providers.js';
+import { fileExists } from './utils.js';
+
+const require = createRequire(import.meta.url);
+const { version: CORE_VERSION } = require('../package.json');
+
+export const PROVIDER_PRESET_KIND = 'aicommit-provider-presets';
+export const PROVIDER_PRESET_SCHEMA_VERSION = 1;
+export const PROVIDER_ADAPTER_CONTRACT_VERSION = 1;
+export const PROVIDER_PRESET_FILENAME = 'provider-presets.json';
+export const PROVIDER_PRESET_BACKUP_FILENAME = 'provider-presets.previous.json';
+export const BUNDLED_PROVIDER_PRESET_PATH = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  '../presets/provider-presets.json',
+);
+
+const MAX_PRESET_BYTES = 256 * 1024;
+const MAX_EXTRA_BODY_DEPTH = 8;
+const MAX_EXTRA_BODY_NODES = 500;
+const STABLE_SEMVER_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+const PRERELEASE_IDENTIFIER = '(?:0|[1-9]\\d*|\\d*[A-Za-z-][0-9A-Za-z-]*)';
+const CORE_SEMVER_RE = new RegExp(
+  `^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)` +
+    `(?:-(${PRERELEASE_IDENTIFIER}(?:\\.${PRERELEASE_IDENTIFIER})*))?` +
+    '(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$',
+);
+const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const FORBIDDEN_JSON_KEYS = new Set(['__proto__', 'prototype', 'constructor']);
+const CREDENTIAL_KEY_RE =
+  /^(?:authorization|proxy-authorization|api[-_]?key|access[-_]?token|bearer[-_]?token|token|secret(?:[-_]?key)?|client[-_]?secret|password)$/i;
+
+function object(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function assertExactKeys(value, expected, path) {
+  if (!object(value)) throw new Error(`${path} must be an object.`);
+  const allowed = new Set(expected);
+  const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+  const missing = expected.filter((key) => !Object.hasOwn(value, key));
+  if (unknown.length)
+    throw new Error(`${path} contains unknown properties: ${unknown.join(', ')}.`);
+  if (missing.length) throw new Error(`${path} is missing properties: ${missing.join(', ')}.`);
+}
+
+function semverValue(value, path, { allowPrerelease = false } = {}) {
+  const match =
+    typeof value === 'string'
+      ? value.match(allowPrerelease ? CORE_SEMVER_RE : STABLE_SEMVER_RE)
+      : null;
+  if (!match) {
+    throw new Error(
+      allowPrerelease
+        ? `${path} must be a semantic version.`
+        : `${path} must be a stable semantic version (x.y.z).`,
+    );
+  }
+  return {
+    numbers: match.slice(1, 4).map(Number),
+    prerelease: match[4] ? match[4].split('.') : [],
+  };
+}
+
+function compareVersions(left, right) {
+  for (let index = 0; index < 3; index++) {
+    if (left.numbers[index] !== right.numbers[index]) {
+      return left.numbers[index] - right.numbers[index];
+    }
+  }
+  if (!left.prerelease.length || !right.prerelease.length) {
+    if (!left.prerelease.length && !right.prerelease.length) return 0;
+    return left.prerelease.length ? -1 : 1;
+  }
+  const count = Math.max(left.prerelease.length, right.prerelease.length);
+  for (let index = 0; index < count; index++) {
+    const leftPart = left.prerelease[index];
+    const rightPart = right.prerelease[index];
+    if (leftPart === undefined) return -1;
+    if (rightPart === undefined) return 1;
+    if (leftPart === rightPart) continue;
+    const leftNumeric = /^\d+$/.test(leftPart);
+    const rightNumeric = /^\d+$/.test(rightPart);
+    if (leftNumeric && rightNumeric) {
+      const normalizedLeft = leftPart.replace(/^0+(?=\d)/, '');
+      const normalizedRight = rightPart.replace(/^0+(?=\d)/, '');
+      if (normalizedLeft.length !== normalizedRight.length) {
+        return normalizedLeft.length - normalizedRight.length;
+      }
+      if (normalizedLeft === normalizedRight) continue;
+      return normalizedLeft < normalizedRight ? -1 : 1;
+    }
+    if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
+    return leftPart < rightPart ? -1 : 1;
+  }
+  return 0;
+}
+
+function assertExtraBody(value, path = 'provider.extraBody', depth = 0, state = { nodes: 0 }) {
+  state.nodes += 1;
+  if (state.nodes > MAX_EXTRA_BODY_NODES) throw new Error(`${path} is too complex.`);
+  if (depth > MAX_EXTRA_BODY_DEPTH) throw new Error(`${path} is nested too deeply.`);
+  if (value === null || ['string', 'boolean'].includes(typeof value)) return;
+  if (typeof value === 'number' && Number.isFinite(value)) return;
+  if (Array.isArray(value)) {
+    if (value.length > 100) throw new Error(`${path} has too many array items.`);
+    value.forEach((item, index) => assertExtraBody(item, `${path}[${index}]`, depth + 1, state));
+    return;
+  }
+  if (!object(value)) throw new Error(`${path} must contain JSON-compatible values.`);
+  const entries = Object.entries(value);
+  if (entries.length > 100) throw new Error(`${path} has too many properties.`);
+  for (const [key, item] of entries) {
+    if (
+      FORBIDDEN_JSON_KEYS.has(key) ||
+      CREDENTIAL_KEY_RE.test(key) ||
+      (depth === 0 && (key === 'model' || key === 'messages'))
+    ) {
+      throw new Error(`${path} contains forbidden property: ${key}.`);
+    }
+    assertExtraBody(item, `${path}.${key}`, depth + 1, state);
+  }
+}
+
+function securePresetUrl(value) {
+  try {
+    const url = new URL(value);
+    const loopback =
+      url.hostname === 'localhost' ||
+      url.hostname === '127.0.0.1' ||
+      url.hostname.startsWith('127.') ||
+      url.hostname === '[::1]';
+    const secureTransport = url.protocol === 'https:' || (url.protocol === 'http:' && loopback);
+    return secureTransport && !url.username && !url.password && !url.search && !url.hash;
+  } catch {
+    return false;
+  }
+}
+
+export function validateProviderPresetManifest(value) {
+  assertExactKeys(
+    value,
+    ['kind', 'schemaVersion', 'version', 'compatibility', 'providers'],
+    'Provider preset manifest',
+  );
+  if (value.kind !== PROVIDER_PRESET_KIND) {
+    throw new Error(`Provider preset kind must be "${PROVIDER_PRESET_KIND}".`);
+  }
+  if (value.schemaVersion !== PROVIDER_PRESET_SCHEMA_VERSION) {
+    throw new Error(`Provider preset schemaVersion must be ${PROVIDER_PRESET_SCHEMA_VERSION}.`);
+  }
+  semverValue(value.version, 'Provider preset version');
+  assertExactKeys(
+    value.compatibility,
+    ['coreMinimum', 'coreMaximumExclusive', 'adapterContract'],
+    'Provider preset compatibility',
+  );
+  const minimum = semverValue(value.compatibility.coreMinimum, 'compatibility.coreMinimum');
+  const maximum = semverValue(
+    value.compatibility.coreMaximumExclusive,
+    'compatibility.coreMaximumExclusive',
+  );
+  if (compareVersions(minimum, maximum) >= 0) {
+    throw new Error('Provider preset compatibility range is empty.');
+  }
+  if (value.compatibility.adapterContract !== PROVIDER_ADAPTER_CONTRACT_VERSION) {
+    throw new Error(
+      `Provider preset adapterContract must be ${PROVIDER_ADAPTER_CONTRACT_VERSION}.`,
+    );
+  }
+  if (!Array.isArray(value.providers) || !value.providers.length || value.providers.length > 100) {
+    throw new Error('Provider preset providers must contain 1-100 entries.');
+  }
+  const ids = new Set();
+  for (const [index, provider] of value.providers.entries()) {
+    const path = `Provider preset providers[${index}]`;
+    const required = ['id', 'label', 'adapter', 'apiUrl', 'modelId'];
+    assertExactKeys(
+      provider,
+      Object.hasOwn(provider || {}, 'extraBody') ? [...required, 'extraBody'] : required,
+      path,
+    );
+    if (
+      !ID_RE.test(provider.id) ||
+      provider.id.toLowerCase() === 'custom' ||
+      ids.has(provider.id)
+    ) {
+      throw new Error(
+        `${path}.id must be unique and use letters, digits, dot, dash, or underscore.`,
+      );
+    }
+    ids.add(provider.id);
+    if (
+      typeof provider.label !== 'string' ||
+      !provider.label.trim() ||
+      provider.label.length > 80 ||
+      /[\0-\x1f\x7f]/.test(provider.label)
+    ) {
+      throw new Error(`${path}.label must be a non-empty string of at most 80 characters.`);
+    }
+    if (!isProviderType(provider.adapter) || provider.adapter !== provider.adapter.toLowerCase()) {
+      throw new Error(`${path}.adapter is not supported by adapter contract v1.`);
+    }
+    if (
+      !securePresetUrl(provider.apiUrl) ||
+      provider.apiUrl.length > 2048 ||
+      /[\0-\x1f\x7f]/.test(provider.apiUrl)
+    ) {
+      throw new Error(
+        `${path}.apiUrl must be credential-free HTTPS, or HTTP only for localhost/loopback, without query or fragment.`,
+      );
+    }
+    if (
+      typeof provider.modelId !== 'string' ||
+      !provider.modelId.trim() ||
+      provider.modelId.length > 256 ||
+      /[\0-\x1f\x7f]/.test(provider.modelId)
+    ) {
+      throw new Error(`${path}.modelId must be a non-empty string of at most 256 characters.`);
+    }
+    if (Object.hasOwn(provider, 'extraBody')) {
+      if (!object(provider.extraBody)) throw new Error(`${path}.extraBody must be an object.`);
+      assertExtraBody(provider.extraBody, `${path}.extraBody`);
+    }
+  }
+  return value;
+}
+
+export function assertProviderPresetCompatibility(value, coreVersion = CORE_VERSION) {
+  validateProviderPresetManifest(value);
+  const core = semverValue(coreVersion, 'Core version', { allowPrerelease: true });
+  const minimum = semverValue(value.compatibility.coreMinimum, 'compatibility.coreMinimum');
+  const maximum = semverValue(
+    value.compatibility.coreMaximumExclusive,
+    'compatibility.coreMaximumExclusive',
+  );
+  if (compareVersions(core, minimum) < 0 || compareVersions(core, maximum) >= 0) {
+    throw new Error(
+      `Provider preset v${value.version} requires aicommit >=${value.compatibility.coreMinimum} and <${value.compatibility.coreMaximumExclusive}; current core is ${coreVersion}.`,
+    );
+  }
+  return value;
+}
+
+export function providerPresetPaths(home = homedir()) {
+  const directory = join(home, '.aicommit');
+  return {
+    bundled: BUNDLED_PROVIDER_PRESET_PATH,
+    user: join(directory, PROVIDER_PRESET_FILENAME),
+    backup: join(directory, PROVIDER_PRESET_BACKUP_FILENAME),
+  };
+}
+
+async function readManifest(path, coreVersion) {
+  const info = await lstat(path);
+  if (!info.isFile() || info.isSymbolicLink()) {
+    throw new Error(`Provider preset must be a regular non-symlinked file: ${path}`);
+  }
+  if (info.size > MAX_PRESET_BYTES) {
+    throw new Error(`Provider preset exceeds 256 KiB: ${path}`);
+  }
+  let value;
+  try {
+    value = JSON.parse(await readFile(path, 'utf8'));
+  } catch (err) {
+    throw new Error(`Failed to parse provider preset ${path}: ${err.message}`, { cause: err });
+  }
+  assertProviderPresetCompatibility(value, coreVersion);
+  return value;
+}
+
+export async function loadProviderPresetManifest({
+  path = null,
+  home = homedir(),
+  coreVersion,
+} = {}) {
+  const paths = providerPresetPaths(home);
+  const selected = path
+    ? resolve(path)
+    : (await fileExists(paths.user))
+      ? paths.user
+      : paths.bundled;
+  return {
+    manifest: await readManifest(selected, coreVersion),
+    path: selected,
+    source: path ? 'file' : selected === paths.user ? 'user' : 'bundled',
+  };
+}
+
+async function assertWritableTarget(path) {
+  if (!(await fileExists(path))) return;
+  const info = await lstat(path);
+  if (!info.isFile() || info.isSymbolicLink()) {
+    throw new Error(`Refusing to replace non-regular provider preset path: ${path}`);
+  }
+}
+
+async function writeTextAtomic(path, text) {
+  const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(temp, text, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    await rename(temp, path);
+  } catch (err) {
+    await unlink(temp).catch(() => {});
+    throw err;
+  }
+}
+
+async function writeAtomic(path, value) {
+  await writeTextAtomic(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export async function installProviderPresetManifest(
+  sourcePath,
+  { home = homedir(), coreVersion } = {},
+) {
+  if (!sourcePath) throw new Error('preset install requires --file=<manifest>.');
+  const source = await loadProviderPresetManifest({ path: sourcePath, home, coreVersion });
+  const paths = providerPresetPaths(home);
+  const directory = dirname(paths.user);
+  if (await fileExists(directory)) {
+    const info = await lstat(directory);
+    if (!info.isDirectory() || info.isSymbolicLink()) {
+      throw new Error(`Refusing to use non-regular provider preset directory: ${directory}`);
+    }
+  } else {
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+  }
+  await assertWritableTarget(paths.user);
+  await assertWritableTarget(paths.backup);
+  let invalidBackupPath = null;
+  if (await fileExists(paths.user)) {
+    try {
+      const current = await readManifest(paths.user, coreVersion);
+      await writeAtomic(paths.backup, current);
+    } catch {
+      invalidBackupPath = join(dirname(paths.user), `provider-presets.invalid-${Date.now()}.json`);
+      await writeTextAtomic(invalidBackupPath, await readFile(paths.user, 'utf8'));
+    }
+  }
+  await writeAtomic(paths.user, source.manifest);
+  return {
+    manifest: source.manifest,
+    path: paths.user,
+    backupPath: paths.backup,
+    invalidBackupPath,
+  };
+}
+
+export async function rollbackProviderPresetManifest({ home = homedir(), coreVersion } = {}) {
+  const paths = providerPresetPaths(home);
+  if (!(await fileExists(paths.backup))) {
+    throw new Error(`No previous provider preset is available at ${paths.backup}.`);
+  }
+  return installProviderPresetManifest(paths.backup, { home, coreVersion });
+}

package/src/providers.js

@@ -0,0 +1,306 @@
+export const PROVIDER_TYPES = Object.freeze([
+  'openai',
+  'openrouter',
+  'deepseek',
+  'minimax',
+  'ollama',
+  'custom',
+]);
+const PROVIDER_TYPE_SET = new Set(PROVIDER_TYPES);
+
+export function isProviderType(value) {
+  return typeof value === 'string' && PROVIDER_TYPE_SET.has(value.toLowerCase());
+}
+
+function endpoint(apiUrl) {
+  try {
+    return new URL(apiUrl);
+  } catch {
+    return null;
+  }
+}
+
+export function detectProviderType(apiUrl, explicitType = '') {
+  if (explicitType) {
+    const normalized = explicitType.toLowerCase();
+    if (/^extension:[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(normalized)) return normalized;
+    if (!PROVIDER_TYPE_SET.has(normalized)) {
+      throw new Error(
+        `Unknown providerType "${explicitType}". Use one of: ${PROVIDER_TYPES.join(', ')}.`,
+      );
+    }
+    return normalized;
+  }
+
+  const url = endpoint(apiUrl);
+  const host = url?.hostname.toLowerCase() || '';
+  if (host === 'api.openai.com') return 'openai';
+  if (host === 'openrouter.ai' || host.endsWith('.openrouter.ai')) return 'openrouter';
+  if (host === 'api.deepseek.com' || host.endsWith('.deepseek.com')) return 'deepseek';
+  if (host.includes('minimax')) return 'minimax';
+  if (
+    /\/api\/(?:chat|generate)\/?$/i.test(url?.pathname || '') &&
+    (host === 'localhost' || host.startsWith('127.') || host === '[::1]')
+  ) {
+    return 'ollama';
+  }
+  return 'custom';
+}
+
+export function isOpenAIReasoningModel(modelId) {
+  const id = (modelId || '').split('/').pop();
+  return /^(?:o\d|gpt-5)/i.test(id);
+}
+
+function openAIReasoningEfforts(modelId) {
+  const id = (modelId || '').split('/').pop().toLowerCase();
+  if (/^gpt-5\.6(?:-|$)/.test(id)) return ['none', 'low', 'medium', 'high', 'xhigh', 'max'];
+  if (/^gpt-5\.(?:2|3|4|5)(?:-|$)/.test(id)) {
+    return ['none', 'low', 'medium', 'high', 'xhigh'];
+  }
+  if (/^gpt-5\.1(?:-|$)/.test(id)) return ['none', 'low', 'medium', 'high'];
+  if (/^gpt-5(?:-|$)/.test(id) || /^o\d(?:-|$)/.test(id)) return ['low', 'medium', 'high'];
+  return null;
+}
+
+function openAIReasoningEffort(modelId, enabled, effort) {
+  const requested = enabled ? effort : 'none';
+  const supported = openAIReasoningEfforts(modelId);
+  if (!supported || supported.includes(requested)) return requested;
+
+  const action = enabled ? `reasoning effort "${requested}"` : 'disabling reasoning';
+  throw new Error(
+    `OpenAI model "${modelId}" does not support ${action}. ` +
+      `Supported reasoning efforts: ${supported.join(', ')}.`,
+  );
+}
+
+function mergeRequestExtensions(payload, extensions) {
+  if (!extensions || typeof extensions !== 'object' || Array.isArray(extensions)) return;
+  const { model: _model, messages: _messages, ...safe } = extensions;
+  Object.assign(payload, safe);
+}
+
+function reasoningText(value) {
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) return value.map(reasoningText).filter(Boolean).join('\n');
+  if (value && typeof value === 'object') {
+    return reasoningText(value.text ?? value.summary ?? value.content);
+  }
+  return '';
+}
+
+function messageText(value) {
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) {
+    return value
+      .map((part) => part?.text ?? part?.content ?? '')
+      .filter(Boolean)
+      .join('');
+  }
+  return value?.text ?? value?.content ?? '';
+}
+
+function firstNumber(...values) {
+  return values.find((value) => typeof value === 'number' && Number.isFinite(value));
+}
+
+export function normalizeUsage(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+
+  const inputTokens = firstNumber(
+    usage.inputTokens,
+    usage.prompt_tokens,
+    usage.input_tokens,
+    usage.prompt_eval_count,
+  );
+  const outputTokens = firstNumber(
+    usage.outputTokens,
+    usage.completion_tokens,
+    usage.output_tokens,
+    usage.eval_count,
+  );
+  const totalTokens = firstNumber(
+    usage.totalTokens,
+    usage.total_tokens,
+    inputTokens !== undefined && outputTokens !== undefined
+      ? inputTokens + outputTokens
+      : undefined,
+  );
+
+  const normalized = {};
+  if (inputTokens !== undefined) normalized.inputTokens = inputTokens;
+  if (outputTokens !== undefined) normalized.outputTokens = outputTokens;
+  if (totalTokens !== undefined) normalized.totalTokens = totalTokens;
+  return Object.keys(normalized).length ? normalized : null;
+}
+
+function normalizeResponse(provider, data) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    throw new Error('Provider returned an invalid response: expected a JSON object.');
+  }
+
+  const choice = data?.choices?.[0];
+  const message = choice?.message ?? data.message;
+  const content =
+    messageText(message?.content) ||
+    messageText(data?.content?.[0]?.text) ||
+    messageText(data.response);
+  const reasoning =
+    reasoningText(message?.reasoning_content) ||
+    reasoningText(message?.reasoning) ||
+    reasoningText(message?.reasoning_details) ||
+    reasoningText(message?.thinking) ||
+    reasoningText(data.thinking) ||
+    null;
+  const finishReason =
+    choice?.finish_reason ?? data.stop_reason ?? data.done_reason ?? (data.done ? 'stop' : null);
+  const usageSource =
+    data.usage ||
+    (data.prompt_eval_count !== undefined || data.eval_count !== undefined
+      ? {
+          prompt_eval_count: data.prompt_eval_count,
+          eval_count: data.eval_count,
+        }
+      : null);
+
+  return {
+    provider,
+    model: data.model || null,
+    content,
+    reasoning,
+    usage: normalizeUsage(usageSource),
+    finishReason,
+    raw: data,
+  };
+}
+
+function applyReasoning(payload, provider, modelId, reasoning, nativeOllama) {
+  const mode = reasoning?.mode || 'auto';
+  if (mode === 'auto') return;
+
+  const enabled = mode === 'on';
+  const effort = reasoning?.effort || 'medium';
+
+  if (provider === 'openai') {
+    if (!isOpenAIReasoningModel(modelId)) return;
+    payload.reasoning_effort = openAIReasoningEffort(modelId, enabled, effort);
+    return;
+  }
+
+  if (provider === 'deepseek') {
+    delete payload.enable_thinking;
+    payload.thinking = { type: enabled ? 'enabled' : 'disabled' };
+    if (enabled) {
+      payload.reasoning_effort = effort === 'low' || effort === 'max' ? effort : 'high';
+      delete payload.temperature;
+    } else {
+      delete payload.reasoning_effort;
+    }
+    return;
+  }
+
+  if (provider === 'openrouter') {
+    payload.reasoning = { effort: enabled ? effort : 'none' };
+    return;
+  }
+
+  if (provider === 'minimax') {
+    payload.reasoning_split = true;
+    if (enabled) {
+      delete payload.thinking;
+      delete payload.enable_thinking;
+    } else {
+      delete payload.enable_thinking;
+      payload.thinking = { type: 'disabled' };
+    }
+    return;
+  }
+
+  if (provider === 'ollama' && nativeOllama) {
+    payload.think = enabled;
+    return;
+  }
+
+  const customBody = enabled ? reasoning?.enabledBody : reasoning?.disabledBody;
+  if (customBody !== undefined) mergeRequestExtensions(payload, customBody);
+}
+
+function reasoningForFollowUp(provider, modelId, reasoning) {
+  if (reasoning?.mode !== 'on') return reasoning;
+  if (['deepseek', 'openrouter', 'minimax', 'ollama'].includes(provider)) {
+    return { ...reasoning, mode: 'off' };
+  }
+  if (provider === 'openai') {
+    const supported = openAIReasoningEfforts(modelId);
+    if (supported?.includes('none')) return { ...reasoning, mode: 'off' };
+  }
+  if (reasoning.disabledBody !== undefined) return { ...reasoning, mode: 'off' };
+  return reasoning;
+}
+
+export function getProviderAdapter({ apiUrl, providerType = '', modelId = '' }) {
+  const provider = detectProviderType(apiUrl, providerType);
+  const url = endpoint(apiUrl);
+  const nativeOllama =
+    provider === 'ollama' && /\/api\/(?:chat|generate)\/?$/i.test(url?.pathname || '');
+  const openAIReasoning = provider === 'openai' && isOpenAIReasoningModel(modelId);
+
+  const capabilities = Object.freeze({
+    streaming: !nativeOllama,
+    reasoning:
+      provider === 'custom'
+        ? 'configurable'
+        : provider === 'openai' && !openAIReasoning
+          ? 'model-dependent'
+          : 'native',
+    tokenBudget: nativeOllama
+      ? 'options.num_predict'
+      : openAIReasoning
+        ? 'max_completion_tokens'
+        : 'max_tokens',
+    usage: true,
+    finishReason: true,
+  });
+
+  return Object.freeze({
+    id: provider,
+    capabilities,
+    headers: provider === 'openrouter' ? { 'X-Title': 'aicommit' } : {},
+    buildRequest({ messages, temperature, maxTokens, extraBody = {}, reasoning, streaming }) {
+      const payload = { model: modelId, messages };
+      if (nativeOllama) {
+        // Ollama's native stream is newline-delimited JSON rather than SSE.
+        // Use its complete JSON response until the request layer exposes an
+        // NDJSON consumer; reasoning still reaches the callback once parsed.
+        payload.stream = false;
+        payload.options = { temperature, num_predict: maxTokens };
+      } else if (openAIReasoning) {
+        payload.max_completion_tokens = maxTokens;
+      } else {
+        payload.temperature = temperature;
+        payload.max_tokens = maxTokens;
+      }
+
+      mergeRequestExtensions(payload, extraBody);
+      applyReasoning(payload, provider, modelId, reasoning, nativeOllama);
+      if (streaming && !nativeOllama) {
+        payload.stream = true;
+        if (provider === 'openai') {
+          const current = payload.stream_options;
+          payload.stream_options = {
+            ...(current && typeof current === 'object' && !Array.isArray(current) ? current : {}),
+            include_usage: true,
+          };
+        }
+      }
+      return payload;
+    },
+    normalizeResponse(data) {
+      return normalizeResponse(provider, data);
+    },
+    reasoningForFollowUp(reasoning) {
+      return reasoningForFollowUp(provider, modelId, reasoning);
+    },
+  });
+}