aigetwey 1.0.1

package/src/translator/thinking.ts

@@ -0,0 +1,64 @@
+/**
+ * Concern: reasoning_effort ↔ provider-native thinking config.
+ * Central source of truth for level↔budget maps (web-standard values).
+ * Provider-specific application lives in thinkingUnified.ts; this file is maps-only.
+ *
+ * Implemented for aigetwey so
+ * aigetwey normalizes thinking identically.
+ */
+
+/** Discrete effort levels, ordered low→high. */
+export const EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+/** Web-standard level → budget_tokens (Anthropic/Gemini docs). */
+export const LEVEL_TO_BUDGET: Record<string, number> = {
+  none: 0,
+  minimal: 512,
+  low: 1024,
+  medium: 8192,
+  high: 24576,
+  xhigh: 32768,
+  max: 128000,
+};
+
+/**
+ * Returns budget_tokens for an effort level, or undefined if unknown.
+ * 0 means "no thinking"; undefined means "effort not recognized".
+ */
+export function effortToBudget(effort: string | undefined | null): number | undefined {
+  if (!effort) return undefined;
+  return LEVEL_TO_BUDGET[String(effort).toLowerCase()];
+}
+
+/**
+ * OpenAI reasoning_effort → Gemini thinkingLevel (gemini-3 enum: minimal|low|medium|high).
+ * Gemini 3 cannot fully disable thinking; "none"/"off" map to "minimal".
+ */
+export function effortToThinkingLevel(effort: string): string {
+  const e = String(effort).toLowerCase().trim();
+  if (e === "none" || e === "off") return "minimal";
+  if (e === "xhigh" || e === "max") return "high";
+  return e;
+}
+
+/**
+ * Numeric budget → nearest discrete level (reverse map via thresholds).
+ * Returns null when budget <= 0 (no reasoning).
+ */
+export function budgetToLevel(budget: number): string | null {
+  const b = Number(budget);
+  if (!b || b <= 0) return null;
+  if (b <= 768) return "minimal";
+  if (b <= 4096) return "low";
+  if (b <= 16384) return "medium";
+  if (b <= 28672) return "high";
+  return "xhigh";
+}
+
+/** Gemini thinkingBudget (numeric) → OpenAI reasoning_effort (antigravity reverse map). */
+export function budgetToEffort(budget: number): string | null {
+  if (!budget || budget <= 0) return null;
+  if (budget <= 2048) return "low";
+  if (budget <= 16384) return "medium";
+  return "high";
+}

package/src/translator/thinkingUnified.ts

