agent-accelerator 0.1.0 → 0.2.0

package/src/ai-sdk/provider.ts

@@ -1,415 +0,0 @@
-import { createGoogleGenerativeAI, type GoogleGenerativeAIProvider } from "@ai-sdk/google";
-import { createOpenAI, type OpenAIProvider as VercelOpenAIProvider } from "@ai-sdk/openai";
-import { createOpenAICompatible, type OpenAICompatibleProvider as VercelOpenAICompatibleProvider } from "@ai-sdk/openai-compatible";
-import type { LanguageModelV4 } from "@ai-sdk/provider";
-import { getApiKey, getEnv } from "../utils/env.ts";
-
-export interface AiSdkModelOptions {
-  apiKey?: string;
-  baseUrl?: string;
-  headers?: Record<string, string>;
-  fetch?: typeof fetch;
-  env?: Record<string, string>;
-}
-
-export type AnyAiSdkProvider =
-  | GoogleGenerativeAIProvider
-  | VercelOpenAIProvider
-  | VercelOpenAICompatibleProvider;
-
-export const streamThoughtSignatures = new Map<string, string>();
-
-function isBrowserFetchRuntime(): boolean {
-  try {
-    return typeof (globalThis as any).window !== "undefined" && typeof (globalThis as any).window.document !== "undefined";
-  } catch {
-    return false;
-  }
-}
-
-function requestUrlOf(input: any): string {
-  try {
-    if (typeof input === "string") return input;
-    if (input instanceof URL) return input.href;
-    if (input && typeof input.url === "string") return input.url;
-  } catch {}
-  return "";
-}
-
-function createAiSdkFetch(customFetch?: typeof fetch): typeof fetch {
-  const fetchFn = async (input: any, init?: any) => {
-    const baseFetch = customFetch || globalThis.fetch;
-    if (init && init.headers) {
-      const h: any = init.headers;
-      if (h instanceof Headers) {
-        h.delete("x-multimodal-user-content");
-        h.delete("x-thought-signature-map");
-        h.delete("x-cached-content-id");
-        if (isBrowserFetchRuntime()) {
-          for (const k of ["user-agent", "x-session-id", "x-client-request-id", "session_id", "x-opencode-session", "x-opencode-client", "x-goog-api-client"]) {
-            try { h.delete(k); } catch {}
-          }
-        }
-      } else if (typeof h === "object" && !Array.isArray(h)) {
-        if (h.authorization && !h.Authorization) {
-          const token = h.authorization;
-          delete h.authorization;
-          h.Authorization = token;
-          Object.defineProperty(h, "authorization", {
-            get() {
-              return this.Authorization;
-            },
-            set(v) {
-              this.Authorization = v;
-            },
-            enumerable: false,
-            configurable: true,
-          });
-        }
-
-        // Drop legacy multimodal header (Vercel serializes image/file parts natively)
-        if ((h as any)["x-multimodal-user-content"]) delete (h as any)["x-multimodal-user-content"];
-
-        // Browser: drop SDK-internal / session headers that force a CORS
-        // preflight the provider never allow-lists (surfaces as bare
-        // `TypeError: Failed to fetch`). Session affinity still flows via
-        // providerOptions.promptCacheKey, never via headers.
-        if (isBrowserFetchRuntime()) {
-          for (const k of ["User-Agent", "user-agent", "x-session-id", "x-client-request-id", "session_id", "x-opencode-session", "x-opencode-client", "x-goog-api-client"]) {
-            try { delete (h as any)[k]; } catch {}
-          }
-        }
-
-        // Replay Google thought_signature on OpenAI-compat Turn 2
-        const sigMapHeader = h["x-thought-signature-map"];
-        if (sigMapHeader) {
-          delete h["x-thought-signature-map"];
-          if (init.body && typeof init.body === "string") {
-            try {
-              const sigMap = JSON.parse(sigMapHeader);
-              const bodyObj = JSON.parse(init.body);
-              if (Array.isArray(bodyObj.messages)) {
-                for (const msg of bodyObj.messages) {
-                  if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
-                    for (const tc of msg.tool_calls) {
-                      const sig = sigMap[tc.id] || sigMap["default"];
-                      if (sig) {
-                        tc.extra_content = { google: { thought_signature: sig } };
-                      }
-                    }
-                  }
-                }
-                init.body = JSON.stringify(bodyObj);
-              }
-            } catch {}
-          }
-        }
-
-        // Add extra_body cached_content if specified
-        const cacheId = h["x-cached-content-id"];
-        if (cacheId) {
-          delete h["x-cached-content-id"];
-          if (init.body && typeof init.body === "string") {
-            try {
-              const bodyObj = JSON.parse(init.body);
-              bodyObj.extra_body = {
-                ...(bodyObj.extra_body || {}),
-                google: { cached_content: cacheId },
-              };
-              init.body = JSON.stringify(bodyObj);
-            } catch {}
-          }
-        }
-      }
-    }
-
-    let res: Response;
-    try {
-      res = await baseFetch(input, init);
-    } catch (e: any) {
-      const msg = e?.message ?? String(e);
-      if (e?.name === "AbortError" || msg.includes("aborted") || msg.includes("abort")) throw e;
-      if (msg.includes("Failed to fetch") || msg.includes("NetworkError") || msg.includes("Load failed") || e instanceof TypeError) {
-        const url = requestUrlOf(input);
-        const host = (() => { try { return new URL(url).host; } catch { return ""; } })();
-        throw new Error(
-          `Network request failed (browser could not reach ${host || url || "provider"}). ` +
-          `URL: ${url || "(unknown)"}. ` +
-          `Usual browser causes: CORS preflight blocked (custom header not allow-listed), ad-blocker, offline, wrong Base URL, or page not on http://localhost. ` +
-          `Check F12 Network tab for the failed OPTIONS/POST request. Original: ${msg}`
-        );
-      }
-      throw e;
-    }
-    const contentType = res.headers.get("content-type") || "";
-
-    // 1. JSON normalization: ensure choices[i].index exists (strict Zod schema tolerance)
-    if (contentType.includes("application/json")) {
-      try {
-        const text = await res.text();
-        const data = JSON.parse(text);
-        let mutated = false;
-        if (data && Array.isArray(data.choices)) {
-          for (let i = 0; i < data.choices.length; i++) {
-            if (data.choices[i] && data.choices[i].index === undefined) {
-              data.choices[i].index = i;
-              mutated = true;
-            }
-          }
-        }
-        if (mutated) {
-          return new Response(JSON.stringify(data), {
-            status: res.status,
-            statusText: res.statusText,
-            headers: res.headers,
-          });
-        }
-        return new Response(text, {
-          status: res.status,
-          statusText: res.statusText,
-          headers: res.headers,
-        });
-      } catch {
-        return res;
-      }
-    }
-
-    // 2. SSE stream normalization: ensure choices[i].index, finish_reason, and extract thought signatures
-    if (contentType.includes("text/event-stream") && res.body) {
-      let hasSeenFinishReason = false;
-      const transformStream = new TransformStream({
-        transform(chunk, controller) {
-          const text = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
-          const lines = text.split("\n");
-          const modifiedLines: string[] = [];
-
-          for (const line of lines) {
-            if (line.startsWith("data: ")) {
-              const dataPayload = line.slice(6).trim();
-              if (dataPayload === "[DONE]") {
-                if (!hasSeenFinishReason) {
-                  hasSeenFinishReason = true;
-                  modifiedLines.push(`data: ${JSON.stringify({
-                    id: "finish-synth",
-                    choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
-                  })}`);
-                }
-                modifiedLines.push(line);
-                continue;
-              }
-
-              try {
-                const json = JSON.parse(dataPayload);
-                let lineMutated = false;
-                if (json && Array.isArray(json.choices)) {
-                  for (let i = 0; i < json.choices.length; i++) {
-                    const c = json.choices[i];
-                    if (c) {
-                      if (c.index === undefined) {
-                        c.index = i;
-                        lineMutated = true;
-                      }
-                      if (c.finish_reason) {
-                        hasSeenFinishReason = true;
-                      } else if (json.finish_reason) {
-                        c.finish_reason = json.finish_reason;
-                        hasSeenFinishReason = true;
-                        lineMutated = true;
-                      }
-                      if (c.delta?.tool_calls && Array.isArray(c.delta.tool_calls)) {
-                        for (let j = 0; j < c.delta.tool_calls.length; j++) {
-                          const tc = c.delta.tool_calls[j];
-                          if (tc) {
-                            if (tc.index === undefined) {
-                              tc.index = j;
-                              lineMutated = true;
-                            }
-                            const sig = tc.extra_content?.google?.thought_signature;
-                            if (sig) {
-                              if (tc.id) streamThoughtSignatures.set(tc.id, sig);
-                              streamThoughtSignatures.set("latest", sig);
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  if (lineMutated) {
-                    modifiedLines.push(`data: ${JSON.stringify(json)}`);
-                    continue;
-                  }
-                }
-              } catch {}
-            }
-            modifiedLines.push(line);
-          }
-          controller.enqueue(new TextEncoder().encode(modifiedLines.join("\n")));
-        },
-      });
-
-      return new Response(res.body.pipeThrough(transformStream), {
-        status: res.status,
-        statusText: res.statusText,
-        headers: res.headers,
-      });
-    }
-
-    return res;
-  };
-  return fetchFn as typeof fetch;
-}
-
-/**
- * Creates or retrieves a Vercel AI SDK provider instance for any given provider ID.
- */
-export function getAiSdkProvider(
-  providerId: string,
-  options?: AiSdkModelOptions
-): AnyAiSdkProvider {
-  const normId = providerId.toLowerCase().trim().replace(/\/.*$/, "");
-  const effectiveFetch = createAiSdkFetch(options?.fetch);
-
-  if (normId === "google") {
-    const apiKey = options?.apiKey || getApiKey("google", undefined, options?.env);
-    const baseURL = options?.baseUrl || "https://generativelanguage.googleapis.com/v1beta";
-    return createGoogleGenerativeAI({
-      apiKey,
-      baseURL,
-      headers: options?.headers,
-      fetch: effectiveFetch,
-    });
-  }
-
-  if (normId === "openai") {
-    const apiKey =
-      options?.apiKey ||
-      options?.env?.["OPENAI_BASE_API_KEY"] ||
-      options?.env?.["OPENAI_API_KEY"] ||
-      getEnv("OPENAI_BASE_API_KEY") ||
-      getEnv("OPENAI_API_KEY") ||
-      getApiKey("openai", undefined, options?.env);
-
-    const baseURL =
-      options?.baseUrl ||
-      options?.env?.["OPENAI_BASE_URL"] ||
-      getEnv("OPENAI_BASE_URL") ||
-      getEnv("OPENAI_API_BASE") ||
-      "https://api.openai.com/v1";
-
-    if (baseURL && !baseURL.includes("api.openai.com")) {
-      return createOpenAICompatible({
-        name: "openai",
-        baseURL,
-        apiKey: apiKey || "dummy-key",
-        headers: options?.headers,
-        fetch: effectiveFetch,
-      });
-    }
-
-    return createOpenAI({
-      apiKey: apiKey || "dummy-key",
-      baseURL,
-      headers: options?.headers,
-      fetch: effectiveFetch,
-    });
-  }
-
-  if (normId === "opencode") {
-    const apiKey = options?.apiKey || getApiKey("opencode", undefined, options?.env);
-    const baseURL =
-      options?.baseUrl ||
-      options?.env?.["OPENCODE_BASE_URL"] ||
-      getEnv("OPENCODE_BASE_URL") ||
-      "https://opencode.ai/zen/v1";
-
-    return createOpenAICompatible({
-      name: "opencode",
-      baseURL,
-      apiKey: apiKey || "dummy-key",
-      headers: options?.headers,
-      fetch: effectiveFetch,
-    });
-  }
-
-  if (normId === "openrouter") {
-    const apiKey = options?.apiKey || getApiKey("openrouter", undefined, options?.env);
-    const baseURL =
-      options?.baseUrl ||
-      options?.env?.["OPENROUTER_BASE_URL"] ||
-      getEnv("OPENROUTER_BASE_URL") ||
-      "https://openrouter.ai/api/v1";
-
-    return createOpenAICompatible({
-      name: "openrouter",
-      baseURL,
-      apiKey: apiKey || "dummy-key",
-      headers: options?.headers,
-      fetch: effectiveFetch,
-    });
-  }
-
-  // Custom / OpenAI-compatible provider (groq, cerebras, together, fireworks, ollama, etc.)
-  const envPrefix = normId.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-  const apiKey =
-    options?.apiKey ||
-    options?.env?.[`${envPrefix}_API_KEY`] ||
-    options?.env?.[`${envPrefix}_BASE_API_KEY`] ||
-    options?.env?.["OPENAI_BASE_API_KEY"] ||
-    options?.env?.["OPENAI_API_KEY"] ||
-    getEnv(`${envPrefix}_API_KEY`) ||
-    getEnv(`${envPrefix}_BASE_API_KEY`) ||
-    getEnv("OPENAI_BASE_API_KEY") ||
-    getEnv("OPENAI_API_KEY") ||
-    getApiKey(normId, undefined, options?.env) ||
-    "dummy-key";
-
-  const baseURL =
-    options?.baseUrl ||
-    options?.env?.[`${envPrefix}_BASE_URL`] ||
-    options?.env?.[`${envPrefix}_BASEURL`] ||
-    options?.env?.[`${envPrefix}_API_BASE`] ||
-    getEnv(`${envPrefix}_BASE_URL`) ||
-    getEnv(`${envPrefix}_BASEURL`) ||
-    getEnv(`${envPrefix}_API_BASE`) ||
-    getEnv("OPENAI_BASE_URL") ||
-    getEnv("OPENAI_API_BASE") ||
-    "https://api.openai.com/v1";
-
-  return createOpenAICompatible({
-    name: normId,
-    baseURL,
-    apiKey,
-    headers: options?.headers,
-    fetch: effectiveFetch,
-  });
-}
-
-/**
- * Returns a Vercel AI SDK LanguageModel instance for any provider and model.
- */
-export function getAiSdkModel(
-  providerId: string,
-  modelId: string,
-  options?: AiSdkModelOptions
-): LanguageModelV4 {
-  const cleanId = modelId.replace(new RegExp(`^(${providerId}|google|openai|opencode|openrouter|models?)/`, "i"), "");
-  const provider = getAiSdkProvider(providerId, options);
-
-  if ("chat" in provider && typeof (provider as any).chat === "function") {
-    return (provider as any).chat(cleanId);
-  }
-
-  if (typeof provider === "function") {
-    return (provider as any)(cleanId);
-  }
-
-  if ("chatModel" in provider && typeof (provider as any).chatModel === "function") {
-    return (provider as any).chatModel(cleanId);
-  }
-
-  if ("languageModel" in provider && typeof (provider as any).languageModel === "function") {
-    return (provider as any).languageModel(cleanId);
-  }
-
-  throw new Error(`Unsupported Vercel AI SDK provider instance for ${providerId}`);
-}

package/src/tokens/counter.ts

@@ -1,136 +0,0 @@
-import type { Message, ContentPart } from "../types/message.ts";
-import type { ProviderContext } from "../types/message.ts";
-
-/**
- * High-speed token estimation utility.
- * For English text, average is ~4 characters per token or ~0.75 words per token.
- * Code and symbols average ~2-3 characters per token.
- */
-/**
- * Estimates token count from text without contacting a provider tokenizer.
- *
- * @example `const tokens = estimateTokensFromText(prompt);`
- */
-export function estimateTokensFromText(text: string): number {
-  if (!text || text.length === 0) return 0;
-  const chars = text.length;
-  let words = 0;
-  let inWord = false;
-  let codeMarkers = 0;
-
-  for (let i = 0; i < chars; i++) {
-    const code = text.charCodeAt(i);
-    // Whitespace: space(32), tab(9), LF(10), CR(13)
-    if (code === 32 || code === 9 || code === 10 || code === 13) {
-      if (inWord) {
-        words++;
-        inWord = false;
-      }
-    } else {
-      inWord = true;
-      // Code markers: { (123), } (125), ; (59), = (61), < (60), > (62), / (47), \ (92)
-      if (code === 123 || code === 125 || code === 59 || code === 61 || code === 60 || code === 62 || code === 47 || code === 92) {
-        codeMarkers++;
-      }
-    }
-  }
-  if (inWord) words++;
-
-  const isCodeHeavy = codeMarkers > chars * 0.05;
-  const charDivisor = isCodeHeavy ? 3.0 : 3.8;
-  const wordFactor = isCodeHeavy ? 1.6 : 1.3;
-  return Math.ceil(Math.max(chars / charDivisor, words * wordFactor));
-}
-
-/**
- * Estimates tokens for one multimodal, thinking, or tool content part.
- *
- * @example `const tokens = estimateTokensFromPart({ type: "text", text: prompt });`
- */
-export function estimateTokensFromPart(part: ContentPart): number {
-  switch (part.type) {
-    case "text":
-      return estimateTokensFromText(part.text);
-    case "thinking":
-      return estimateTokensFromText(part.thinking);
-    case "image":
-      // Standard vision token cost ~258 tokens per low-res / 1000-1600 per high-res tile
-      return 258;
-    case "audio":
-      // ~25 tokens per second of audio
-      return 150;
-    case "video":
-      // ~250 tokens per frame / minute
-      return 500;
-    case "file":
-      return 400;
-    case "tool_call":
-      return (
-        estimateTokensFromText(part.name) +
-        estimateTokensFromText(JSON.stringify(part.arguments)) +
-        15
-      );
-    case "tool_result":
-      return (
-        estimateTokensFromText(part.name) +
-        estimateTokensFromText(
-          typeof part.result === "string" ? part.result : JSON.stringify(part.result)
-        ) +
-        10
-      );
-    default:
-      return 0;
-  }
-}
-
-/**
- * Estimates tokens for one normalized message including metadata overhead.
- *
- * @example `const tokens = estimateTokensFromMessage({ role: "user", content: "Hi" });`
- */
-export function estimateTokensFromMessage(message: Message): number {
-  let count = 4; // Message metadata overhead (role, markers)
-  if (typeof message.content === "string") {
-    count += estimateTokensFromText(message.content);
-  } else if (Array.isArray(message.content)) {
-    for (const part of message.content) {
-      count += estimateTokensFromPart(part);
-    }
-  }
-  return count;
-}
-
-/**
- * Estimates tokens for text, messages, or a complete ProviderContext.
- *
- * @example `const tokens = countTokens({ messages });`
- */
-export function countTokens(
-  input: string | Message[] | ProviderContext
-): number {
-  if (typeof input === "string") {
-    return estimateTokensFromText(input);
-  }
-
-  if (Array.isArray(input)) {
-    let total = 0;
-    for (const msg of input) {
-      total += estimateTokensFromMessage(msg);
-    }
-    return total;
-  }
-
-  let total = 0;
-  if (input.systemPrompt) {
-    total += estimateTokensFromText(input.systemPrompt) + 5;
-  }
-  if (input.messages) {
-    for (const msg of input.messages) {
-      total += estimateTokensFromMessage(msg);
-    }
-  }
-  if (input.tools) {
-    total += estimateTokensFromText(JSON.stringify(input.tools)) + 20;
-  }
-  return total;
-}