agent-accelerator 0.1.0

package/src/ai-sdk/model-provider.ts

@@ -0,0 +1,303 @@
+import type {
+  Provider,
+  ProviderId,
+  ModelSpec,
+  ProviderRequestOptions,
+  ProviderGenerateResult,
+} from "../types/model.ts";
+import type { ProviderContext } from "../types/message.ts";
+import type { AssistantMessageEventStream } from "../streaming/event-stream.ts";
+import type { LanguageModelV4 } from "@ai-sdk/provider";
+import { getAiSdkModel } from "./provider.ts";
+import { executeAiSdkGenerate, executeAiSdkStream } from "./executor.ts";
+import { countTokens } from "../tokens/counter.ts";
+import { getModelFromCatalog, getModelsForProvider } from "../models/catalog.ts";
+import { getApiKey, getEnv } from "../utils/env.ts";
+
+/**
+ * Permissive placeholder so custom endpoints never fail preflight:
+ * allows every ThinkingLevel (none -> xhigh + dynamic).
+ * @example `const spec = createGenericModelSpec("groq", "llama-3.3-70b-versatile");`
+ */
+export function createGenericModelSpec(provider: string, modelId: string): ModelSpec {
+  const clean = modelId.includes("/") ? modelId.split("/").slice(1).join("/") : modelId;
+  return {
+    id: clean,
+    provider: provider as ProviderId,
+    name: clean,
+    contextWindow: 128000,
+    maxOutputTokens: 8192,
+    limit: { context: 128000, output: 8192 },
+    cost: {},
+    modalities: { input: ["text"], output: ["text"] },
+    reasoning: true,
+    reasoning_options: [
+      { type: "toggle" },
+      { type: "effort", values: ["minimal", "low", "medium", "high", "xhigh"] },
+      { type: "budget_tokens", min: 0, max: 128000 },
+    ],
+    tool_call: true,
+    capabilities: {
+      supportsThinking: true,
+      supportsThinkingLevel: true,
+      supportsThinkingBudget: true,
+      supportsReasoningToggle: true,
+      supportsReasoningEffort: true,
+      supportsImplicitCaching: true,
+      supportsExplicitCaching: false,
+      supportsLongCacheRetention: false,
+      supportsParallelToolCalls: true,
+      supportsStreaming: true,
+      modalities: ["text"],
+    },
+    pricing: {},
+  };
+}
+
+/**
+ * Base provider class powered purely by Vercel AI SDK.
+ */
+export class AiSdkBaseProvider implements Provider {
+  readonly id: ProviderId;
+  readonly name: string;
+  readonly models: ModelSpec[] = [];
+
+  /**
+   * Creates a provider adapter around the Vercel AI SDK.
+   *
+   * @param id Stable provider prefix used in `provider/model` strings.
+   * @param name Human-readable provider label.
+   * @param models Optional catalog entries exposed by this provider.
+   */
+  constructor(id: ProviderId, name: string, models: ModelSpec[] = []) {
+    this.id = id;
+    this.name = name;
+    this.models = models;
+  }
+
+  getModel(modelId: string): ModelSpec | undefined {
+    const clean = modelId.includes("/") ? modelId.split("/").slice(1).join("/") : modelId;
+    const fromCatalog =
+      getModelFromCatalog(this.id, modelId) ||
+      getModelFromCatalog(this.id, clean) ||
+      this.models.find((m) => m.id === modelId || m.id === clean);
+
+    if (fromCatalog) return fromCatalog;
+    return createGenericModelSpec(this.id, clean);
+  }
+
+  protected cleanModelId(model: string | ModelSpec): string {
+    const rawId = typeof model === "string" ? model : model.id;
+    return rawId.replace(new RegExp(`^(${this.id}|models?)/`, "i"), "");
+  }
+
+  toAiSdkModel(modelId: string, options?: ProviderRequestOptions): LanguageModelV4 {
+    const clean = this.cleanModelId(modelId);
+    return getAiSdkModel(this.id, clean, {
+      apiKey: options?.apiKey,
+      baseUrl: options?.baseUrl,
+      headers: options?.headers,
+      env: options?.env,
+    });
+  }
+
+  async generate(
+    model: string | ModelSpec,
+    context: ProviderContext,
+    options?: ProviderRequestOptions
+  ): Promise<ProviderGenerateResult> {
+    const rawId = typeof model === "string" ? model : model.id;
+    const clean = this.cleanModelId(rawId);
+    const aiModel = this.toAiSdkModel(clean, options);
+    return executeAiSdkGenerate(aiModel, this.id, clean, context, options);
+  }
+
+  stream(
+    model: string | ModelSpec,
+    context: ProviderContext,
+    options?: ProviderRequestOptions
+  ): AssistantMessageEventStream {
+    const rawId = typeof model === "string" ? model : model.id;
+    const clean = this.cleanModelId(rawId);
+    const aiModel = this.toAiSdkModel(clean, options);
+    return executeAiSdkStream(aiModel, this.id, clean, context, options);
+  }
+
+  async countTokens(
+    _model: string | ModelSpec,
+    context: ProviderContext
+  ): Promise<number> {
+    return countTokens(context);
+  }
+}
+
+/**
+ * Pure Vercel AI SDK Google provider.
+ */
+export class GoogleAiSdkProvider extends AiSdkBaseProvider {
+  /** Creates a Google AI Studio adapter with the supported Gemini catalog. */
+  constructor() {
+    const filtered = getModelsForProvider("google").filter(
+      (m) => !m.id.toLowerCase().includes("gemini-2") && !m.id.toLowerCase().includes("gemini-1")
+    );
+    super("google", "Google AI Studio", filtered);
+  }
+
+  protected override cleanModelId(model: string | ModelSpec): string {
+    const rawId = typeof model === "string" ? model : model.id;
+    const clean = rawId.replace(/^(google\/|models\/)/, "");
+    if (clean.toLowerCase().includes("gemini-2") || clean.toLowerCase().includes("gemini-1")) {
+      throw new Error(
+        `Gemini 2.x and 1.x models are not supported by the Google Provider. ` +
+        `Only Gemini 3.x series models are supported (e.g. 'gemini-3.5-flash-lite', 'gemini-3.7-flash').`
+      );
+    }
+    return clean;
+  }
+
+}
+
+/**
+ * Pure Vercel AI SDK OpenAI provider.
+ */
+export class OpenAiAiSdkProvider extends AiSdkBaseProvider {
+  /** Creates an OpenAI adapter backed by the AI SDK and the OpenAI catalog. */
+  constructor() {
+    super("openai", "OpenAI", getModelsForProvider("openai"));
+  }
+
+  protected override cleanModelId(model: string | ModelSpec): string {
+    const rawId = typeof model === "string" ? model : model.id;
+    return rawId.replace(/^(openai|models?)\//, "");
+  }
+}
+
+/**
+ * Pure Vercel AI SDK OpenCode provider.
+ */
+export class OpenCodeAiSdkProvider extends AiSdkBaseProvider {
+  /** Creates an OpenCode adapter backed by the AI SDK and OpenCode catalog. */
+  constructor() {
+    super("opencode", "OpenCode", getModelsForProvider("opencode"));
+  }
+
+  protected override cleanModelId(model: string | ModelSpec): string {
+    const rawId = typeof model === "string" ? model : model.id;
+    return rawId.replace(/^(opencode-go\/|opencode\/)/, "");
+  }
+}
+
+/**
+ * Pure Vercel AI SDK OpenRouter provider.
+ */
+export class OpenRouterAiSdkProvider extends AiSdkBaseProvider {
+  /** Creates an OpenRouter adapter backed by the AI SDK and OpenRouter catalog. */
+  constructor() {
+    super("openrouter", "OpenRouter", getModelsForProvider("openrouter"));
+  }
+
+  protected override cleanModelId(model: string | ModelSpec): string {
+    const rawId = typeof model === "string" ? model : model.id;
+    return rawId.replace(/^openrouter\//, "");
+  }
+}
+
+export interface CustomProviderOptions {
+  /** Human label, defaults to `${id} (OpenAI-compatible)` */
+  name?: string;
+  /** Static baseUrl — overrides env. Env `{PREFIX}_BASE_URL` still wins at runtime if set. */
+  baseUrl?: string;
+  /** Static apiKey — overrides env. Explicit per-call `apiKey` still wins. */
+  apiKey?: string;
+  /** Default baseUrl when no env is set. Defaults to OpenAI cloud. */
+  defaultBaseUrl?: string;
+}
+
+/**
+ * Pure Vercel AI SDK Custom/OpenAI-compatible provider.
+ */
+export class CustomAiSdkProvider extends AiSdkBaseProvider {
+  private readonly prefix: string;
+  private readonly configuredBaseUrl?: string;
+  private readonly configuredApiKey?: string;
+
+  /**
+   * Creates an OpenAI-compatible provider for any endpoint prefix.
+   *
+   * @param prefix Prefix used in model strings and environment variables,
+   * such as `groq` for `groq/llama-3.3-70b`.
+   * @param opts Optional endpoint, key, and display-name overrides.
+   *
+   * @example
+   * ```ts
+   * const groq = new CustomAiSdkProvider("groq", {
+   *   baseUrl: "https://api.groq.com/openai/v1",
+   *   apiKey: process.env.GROQ_API_KEY,
+   * });
+   * ```
+   */
+  constructor(prefix: string, opts?: CustomProviderOptions) {
+    const norm = prefix.trim().toLowerCase().replace(/\/.*$/, "");
+    super(norm as ProviderId, opts?.name ?? `${norm} (OpenAI-compatible)`);
+    this.prefix = norm;
+    this.configuredBaseUrl = opts?.baseUrl ?? opts?.defaultBaseUrl;
+    this.configuredApiKey = opts?.apiKey;
+  }
+
+  override toAiSdkModel(modelId: string, options?: ProviderRequestOptions): LanguageModelV4 {
+    const clean = this.cleanModelId(modelId);
+    const envPrefix = this.prefix.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+
+    const apiKey =
+      options?.apiKey ||
+      this.configuredApiKey ||
+      options?.env?.[`${envPrefix}_API_KEY`] ||
+      options?.env?.[`${envPrefix}_BASE_API_KEY`] ||
+      getEnv(`${envPrefix}_API_KEY`) ||
+      getEnv(`${envPrefix}_BASE_API_KEY`) ||
+      getEnv("OPENAI_BASE_API_KEY") ||
+      getEnv("OPENAI_API_KEY") ||
+      getApiKey(this.prefix, undefined, options?.env);
+
+    const baseUrl =
+      options?.baseUrl ||
+      this.configuredBaseUrl ||
+      options?.env?.[`${envPrefix}_BASE_URL`] ||
+      options?.env?.[`${envPrefix}_BASEURL`] ||
+      getEnv(`${envPrefix}_BASE_URL`) ||
+      getEnv(`${envPrefix}_BASEURL`) ||
+      getEnv("OPENAI_BASE_URL") ||
+      "https://api.openai.com/v1";
+
+    return getAiSdkModel(this.prefix, clean, {
+      apiKey,
+      baseUrl,
+      headers: options?.headers,
+      env: options?.env,
+    });
+  }
+}
+
+// Legacy class aliases so instanceof checks in tests & user code succeed seamlessly
+export {
+  GoogleAiSdkProvider as GoogleAIStudioProvider,
+  OpenAiAiSdkProvider as OpenAIProvider,
+  OpenCodeAiSdkProvider as OpenCodeProvider,
+  OpenRouterAiSdkProvider as OpenRouterProvider,
+  CustomAiSdkProvider as OpenAICompatibleProvider,
+};
+
+/**
+ * Creates a custom OpenAI-compatible provider backed by the Vercel AI SDK.
+ * @example `const provider = createOpenAICompatibleProvider("groq", { baseUrl: "https://api.groq.com/openai/v1" });`
+ */
+export function createOpenAICompatibleProvider(
+  prefix: string,
+  opts?: CustomProviderOptions
+): CustomAiSdkProvider {
+  return new CustomAiSdkProvider(prefix, opts);
+}
+/** Backward-compatible alias for {@link createOpenAICompatibleProvider}. @example `createCustomProvider("ollama")` */
+export const createCustomProvider = createOpenAICompatibleProvider;
+/** Backward-compatible class alias for {@link CustomAiSdkProvider}. @example `new CustomProvider("ollama")` */
+export const CustomProvider = CustomAiSdkProvider;

package/src/ai-sdk/options.ts

@@ -0,0 +1,306 @@
+import type { ThinkingConfig, CacheConfig, ServiceTier } from "../types/core.ts";
+import type { ProviderRequestOptions } from "../types/model.ts";
+import { buildSessionHeaders } from "../utils/headers.ts";
+import { toConciseProviderError } from "./errors.ts";
+import { getPromptCacheRetention } from "../utils/cache.ts";
+
+export type AiSdkReasoning = "provider-default" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+
+export type AiSdkToolChoice =
+  | { type: "auto" }
+  | { type: "none" }
+  | { type: "required" }
+  | { type: "tool"; toolName: string };
+
+export interface AiSdkCallOptions {
+  reasoning?: AiSdkReasoning;
+  toolChoice?: AiSdkToolChoice;
+  providerOptions?: Record<string, Record<string, unknown>>;
+  headers?: Record<string, string>;
+  abortSignal?: AbortSignal;
+}
+
+/**
+ * Maps Agent Accelerator thinkingLevel to Vercel AI SDK reasoning.
+ */
+export function mapThinkingToReasoning(thinking?: ThinkingConfig): AiSdkReasoning | undefined {
+  if (!thinking) return undefined;
+  if (thinking.enabled === false) return "none";
+  const level = thinking.level;
+  if (!level) return undefined;
+  if (level === "none") return "none";
+  if (level === "dynamic") return "provider-default";
+  if (level === "minimal" || level === "low" || level === "medium" || level === "high" || level === "xhigh") {
+    return level;
+  }
+  return "provider-default";
+}
+
+/**
+ * Resolves per-run thinking override without mutating agent config.
+ */
+export function resolveEffectiveThinking(
+  base?: ThinkingConfig,
+  overrideLevel?: string
+): ThinkingConfig | undefined {
+  if (!overrideLevel) return base;
+  if (overrideLevel === "none") return { enabled: false, level: "none", budgetTokens: 0 };
+  if (overrideLevel === "dynamic") return { enabled: true, level: "dynamic", budgetTokens: -1 };
+  return { enabled: true, level: overrideLevel as ThinkingConfig["level"] };
+}
+
+/**
+ * Maps Agent Accelerator toolChoice to Vercel AI SDK toolChoice.
+ */
+export function mapToolChoice(
+  choice?: ProviderRequestOptions["toolChoice"]
+): AiSdkToolChoice | undefined {
+  if (!choice) return undefined;
+  if (typeof choice === "string") {
+    if (choice === "auto") return { type: "auto" };
+    if (choice === "none") return { type: "none" };
+    if (choice === "required") return { type: "required" };
+    return undefined;
+  }
+  if (choice.type === "function") {
+    const name = choice.function?.name;
+    if (name) return { type: "tool", toolName: name };
+    return { type: "required" };
+  }
+  return undefined;
+}
+
+function mergeProviderOptions(
+  target: Record<string, Record<string, unknown>>,
+  source: Record<string, Record<string, unknown>>
+): void {
+  for (const [key, value] of Object.entries(source)) {
+    target[key] = { ...(target[key] ?? {}), ...value };
+  }
+}
+
+/**
+ * Maps thinking details to provider-specific providerOptions.
+ */
+export function mapThinkingToProviderOptions(
+  providerId: string,
+  thinking?: ThinkingConfig
+): Record<string, Record<string, unknown>> {
+  if (!thinking || thinking.enabled === false) return {};
+  const level = thinking.level;
+  if (!level || level === "none" || level === "dynamic") return {};
+  const norm = providerId.toLowerCase().trim();
+
+  if (norm === "google" || norm === "gemini") {
+    const googleLevel = level === "xhigh" ? "high" : level === "minimal" ? "minimal" : level;
+    if (googleLevel === "minimal" || googleLevel === "low" || googleLevel === "medium" || googleLevel === "high") {
+      return {
+        google: {
+          thinkingConfig: {
+            thinkingLevel: googleLevel,
+            includeThoughts: thinking.includeThoughts ?? true,
+          },
+        },
+      };
+    }
+    return {};
+  }
+
+  if (norm === "openai") {
+    if (level === "minimal" || level === "low" || level === "medium" || level === "high" || level === "xhigh") {
+      return { openai: { reasoningEffort: level } };
+    }
+    return {};
+  }
+
+  return {};
+}
+
+/**
+ * Providers known to tolerate OpenAI-style prompt-cache/service-tier body
+ * params. Strict OpenAI-compatible endpoints (groq, ollama, …) 400 on unknown
+ * properties like `promptCacheKey`, so anything off this list gets session
+ * affinity via headers only (always harmless).
+ */
+const PROMPT_CACHE_KEY_PROVIDERS = new Set([
+  "openai",
+  "openrouter",
+  "opencode",
+  "opencode-go",
+]);
+
+/**
+ * Maps serviceTier to provider-specific providerOptions.
+ */
+export function mapServiceTierToProviderOptions(
+  providerId: string,
+  tier?: ServiceTier
+): Record<string, Record<string, unknown>> {
+  if (!tier) return {};
+  const norm = providerId.toLowerCase().trim();
+  if (norm === "google" || norm === "gemini") {
+    return { google: { serviceTier: tier } };
+  }
+  if (norm === "openai") {
+    return { openai: { serviceTier: tier } };
+  }
+  if (!PROMPT_CACHE_KEY_PROVIDERS.has(norm)) return {};
+  return {
+    openai: { serviceTier: tier },
+    [norm]: { serviceTier: tier },
+  };
+}
+
+/**
+ * Maps cache config to provider-specific providerOptions.
+ * retention short|medium|long maps to OpenCode prompt_cache_retention;
+ * session affinity maps to OpenAI promptCacheKey; explicit Google
+ * cachedContentId maps to google.cachedContent. Implicit prefix caching
+ * itself needs no flag beyond a stable prompt plus session headers.
+ */
+export function mapCacheToProviderOptions(
+  providerId: string,
+  cache?: CacheConfig,
+  sessionId?: string
+): Record<string, Record<string, unknown>> {
+  const out: Record<string, Record<string, unknown>> = {};
+  if (!cache && !sessionId) return out;
+  const norm = providerId.toLowerCase().trim();
+  const cachedContentId = cache?.cachedContentId;
+  if (cachedContentId && (norm === "google" || norm === "gemini")) {
+    mergeProviderOptions(out, { google: { cachedContent: cachedContentId } });
+  }
+  const affinity = sessionId || cache?.sessionId;
+  if (affinity && PROMPT_CACHE_KEY_PROVIDERS.has(norm)) {
+    mergeProviderOptions(out, { openai: { promptCacheKey: affinity } });
+    if (norm !== "openai") {
+      mergeProviderOptions(out, { [norm]: { promptCacheKey: affinity } });
+    }
+  }
+  const retention = cache?.retention;
+  if (retention && retention !== "implicit") {
+    const promptCacheRetention = getPromptCacheRetention(retention, true);
+    if (promptCacheRetention && (norm === "opencode" || norm === "opencode-go")) {
+      mergeProviderOptions(out, {
+        opencode: { prompt_cache_retention: promptCacheRetention },
+        openai: { promptCacheRetention: promptCacheRetention },
+      });
+    }
+  }
+  return out;
+}
+
+/**
+ * Builds Vercel AI SDK call options from Agent Accelerator request options.
+ */
+export function buildAiSdkCallOptions(
+  providerId: string,
+  options?: ProviderRequestOptions
+): AiSdkCallOptions {
+  const reasoning = mapThinkingToReasoning(options?.thinking);
+  const toolChoice = mapToolChoice(options?.toolChoice);
+  const providerOptions: Record<string, Record<string, unknown>> = {};
+  mergeProviderOptions(providerOptions, mapThinkingToProviderOptions(providerId, options?.thinking));
+  mergeProviderOptions(providerOptions, mapServiceTierToProviderOptions(providerId, options?.serviceTier));
+  mergeProviderOptions(providerOptions, mapCacheToProviderOptions(providerId, options?.cache, options?.sessionId));
+
+  const headers: Record<string, string> = buildSessionHeaders(
+    providerId,
+    options?.cache,
+    options?.headers,
+    options?.sessionId
+  );
+
+  const result: AiSdkCallOptions = {};
+  if (reasoning !== undefined) result.reasoning = reasoning;
+  if (toolChoice !== undefined) result.toolChoice = toolChoice;
+  if (Object.keys(providerOptions).length > 0) result.providerOptions = providerOptions;
+  if (Object.keys(headers).length > 0) result.headers = headers;
+  if (options?.signal) result.abortSignal = options.signal;
+  return result;
+}
+
+/**
+ * Checks whether a provider error is transient and safe to retry.
+ */
+export function isAbortError(error: unknown): boolean {
+  const err = error as { name?: unknown; message?: unknown } | null;
+  if (!err || typeof err !== "object") return false;
+  if ((err as { name?: unknown }).name === "AbortError") return true;
+  return /abort|cancell?ed/i.test(String((err as { message?: unknown }).message ?? error));
+}
+
+export function isTransientAiSdkError(error: unknown): boolean {
+  if (!error) return false;
+  if (isAbortError(error)) return false;
+  const err = error as Record<string, unknown>;
+  if (err["transient"] === true) return true;
+  const status = Number(
+    (err["status"] as number | undefined) ??
+      (err["statusCode"] as number | undefined) ??
+      ((err["response"] as Record<string, unknown> | undefined)?.["status"] as number | undefined) ??
+      ((err["lastError"] as Record<string, unknown> | undefined)?.["status"] as number | undefined) ??
+      NaN
+  );
+  if ([408, 425, 429, 500, 502, 503, 504].includes(status)) return true;
+  const code = String((err["code"] as string | undefined) ?? "").toUpperCase();
+  if (["ECONNRESET", "ECONNREFUSED", "EAI_AGAIN", "UND_ERR_CONNECT_TIMEOUT", "EPIPE", "ETIMEDOUT"].includes(code)) {
+    return true;
+  }
+  return /(?:timed?\s?out|temporar(?:y|ily)|connection reset|connection refused|service unavailable|rate limit|\b5\d\d\b|overloaded)/i.test(
+    String((err["message"] as string | undefined) ?? error)
+  );
+}
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(Object.assign(new Error("Operation aborted"), { name: "AbortError" }));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+    // Tag as AbortError so callers never retry it
+    // (name assigned at reject site)
+  });
+}
+
+/**
+ * Runs a Vercel AI SDK call with bounded retries for transient failures.
+ */
+export async function withAiSdkRetries<T>(
+  fn: () => Promise<T> | PromiseLike<T>,
+  options?: {
+    maxRetries?: number;
+    maxRetryDelayMs?: number;
+    signal?: AbortSignal;
+    label?: { providerId?: string; modelId?: string };
+  }
+): Promise<T> {
+  const maxRetries = options?.maxRetries ?? 2;
+  const maxDelay = options?.maxRetryDelayMs ?? 5000;
+  const fail = (error: unknown): never => {
+    if (options?.label?.providerId && options?.label?.modelId) {
+      throw toConciseProviderError(error, options.label.providerId, options.label.modelId);
+    }
+    throw error;
+  };
+  let attempt = 0;
+  for (;;) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (options?.signal?.aborted || isAbortError(error)) throw error;
+      if (attempt >= maxRetries || !isTransientAiSdkError(error)) fail(error);
+      const delay = Math.min(maxDelay, 250 * 2 ** attempt + Math.random() * 100);
+      attempt += 1;
+      await sleep(delay, options?.signal);
+    }
+  }
+}