@@ -0,0 +1,319 @@
+/**
+ * Unified thinking normalization: extract client intent → apply provider-native format.
+ * Config-driven: thinking format/limits come from capabilities.ts, never hardcoded
+ * per-model here.
+ *
+ * aigetwey's own implementation. The one
+ * adaptation for aigetwey: there is no provider registry carrying a thinkingFormat,
+ * so resolveFormat relies on the capabilities table + the wire format alone, and
+ * FORMAT_TO_NATIVE also maps aigetwey's "anthropic" wire format. See
+ * 
+ */
+import { getCapabilitiesForModel, type Caps } from "../providers/capabilities.js";
+import { LEVEL_TO_BUDGET, budgetToLevel, effortToBudget } from "./thinking.js";
+
+export interface ThinkingConfig {
+  mode: "none" | "auto" | "budget" | "level";
+  budget?: number;
+  level?: string;
+}
+
+type Body = Record<string, any>;
+
+// Map a target wire-format to its native thinking format (when capability has none).
+const FORMAT_TO_NATIVE: Record<string, string> = {
+  openai: "openai",
+  "openai-responses": "openai",
+  "openai-response": "openai",
+  codex: "openai",
+  claude: "claude-budget",
+  anthropic: "claude-budget",
+  gemini: "gemini-budget",
+  "gemini-cli": "gemini-budget",
+  vertex: "gemini-budget",
+  antigravity: "gemini-budget",
+  kiro: "kiro",
+};
+
+/**
+ * Parse model-name suffix "model(value)" → { cleanModel, override }.
+ * value: level name (high) | number (8192) | auto | none. null override when absent.
+ */
+export function parseSuffix(model: string): { cleanModel: string; override: ThinkingConfig | null } {
+  if (typeof model !== "string") return { cleanModel: model, override: null };
+  const m = model.match(/^(.*)\(([^()]+)\)\s*$/);
+  if (!m) return { cleanModel: model, override: null };
+  const cleanModel = m[1]!.trim();
+  const raw = m[2]!.trim().toLowerCase();
+  if (raw === "none" || raw === "off") return { cleanModel, override: { mode: "none" } };
+  if (raw === "auto") return { cleanModel, override: { mode: "auto" } };
+  if (/^\d+$/.test(raw)) return { cleanModel, override: { mode: "budget", budget: Number(raw) } };
+  if (LEVEL_TO_BUDGET[raw] !== undefined) return { cleanModel, override: { mode: "level", level: raw } };
+  return { cleanModel, override: null };
+}
+
+/**
+ * Extract unified thinking intent from a request body (post-translation, mixed shapes).
+ * Returns { mode, budget?, level? } or null when no thinking intent present.
+ */
+export function extractThinking(body: Body | null | undefined): ThinkingConfig | null {
+  if (!body || typeof body !== "object") return null;
+
+  // Claude output_config.effort (explicit) — priority over adaptive thinking
+  const oc = body.output_config?.effort;
+  if (typeof oc === "string" && oc) {
+    const e = oc.toLowerCase();
+    if (e === "none" || e === "off") return { mode: "none" };
+    if (e === "auto") return { mode: "auto" };
+    return { mode: "level", level: e };
+  }
+
+  // Claude shape
+  const t = body.thinking;
+  if (t && typeof t === "object") {
+    if (t.type === "disabled") return { mode: "none" };
+    if (t.type === "adaptive" || t.type === "enabled") {
+      const budget = Number(t.budget_tokens);
+      if (Number.isFinite(budget) && budget > 0) return { mode: "budget", budget };
+      return { mode: "auto" };
+    }
+  }
+
+  // OpenAI chat / Responses shape
+  const effort = body.reasoning_effort ?? (typeof body.reasoning === "object" ? body.reasoning?.effort : null);
+  if (typeof effort === "string" && effort) {
+    const e = effort.toLowerCase();
+    if (e === "none" || e === "off") return { mode: "none" };
+    if (e === "auto") return { mode: "auto" };
+    return { mode: "level", level: e };
+  }
+
+  // Gemini shape (top-level, generationConfig, or request envelope)
+  const tc = body.thinkingConfig || body.generationConfig?.thinkingConfig || body.request?.generationConfig?.thinkingConfig;
+  if (tc && typeof tc === "object") {
+    if (typeof tc.thinkingLevel === "string") return { mode: "level", level: tc.thinkingLevel.toLowerCase() };
+    const tb = Number(tc.thinkingBudget);
+    if (Number.isFinite(tb)) {
+      if (tb === 0) return { mode: "none" };
+      if (tb < 0) return { mode: "auto" };
+      return { mode: "budget", budget: tb };
+    }
+  }
+
+  // Qwen shape
+  if (body.enable_thinking === false) return { mode: "none" };
+  if (body.enable_thinking === true) {
+    const tb = Number(body.thinking_budget);
+    if (Number.isFinite(tb) && tb > 0) return { mode: "budget", budget: tb };
+    return { mode: "auto" };
+  }
+
+  return null;
+}
+
+/**
+ * Capture thinking intent from a body. Alias of extractThinking, named for clarity
+ * at the call-site where intent is snapshotted before format translation.
+ */
+export const captureThinking = extractThinking;
+
+// Resolve thinking format: capability > derive(targetFormat).
+function resolveFormat(targetFormat: string, model: string, provider: string | null): string {
+  const caps = getCapabilitiesForModel(provider, model);
+  if (caps.thinkingFormat) return caps.thinkingFormat;
+  return FORMAT_TO_NATIVE[targetFormat] || "openai";
+}
+
+// Convert unified config to a budget number (for budget-based formats).
+function toBudget(cfg: ThinkingConfig, range: Caps["thinkingRange"]): number | undefined {
+  let budget: number | undefined;
+  if (cfg.mode === "budget") budget = cfg.budget;
+  else if (cfg.mode === "level") budget = effortToBudget(cfg.level);
+  else if (cfg.mode === "auto") return -1;
+  if (!Number.isFinite(budget)) return undefined;
+  if (range) {
+    if (range.min != null && budget! < range.min) budget = range.min;
+    if (range.max != null && budget! > range.max) budget = range.max;
+  }
+  return budget;
+}
+
+// Convert unified config to a discrete level string.
+function toLevel(cfg: ThinkingConfig): string | null {
+  if (cfg.mode === "level") return cfg.level ?? null;
+  if (cfg.mode === "budget") return budgetToLevel(cfg.budget ?? 0) || "medium";
+  if (cfg.mode === "auto") return "auto";
+  return null;
+}
+
+// Gemini nests thinkingConfig under generationConfig.
+function setGeminiThinking(body: Body, tc: Record<string, unknown>): void {
+  const gc = body.request?.generationConfig
+    ? body.request.generationConfig
+    : body.generationConfig && typeof body.generationConfig === "object"
+      ? body.generationConfig
+      : (body.generationConfig = {});
+  gc.thinkingConfig = tc;
+}
+
+// Strip every known thinking field from a body (used before re-applying / when unsupported).
+function stripAll(body: Body): void {
+  delete body.thinking;
+  delete body.reasoning_effort;
+  delete body.reasoning;
+  delete body.thinkingConfig;
+  delete body.enable_thinking;
+  delete body.thinking_budget;
+  delete body.output_config;
+  if (body.generationConfig) delete body.generationConfig.thinkingConfig;
+  if (body.request?.generationConfig) delete body.request.generationConfig.thinkingConfig;
+}
+
+// Apply unified thinking config to body in the resolved provider-native format.
+function applyFormat(fmt: string, body: Body, cfg: ThinkingConfig, caps: Caps): void {
+  const none = cfg.mode === "none";
+  const canDisable = caps.thinkingCanDisable !== false;
+  // Model cannot disable thinking → clamp "none" to minimal effort instead.
+  const eff: ThinkingConfig = none && !canDisable ? { mode: "level", level: "minimal" } : cfg;
+
+  switch (fmt) {
+    case "openai": {
+      if (none && canDisable) {
+        body.reasoning_effort = "none";
+        break;
+      }
+      const level = toLevel(eff);
+      if (level) body.reasoning_effort = level === "xhigh" || level === "max" ? "high" : level;
+      break;
+    }
+    case "claude-adaptive": {
+      if (none && canDisable) {
+        body.thinking = { type: "disabled" };
+        break;
+      }
+      const level = toLevel(eff);
+      body.output_config = { effort: level === "xhigh" ? "high" : level };
+      break;
+    }
+    case "claude-budget": {
+      if (none && canDisable) {
+        body.thinking = { type: "disabled" };
+        break;
+      }
+      const budget = toBudget(eff, caps.thinkingRange);
+      body.thinking = budget === -1 ? { type: "enabled" } : { type: "enabled", budget_tokens: budget || 8192 };
+      break;
+    }
+    case "gemini-level": {
+      const level = none ? "minimal" : toLevel(eff) || "high";
+      setGeminiThinking(body, { thinkingLevel: level, includeThoughts: level !== "minimal" });
+      break;
+    }
+    case "gemini-budget": {
+      if (none && canDisable) {
+        setGeminiThinking(body, { thinkingBudget: 0, includeThoughts: false });
+        break;
+      }
+      const budget = toBudget(eff, caps.thinkingRange);
+      setGeminiThinking(body, { thinkingBudget: budget ?? -1, includeThoughts: true });
+      break;
+    }
+    case "zai": {
+      // Z.ai ignores thinking.disabled → must use enable_thinking:false to turn off.
+      if (none && canDisable) {
+        body.enable_thinking = false;
+        delete body.thinking;
+        break;
+      }
+      body.thinking = { type: "enabled" };
+      break;
+    }
+    case "qwen": {
+      if (none && canDisable) {
+        body.enable_thinking = false;
+        break;
+      }
+      body.enable_thinking = true;
+      const budget = toBudget(eff, caps.thinkingRange);
+      if (Number.isFinite(budget) && budget! > 0) body.thinking_budget = budget;
+      break;
+    }
+    case "deepseek": {
+      if (none && canDisable) {
+        body.thinking = { type: "disabled" };
+        break;
+      }
+      body.thinking = { type: "enabled" };
+      // DeepSeek: low/medium→high, xhigh/max→max.
+      const level = toLevel(eff);
+      body.reasoning_effort = level === "xhigh" || level === "max" ? "max" : "high";
+      break;
+    }
+    case "kimi": {
+      if (none && canDisable) {
+        body.thinking = { type: "disabled" };
+        break;
+      }
+      const level = toLevel(eff);
+      if (level) body.reasoning_effort = level === "max" ? "high" : level;
+      break;
+    }
+    case "minimax": {
+      // M3 adaptive; M2.x cannot disable (handled via canDisable clamp).
+      body.thinking = { type: none && canDisable ? "disabled" : "adaptive" };
+      break;
+    }
+    case "hunyuan": {
+      if (none && canDisable) {
+        body.thinking = { type: "disabled" };
+        break;
+      }
+      const budget = toBudget(eff, caps.thinkingRange);
+      body.thinking = budget === -1 ? { type: "enabled" } : { type: "enabled", budget_tokens: budget || 8192 };
+      break;
+    }
+    case "step": {
+      if (none && canDisable) break;
+      const level = toLevel(eff);
+      if (level) body.reasoning_effort = level === "xhigh" || level === "max" ? "high" : level;
+      break;
+    }
+    case "kiro":
+      // Kiro thinking handled via system-tag injection elsewhere; no body field here.
+      break;
+    default:
+      break;
+  }
+}
+
+/**
+ * Public entry: normalize thinking for the resolved target format.
+ * Mutates and returns body. No-op when model has no reasoning capability.
+ * `intent` is a pre-captured config (from captureThinking on the original body);
+ * falls back to extracting from the current body when omitted.
+ */
+export function applyThinking(
+  targetFormat: string,
+  model: string,
+  body: Body,
+  provider: string | null = null,
+  intent: ThinkingConfig | null | undefined = undefined,
+): Body {
+  if (!body || typeof body !== "object") return body;
+
+  const { cleanModel, override } = parseSuffix(model);
+  const cfg = override || intent || extractThinking(body);
+  const caps = getCapabilitiesForModel(provider, cleanModel);
+
+  // Model cannot reason → strip any stray thinking fields.
+  if (!caps.reasoning) {
+    stripAll(body);
+    return body;
+  }
+  if (!cfg) return body;
+
+  const fmt = resolveFormat(targetFormat, cleanModel, provider);
+  stripAll(body);
+  applyFormat(fmt, body, cfg, caps);
+  return body;
+}

package/src/upstream/client.ts

@@ -0,0 +1,155 @@
+/**
+ * Upstream provider client. Translates a canonical request into the provider's
+ * native format, calls it, and returns either a parsed canonical response
+ * (non-stream) or the raw byte stream (stream — consumed in Phase 3).
+ */
+import { request } from "undici";
+import type { Provider } from "../config.js";
+import type { CanonicalRequest, CanonicalResponse } from "../core/canonical.js";
+import { adapterFor } from "../adapters/index.js";
+import { applyThinking, type ThinkingConfig } from "../translator/thinkingUnified.js";
+
+export interface UpstreamError extends Error {
+  status?: number;
+  body?: string;
+  /** true if trying a different key/provider might succeed */
+  retryable?: boolean;
+}
+
+/**
+ * Retryable = an availability problem another key/provider could clear: rate
+ * limits (429), server errors (5xx), network/timeout (no status). Non-retryable
+ * = the request itself is bad (400/401/403/404/422) — falling back just wastes
+ * time and spams other providers.
+ */
+function classifyRetryable(status: number | undefined): boolean {
+  if (status === undefined) return true; // network error / timeout / abort
+  if (status === 429) return true;
+  if (status >= 500) return true;
+  return false;
+}
+
+function buildHeaders(provider: Provider, key: string | undefined): Record<string, string> {
+  const headers: Record<string, string> = {
+    "content-type": "application/json",
+    ...(provider.headers ?? {}),
+  };
+  if (provider.format === "anthropic") {
+    if (key) headers["x-api-key"] = key;
+    headers["anthropic-version"] ??= "2023-06-01";
+  } else if (provider.format === "gemini") {
+    if (key) headers["x-goog-api-key"] = key;
+  } else {
+    if (key) headers["authorization"] = `Bearer ${key}`;
+  }
+  return headers;
+}
+
+/**
+ * OpenAI/Anthropic use a fixed path on base_url; Gemini puts the model and
+ * stream mode in the path (:generateContent | :streamGenerateContent?alt=sse).
+ */
+function buildUrl(provider: Provider, model: string, stream: boolean): string {
+  const base = provider.base_url.replace(/\/$/, "");
+  if (provider.format === "gemini") {
+    const method = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+    return `${base}/models/${encodeURIComponent(model)}:${method}`;
+  }
+  return base + (provider.format === "anthropic" ? "/messages" : "/chat/completions");
+}
+
+function buildBody(
+  provider: Provider,
+  req: CanonicalRequest,
+  model: string,
+  stream: boolean,
+  thinkingIntent?: ThinkingConfig | null,
+): unknown {
+  const adapter = adapterFor(provider.format);
+  const upstreamReq: CanonicalRequest = { ...req, model, stream };
+  const out = adapter.requestFromCanonical(upstreamReq) as Record<string, unknown>;
+  // Normalize thinking into THIS provider's native format, keyed by the upstream
+  // model's capabilities. No-op for non-reasoning models. Runs per-attempt so each
+  // provider in a fallback chain gets the right shape.
+  applyThinking(provider.format, model, out, provider.id, thinkingIntent);
+  return out;
+}
+
+export interface NonStreamResult {
+  stream: false;
+  response: CanonicalResponse;
+}
+export interface StreamResult {
+  stream: true;
+  body: AsyncIterable<Uint8Array>;
+}
+
+export async function callUpstream(
+  provider: Provider,
+  req: CanonicalRequest,
+  model: string,
+  opts: { stream: boolean; key?: string; signal?: AbortSignal; thinkingIntent?: ThinkingConfig | null },
+): Promise<NonStreamResult | StreamResult> {
+  const url = buildUrl(provider, model, opts.stream);
+  const headers = buildHeaders(provider, opts.key);
+  const body = buildBody(provider, req, model, opts.stream, opts.thinkingIntent);
+
+  let res;
+  try {
+    res = await request(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: opts.signal,
+      // providers can be slow to first byte on long generations
+      headersTimeout: 600_000,
+      bodyTimeout: 600_000,
+    });
+  } catch (e) {
+    const err = new Error(`upstream ${provider.id} request failed: ${(e as Error).message}`) as UpstreamError;
+    err.retryable = true;
+    throw err;
+  }
+
+  if (res.statusCode >= 400) {
+    const text = await res.body.text();
+    const err = new Error(`upstream ${provider.id} returned ${res.statusCode}`) as UpstreamError;
+    err.status = res.statusCode;
+    err.body = text;
+    err.retryable = classifyRetryable(res.statusCode);
+    throw err;
+  }
+
+  if (opts.stream) return { stream: true, body: res.body };
+
+  const json = await res.body.json();
+  const adapter = adapterFor(provider.format);
+  return { stream: false, response: adapter.responseToCanonical(json) };
+}
+
+export interface PingResult {
+  reachable: boolean;
+  status?: number;
+  ok: boolean; // 2xx — endpoint + key both good
+  error?: string;
+}
+
+/**
+ * Lightweight connectivity check: GET {base}/models with the provider's auth.
+ * Any HTTP status means the host is reachable; 2xx means the key is accepted.
+ * Never throws — returns a structured result for the dashboard.
+ */
+export async function pingProvider(provider: Provider, key: string | undefined): Promise<PingResult> {
+  const base = provider.base_url.replace(/\/$/, "");
+  const url = `${base}/models`;
+  const headers = buildHeaders(provider, key);
+  try {
+    const res = await request(url, { method: "GET", headers, headersTimeout: 10_000, bodyTimeout: 10_000 });
+    await res.body.dump();
+    return { reachable: true, status: res.statusCode, ok: res.statusCode >= 200 && res.statusCode < 300 };
+  } catch (e) {
+    return { reachable: false, ok: false, error: (e as Error).message };
+  }
+}
+
+export { buildHeaders, buildUrl };

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": false,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "tests"]
+}