shariq-pi-extensions 0.1.0

package/extensions/factory-provider/factory/limits.ts

@@ -0,0 +1,342 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { FACTORY_API_BASE_URL, FACTORY_STATE_DIR } from "./constants.ts";
+
+export const FACTORY_LIMITS_CACHE_PATH = path.join(
+  FACTORY_STATE_DIR,
+  "limits-cache.json",
+);
+export const FACTORY_LIMITS_TTL_MS = 15 * 60 * 1000;
+const CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const REQUEST_TIMEOUT_MS = 10_000;
+
+export const FACTORY_CORE_MODEL_IDS = new Set([
+  "glm-5.2",
+  "glm-5.2-fast",
+  "kimi-k3",
+  "kimi-k2.7-code",
+  "kimi-k2.6",
+  "nemotron-3-ultra",
+  "deepseek-v4-flash-0731",
+  "deepseek-v4-pro",
+  "minimax-m3",
+  "inkling",
+]);
+
+export type FactoryBillingPool = "standard" | "core";
+
+export interface FactoryLimitBucket {
+  usedPercent: number;
+  windowEnd?: string | null;
+  secondsRemaining?: number | null;
+}
+
+export interface FactoryPoolLimits {
+  fiveHour: FactoryLimitBucket;
+  weekly: FactoryLimitBucket;
+  monthly: FactoryLimitBucket;
+}
+
+export interface FactoryLimits {
+  standard?: FactoryPoolLimits;
+  core?: FactoryPoolLimits;
+}
+
+export interface FactoryLimitCredential {
+  label: string;
+  secret: string;
+  headers?: Record<string, string>;
+}
+
+export interface FactoryLimitRecord {
+  id: string;
+  label: string;
+  fetchedAt: number;
+  attemptedAt?: number;
+  limits?: FactoryLimits;
+  error?: string;
+}
+
+interface FactoryLimitCache {
+  version: 1;
+  records: FactoryLimitRecord[];
+}
+
+function finitePercent(value: unknown) {
+  return typeof value === "number" && Number.isFinite(value)
+    ? Math.max(0, Math.min(100, value))
+    : 0;
+}
+
+function bucket(value: unknown): FactoryLimitBucket {
+  const raw = value && typeof value === "object"
+    ? (value as Record<string, unknown>)
+    : {};
+  return {
+    usedPercent: finitePercent(raw.usedPercent),
+    windowEnd: typeof raw.windowEnd === "string" ? raw.windowEnd : null,
+    secondsRemaining:
+      typeof raw.secondsRemaining === "number" &&
+      Number.isFinite(raw.secondsRemaining)
+        ? Math.max(0, raw.secondsRemaining)
+        : null,
+  };
+}
+
+function pool(value: unknown): FactoryPoolLimits | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const raw = value as Record<string, unknown>;
+  return {
+    fiveHour: bucket(raw.fiveHour),
+    weekly: bucket(raw.weekly),
+    monthly: bucket(raw.monthly),
+  };
+}
+
+function parseLimits(value: unknown): FactoryLimits {
+  const raw = value && typeof value === "object"
+    ? (value as Record<string, unknown>)
+    : {};
+  const limits = raw.limits && typeof raw.limits === "object"
+    ? (raw.limits as Record<string, unknown>)
+    : {};
+  return { standard: pool(limits.standard), core: pool(limits.core) };
+}
+
+export function factoryCredentialId(secret: string) {
+  return createHash("sha256").update(secret).digest("hex").slice(0, 20);
+}
+
+export function loadFactoryLimitCache(): FactoryLimitCache {
+  try {
+    const value = JSON.parse(
+      fs.readFileSync(FACTORY_LIMITS_CACHE_PATH, "utf8"),
+    ) as Partial<FactoryLimitCache>;
+    const records = Array.isArray(value.records)
+      ? value.records.filter(
+          (record): record is FactoryLimitRecord =>
+            !!record &&
+            typeof record.id === "string" &&
+            typeof record.label === "string" &&
+            typeof record.fetchedAt === "number",
+        )
+      : [];
+    return { version: 1, records };
+  } catch {
+    return { version: 1, records: [] };
+  }
+}
+
+function saveFactoryLimitCache(cache: FactoryLimitCache) {
+  fs.mkdirSync(path.dirname(FACTORY_LIMITS_CACHE_PATH), {
+    recursive: true,
+    mode: 0o700,
+  });
+  const temporary = `${FACTORY_LIMITS_CACHE_PATH}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(cache, null, 2)}\n`, {
+    mode: 0o600,
+  });
+  fs.renameSync(temporary, FACTORY_LIMITS_CACHE_PATH);
+  fs.chmodSync(FACTORY_LIMITS_CACHE_PATH, 0o600);
+}
+
+function bucketResetAt(
+  bucket: FactoryLimitBucket,
+  observedAt = Date.now(),
+) {
+  if (bucket.windowEnd) {
+    const end = Date.parse(bucket.windowEnd);
+    if (Number.isFinite(end)) return end;
+  }
+  if (typeof bucket.secondsRemaining === "number") {
+    return observedAt + bucket.secondsRemaining * 1000;
+  }
+  return undefined;
+}
+
+function active(
+  bucket: FactoryLimitBucket,
+  now = Date.now(),
+  observedAt = now,
+) {
+  const resetAt = bucketResetAt(bucket, observedAt);
+  return resetAt !== undefined && resetAt > now;
+}
+
+/** Parent windows dominate exhausted child windows: monthly → weekly → 5-hour. */
+export function exhaustedBucket(
+  limits: FactoryPoolLimits | undefined,
+  now = Date.now(),
+  observedAt = now,
+): "monthly" | "weekly" | "fiveHour" | undefined {
+  if (!limits) return undefined;
+  if (active(limits.monthly, now, observedAt) && limits.monthly.usedPercent >= 100) {
+    return "monthly";
+  }
+  if (active(limits.weekly, now, observedAt) && limits.weekly.usedPercent >= 100) {
+    return "weekly";
+  }
+  if (active(limits.fiveHour, now, observedAt) && limits.fiveHour.usedPercent >= 100) {
+    return "fiveHour";
+  }
+  return undefined;
+}
+
+export function billingPoolForModel(modelId: string): FactoryBillingPool {
+  return FACTORY_CORE_MODEL_IDS.has(modelId) ? "core" : "standard";
+}
+
+export function cachedLimitDecision(
+  secret: string,
+  modelId: string,
+  now = Date.now(),
+) {
+  const record = loadFactoryLimitCache().records.find(
+    (item) => item.id === factoryCredentialId(secret),
+  );
+  if (!record?.limits) return undefined;
+  const poolName = billingPoolForModel(modelId);
+  const limits = record.limits[poolName];
+  const exhausted = exhaustedBucket(limits, now, record.fetchedAt);
+  if (exhausted && limits) {
+    return {
+      available: false as const,
+      pool: poolName,
+      exhausted,
+      resetAt: bucketResetAt(limits[exhausted], record.fetchedAt),
+      label: record.label,
+    };
+  }
+  if (now - record.fetchedAt > FACTORY_LIMITS_TTL_MS * 2) return undefined;
+  return { available: true as const, pool: poolName, label: record.label };
+}
+
+let refreshPromise: Promise<FactoryLimitRecord[]> | undefined;
+
+export function refreshFactoryLimits(
+  credentials: ReadonlyArray<FactoryLimitCredential>,
+  options: { force?: boolean; version: string; signal?: AbortSignal },
+) {
+  if (refreshPromise) return refreshPromise;
+  refreshPromise = (async () => {
+    const now = Date.now();
+    const cache = loadFactoryLimitCache();
+    const unique = new Map(
+      credentials
+        .filter((credential) => credential.secret.trim())
+        .map((credential) => [factoryCredentialId(credential.secret), credential]),
+    );
+    const records: FactoryLimitRecord[] = [];
+    for (const [id, credential] of unique) {
+      const existing = cache.records.find((record) => record.id === id);
+      if (
+        !options.force &&
+        existing &&
+        now - (existing.attemptedAt ?? existing.fetchedAt) < FACTORY_LIMITS_TTL_MS
+      ) {
+        records.push({ ...existing, label: credential.label });
+        continue;
+      }
+      const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+      const signal = options.signal
+        ? AbortSignal.any([options.signal, timeout])
+        : timeout;
+      try {
+        const response = await fetch(
+          `${FACTORY_API_BASE_URL}/api/billing/limits`,
+          {
+            headers: {
+              Authorization: `Bearer ${credential.secret}`,
+              "X-Factory-Client": "cli",
+              "X-Client-Version": options.version,
+              ...(credential.headers ?? {}),
+            },
+            signal,
+          },
+        );
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}`);
+        }
+        const body = await response.json();
+        records.push({
+          id,
+          label: credential.label,
+          fetchedAt: Date.now(),
+          attemptedAt: Date.now(),
+          limits: parseLimits(body),
+        });
+      } catch (error) {
+        records.push({
+          id,
+          label: credential.label,
+          fetchedAt: existing?.fetchedAt ?? Date.now(),
+          attemptedAt: Date.now(),
+          limits: existing?.limits,
+          error: error instanceof Error ? error.message.slice(0, 300) : String(error).slice(0, 300),
+        });
+      }
+    }
+    for (const record of cache.records) {
+      if (
+        unique.has(record.id) ||
+        now - record.fetchedAt > CACHE_MAX_AGE_MS
+      ) continue;
+      records.push(record);
+    }
+    saveFactoryLimitCache({ version: 1, records });
+    return records.filter((record) => unique.has(record.id));
+  })().finally(() => {
+    refreshPromise = undefined;
+  });
+  return refreshPromise;
+}
+
+function resetText(
+  bucket: FactoryLimitBucket,
+  now = Date.now(),
+  observedAt = now,
+) {
+  if (!active(bucket, now, observedAt)) return "reset";
+  const resetAt = bucketResetAt(bucket, observedAt);
+  const seconds = resetAt ? Math.max(0, Math.round((resetAt - now) / 1000)) : 0;
+  if (!seconds) return "reset soon";
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  return hours ? `${hours}h${minutes ? ` ${minutes}m` : ""}` : `${minutes}m`;
+}
+
+export function formatPoolLimits(
+  name: "Standard" | "Core",
+  limits: FactoryPoolLimits | undefined,
+  now = Date.now(),
+  observedAt = now,
+) {
+  if (!limits) return `${name}: unavailable`;
+  const exhausted = exhaustedBucket(limits, now, observedAt);
+  if (exhausted === "monthly") {
+    return `${name} used: monthly 100% · resets ${resetText(limits.monthly, now, observedAt)} · weekly/5h inactive`;
+  }
+  if (exhausted === "weekly") {
+    return `${name} used: monthly ${limits.monthly.usedPercent}% · weekly 100% · resets ${resetText(limits.weekly, now, observedAt)} · 5h inactive`;
+  }
+  if (exhausted === "fiveHour") {
+    return `${name} used: monthly ${limits.monthly.usedPercent}% · weekly ${limits.weekly.usedPercent}% · 5h 100% · resets ${resetText(limits.fiveHour, now, observedAt)}`;
+  }
+  const parts = [
+    active(limits.monthly, now, observedAt) ? `M ${limits.monthly.usedPercent}%` : undefined,
+    active(limits.weekly, now, observedAt) ? `W ${limits.weekly.usedPercent}%` : undefined,
+    active(limits.fiveHour, now, observedAt) ? `5h ${limits.fiveHour.usedPercent}%` : undefined,
+  ].filter(Boolean);
+  return `${name} used: ${parts.join(" · ") || "fresh window"}`;
+}
+
+export function formatLimitRecord(record: FactoryLimitRecord, now = Date.now()) {
+  const ageMinutes = Math.max(0, Math.floor((now - record.fetchedAt) / 60_000));
+  const lines = [
+    `${record.label} · ${ageMinutes ? `${ageMinutes}m old` : "just refreshed"}${record.error ? ` · refresh error: ${record.error}` : ""}`,
+    `  ${formatPoolLimits("Standard", record.limits?.standard, now, record.fetchedAt)}`,
+    `  ${formatPoolLimits("Core", record.limits?.core, now, record.fetchedAt)}`,
+  ];
+  return lines;
+}

package/extensions/factory-provider/factory/models.ts

@@ -0,0 +1,283 @@
+import { FACTORY_API_BASE_URL } from "./constants.ts";
+import { droidExecHelp } from "./droid.ts";
+import {
+  billingPoolForModel,
+  type FactoryBillingPool,
+} from "./limits.ts";
+
+export type FactoryModel = {
+  id: string;
+  name: string;
+  reasoning: boolean;
+  supportedReasoningEfforts: string[];
+  defaultReasoningEffort?: string;
+  contextWindow: number;
+  maxTokens: number;
+  images: boolean;
+  pdf: boolean;
+  api: "openai-responses" | "openai-completions" | "anthropic-messages" | "google-generative-ai";
+  baseUrl: string;
+  apiProvider?: string;
+  billingPool: FactoryBillingPool;
+};
+
+type BinaryCapability = Omit<FactoryModel, "id" | "name" | "reasoning" | "supportedReasoningEfforts" | "defaultReasoningEffort" | "api" | "baseUrl" | "apiProvider" | "billingPool"> & Partial<Pick<FactoryModel, "api" | "baseUrl" | "apiProvider">>;
+
+// Tracks the current Droid embedded registry; re-check the active binary after Droid upgrades.
+// Re-check with UPDATING.md when Droid changes. Keep only the latest/current model per
+// family to avoid cluttering Pi's model picker with older Factory models.
+const BINARY_CAPABILITIES: Record<string, BinaryCapability> = {
+  "claude-opus-5": { contextWindow: 867_000, maxTokens: 128_000, images: true, pdf: true },
+  "claude-opus-5-fast": { contextWindow: 867_000, maxTokens: 128_000, images: true, pdf: true },
+  "claude-fable-5": { contextWindow: 867_000, maxTokens: 128_000, images: true, pdf: true },
+  "claude-sonnet-5": { contextWindow: 872_000, maxTokens: 128_000, images: true, pdf: true },
+  "claude-haiku-4-5-20251001": { contextWindow: 180_000, maxTokens: 32_000, images: true, pdf: true },
+  "gpt-5.6-sol": { contextWindow: 1_050_000, maxTokens: 128_000, images: true, pdf: true },
+  "gpt-5.6-terra": { contextWindow: 1_050_000, maxTokens: 128_000, images: true, pdf: true },
+  "gpt-5.6-luna": { contextWindow: 1_050_000, maxTokens: 128_000, images: true, pdf: true },
+  "gpt-5.5-pro": { contextWindow: 1_050_000, maxTokens: 128_000, images: true, pdf: true },
+  "gemini-3.1-pro-preview": { contextWindow: 1_000_000, maxTokens: 65_536, images: true, pdf: true },
+  "gemini-3.7-flash": { contextWindow: 1_000_000, maxTokens: 65_536, images: true, pdf: true },
+  "grok-4.5": { contextWindow: 200_000, maxTokens: 63_356, images: true, pdf: false },
+  "grok-4.6": { contextWindow: 200_000, maxTokens: 63_356, images: true, pdf: false },
+  "minimax-m3": { contextWindow: 512_000, maxTokens: 64_000, images: true, pdf: false },
+  "glm-5.2": { contextWindow: 1_040_000, maxTokens: 131_072, images: false, pdf: false },
+  "glm-5.2-fast": { contextWindow: 524_288, maxTokens: 131_072, images: false, pdf: false },
+  // Kimi documents a 1,048,576-token context and a 131,072-token default
+  // completion limit. Droid 0.200.0 still embeds a conservative 262,144/65,536
+  // proxy entry, so keep this explicit product-capability override.
+  "kimi-k3": { contextWindow: 1_048_576, maxTokens: 131_072, images: true, pdf: false },
+  "inkling": { contextWindow: 1_040_000, maxTokens: 32_768, images: true, pdf: false },
+  "nemotron-3-ultra": { contextWindow: 202_000, maxTokens: 65_536, images: false, pdf: false },
+  "deepseek-v4-flash-0731": { contextWindow: 1_040_000, maxTokens: 131_072, images: false, pdf: false },
+  "deepseek-v4-pro": { contextWindow: 1_040_000, maxTokens: 65_536, images: false, pdf: false },
+};
+
+const HIDDEN_MODEL_IDS = new Set([
+  "claude-haiku-4-5-20251001",
+  "claude-opus-5",
+  "gemini-3.1-pro-preview",
+  "glm-5.2-fast",
+  "inkling",
+  "minimax-m3",
+  "nemotron-3-ultra",
+]);
+
+const ACTIVE_MODEL_IDS = new Set(Object.keys(BINARY_CAPABILITIES).filter((id) =>
+  !id.endsWith("-fast") && !HIDDEN_MODEL_IDS.has(id),
+));
+
+// OpenRouter provider telemetry checked 2026-07-29. Prefer throughput and
+// latency, with uptime and available context as reliability constraints.
+const FACTORY_CORE_PROVIDER_OVERRIDES: Record<string, "fireworks" | "baseten"> = {
+  "kimi-k3": "fireworks",
+  "glm-5.2": "baseten",
+  "glm-5.2-fast": "fireworks",
+  "inkling": "fireworks",
+  "deepseek-v4-flash-0731": "fireworks",
+  "deepseek-v4-pro": "fireworks",
+  "nemotron-3-ultra": "baseten",
+};
+
+const FACTORY_OPENAI_BASE_URL = `${FACTORY_API_BASE_URL}/api/llm/o/v1`;
+const FACTORY_ANTHROPIC_BASE_URL = `${FACTORY_API_BASE_URL}/api/llm/a`;
+const FACTORY_GEMINI_BASE_URL = `${FACTORY_API_BASE_URL}/api/llm/g/v1`;
+
+const DEFAULT_CAPABILITIES: BinaryCapability = { contextWindow: 200_000, maxTokens: 64_000, images: true, pdf: false, api: "openai-responses", baseUrl: FACTORY_OPENAI_BASE_URL };
+
+const FALLBACK_REASONING: Record<string, { supported: string[]; default: string }> = {
+  "claude-opus-5": { supported: ["off", "low", "medium", "high", "xhigh", "max"], default: "high" },
+  "claude-opus-5-fast": { supported: ["off", "low", "medium", "high", "xhigh", "max"], default: "high" },
+  "claude-fable-5": { supported: ["off", "low", "medium", "high", "xhigh", "max"], default: "high" },
+  "claude-sonnet-5": { supported: ["off", "low", "medium", "high", "xhigh", "max"], default: "high" },
+  "claude-haiku-4-5-20251001": { supported: ["off", "low", "medium", "high"], default: "off" },
+  "gpt-5.6-sol": { supported: ["none", "low", "medium", "high", "xhigh", "max"], default: "medium" },
+  "gpt-5.6-terra": { supported: ["none", "low", "medium", "high", "xhigh", "max"], default: "medium" },
+  "gpt-5.6-luna": { supported: ["none", "low", "medium", "high", "xhigh", "max"], default: "medium" },
+  "gpt-5.5-pro": { supported: ["medium", "high", "xhigh"], default: "medium" },
+  "gemini-3.7-flash": { supported: ["low", "medium", "high"], default: "high" },
+  "grok-4.5": { supported: ["low", "medium", "high"], default: "high" },
+  "grok-4.6": { supported: ["low", "medium", "high", "xhigh"], default: "high" },
+  "minimax-m3": { supported: ["high"], default: "high" },
+  "inkling": { supported: ["off", "minimal", "low", "medium", "high", "xhigh", "max"], default: "high" },
+  "deepseek-v4-flash-0731": { supported: ["off", "low", "high", "max"], default: "high" },
+  "deepseek-v4-pro": { supported: ["off", "low", "high", "max"], default: "high" },
+  "glm-5.2": { supported: ["off", "high", "max"], default: "high" },
+  "glm-5.2-fast": { supported: ["off", "high", "max"], default: "high" },
+  "kimi-k3": { supported: ["off", "low", "high", "max"], default: "high" },
+  // Live Factory streaming rejects reasoning_effort="off" for Nemotron and reports
+  // the accepted disable token as `none`; keep this as an API-truth override.
+  "nemotron-3-ultra": { supported: ["off", "high"], default: "high" },
+};
+
+export const DROID_MODELS_FALLBACK: FactoryModel[] = Object.entries(BINARY_CAPABILITIES).filter(([id]) => ACTIVE_MODEL_IDS.has(id)).map(([id, capability]) => {
+  const reasoning = FALLBACK_REASONING[id] || fallbackReasoning(id);
+  return {
+    id,
+    name: fallbackName(id),
+    reasoning: reasoning.supported.some((effort) => effort !== "none" && effort !== "off"),
+    supportedReasoningEfforts: reasoning.supported,
+    defaultReasoningEffort: reasoning.default,
+    ...capability,
+    ...familyForModel(id),
+    billingPool: billingPoolForModel(id),
+  } as FactoryModel;
+});
+
+function fallbackName(id: string) {
+  const fromHelp = id
+    .replace(/-/g, " ")
+    .replace(/\bgpt\b/i, "GPT")
+    .replace(/\bgrok\b/i, "Grok")
+    .replace(/\bsol\b/i, "Sol")
+    .replace(/\bterra\b/i, "Terra")
+    .replace(/\bluna\b/i, "Luna")
+    .replace(/\bglm\b/i, "GLM")
+    .replace(/\bkimi\b/i, "Kimi")
+    .replace(/\bdeepseek\b/i, "DeepSeek")
+    .replace(/\binkling\b/i, "Inkling")
+    .replace(/\bclaude\b/i, "Claude")
+    .replace(/\bopus\b/i, "Opus")
+    .replace(/\bfable\b/i, "Fable")
+    .replace(/\bsonnet\b/i, "Sonnet")
+    .replace(/\bhaiku\b/i, "Haiku")
+    .replace(/\bfast\b/i, "Fast Mode")
+    .replace(/\bpro\b/i, "Pro")
+    .replace(/\bcodex\b/i, "Codex");
+  return fromHelp.replace(/\s+/g, " ").trim();
+}
+
+function fallbackReasoning(id: string) {
+  if (id.startsWith("gpt-5.2")) return { supported: ["off", "low", "medium", "high", "xhigh"], default: "low" };
+  if (id.startsWith("gpt-")) return { supported: ["low", "medium", "high", "xhigh"], default: "medium" };
+  if (id.startsWith("gemini-3.1")) return { supported: ["low", "medium", "high"], default: "high" };
+  if (id.startsWith("gemini-")) return { supported: ["minimal", "low", "medium", "high"], default: "high" };
+  if (id.startsWith("glm-5.2")) return { supported: ["off", "high", "max"], default: "high" };
+  if (id.startsWith("glm-") || id.startsWith("kimi-") || id.startsWith("nemotron-")) return { supported: ["off", "high"], default: "high" };
+  if (id.startsWith("deepseek-")) return { supported: ["off", "low", "high", "max"], default: "high" };
+  if (id.startsWith("minimax-m2.5")) return { supported: ["low", "medium", "high"], default: "high" };
+  if (id.includes("4-5")) return { supported: ["off", "low", "medium", "high"], default: "off" };
+  return { supported: ["off", "low", "medium", "high"], default: "high" };
+}
+
+export function factoryApiForModel(id: string) {
+  if (id.startsWith("claude-") || id.startsWith("minimax-")) return "anthropic-messages";
+  if (id.startsWith("gemini-")) return "google-generative-ai";
+  if (id === "inkling" || id.startsWith("kimi-") || id.startsWith("glm-") || id.startsWith("deepseek-") || id.startsWith("nemotron-")) return "openai-completions";
+  return "openai-responses";
+}
+
+function familyForModel(id: string): Pick<BinaryCapability, "api" | "baseUrl" | "apiProvider"> {
+  const api = factoryApiForModel(id);
+  if (api === "anthropic-messages") {
+    return { api, baseUrl: FACTORY_ANTHROPIC_BASE_URL, apiProvider: id.startsWith("minimax-") ? "fireworks" : "bedrock_anthropic" };
+  }
+  if (api === "google-generative-ai") return { api, baseUrl: FACTORY_GEMINI_BASE_URL, apiProvider: "google" };
+  if (api === "openai-completions") {
+    return { api, baseUrl: FACTORY_OPENAI_BASE_URL, apiProvider: FACTORY_CORE_PROVIDER_OVERRIDES[id] || "fireworks" };
+  }
+  return { api, baseUrl: FACTORY_OPENAI_BASE_URL, apiProvider: id.startsWith("grok-") ? "xai" : "openai" };
+}
+
+function capabilityForModel(id: string): Required<Pick<FactoryModel, "api" | "baseUrl">> & BinaryCapability {
+  return { ...(BINARY_CAPABILITIES[id] || DEFAULT_CAPABILITIES), ...familyForModel(id) } as Required<Pick<FactoryModel, "api" | "baseUrl">> & BinaryCapability;
+}
+
+function normalizeDisplayName(name: string) {
+  return name
+    .replace(/\s*\(default\)\s*$/, "")
+    .replace(/\s+\[Deprecated\]\s*$/, "")
+    .replace(/^Droid Core\s*\((.+)\)$/i, "$1")
+    .trim();
+}
+
+function comparableDisplayName(name: string) {
+  return normalizeDisplayName(name).toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+
+export function parseModelsFromDroidHelp(): FactoryModel[] {
+  try {
+    const help = droidExecHelp();
+    const modelSection = help.split("Available Models:")[1]?.split("Model details:")[0] || "";
+    const detailSection = help.split("Model details:")[1]?.split("Authentication:")[0] || "";
+    const models = new Map<string, FactoryModel>();
+    for (const line of modelSection.split(/\r?\n/)) {
+      const match = line.match(/^\s{2}([^\s]+)\s{2,}(.+?)\s*(?:\[Deprecated\])?\s*$/);
+      if (!match) continue;
+      const id = match[1];
+      if (!ACTIVE_MODEL_IDS.has(id)) continue;
+      const reasoning = FALLBACK_REASONING[id] || fallbackReasoning(id);
+      models.set(id, {
+        id,
+        name: normalizeDisplayName(match[2]),
+        reasoning: reasoning.supported.some((effort) => effort !== "none" && effort !== "off"),
+        supportedReasoningEfforts: reasoning.supported,
+        defaultReasoningEffort: reasoning.default,
+        ...capabilityForModel(id),
+        billingPool: /\(Droid Core\)/i.test(match[2])
+          ? "core"
+          : billingPoolForModel(id),
+      });
+    }
+    for (const line of detailSection.split(/\r?\n/)) {
+      const match = line.match(/^\s*-\s+(.+?): supports reasoning: (Yes|No); supported: \[([^\]]*)\]; default: ([^\s]+)/);
+      if (!match) continue;
+      const detailName = comparableDisplayName(match[1]);
+      const byName = [...models.values()].find((model) => comparableDisplayName(model.name) === detailName);
+      if (!byName) continue;
+      byName.supportedReasoningEfforts = match[3].split(",").map((effort) => effort.trim()).filter(Boolean);
+      byName.defaultReasoningEffort = match[4];
+      byName.reasoning = match[2] === "Yes";
+    }
+    if (!models.size) return DROID_MODELS_FALLBACK;
+    for (const fallback of DROID_MODELS_FALLBACK) {
+      if (!models.has(fallback.id)) models.set(fallback.id, fallback);
+    }
+    return [...models.values()];
+  } catch {
+    return DROID_MODELS_FALLBACK;
+  }
+}
+
+function thinkingMap(model: FactoryModel) {
+  const supported = model.supportedReasoningEfforts;
+  const levels = ["off", "none", "minimal", "low", "medium", "high", "xhigh", "max"];
+  // Droid exposes Nemotron's disabled effort as `off`, while Factory's
+  // Baseten wire endpoint accepts the equivalent token `none`.
+  const disableLevel = model.id === "nemotron-3-ultra"
+    ? "none"
+    : supported.includes("none")
+      ? "none"
+      : supported.includes("off")
+        ? "off"
+        : null;
+  return Object.fromEntries(levels.map((level) => {
+    if (model.id === "nemotron-3-ultra" && (level === "off" || level === "none")) return [level, "none"];
+    const providerLevel = level === "off" || level === "none" ? disableLevel : level;
+    return [level, providerLevel && supported.includes(providerLevel) ? providerLevel : null];
+  }));
+}
+
+export function toPiModel(model: FactoryModel) {
+  return {
+    id: model.id,
+    name:
+      model.billingPool === "core" && !/Droid Core/i.test(model.name)
+        ? `${model.name} (Droid Core)`
+        : model.name,
+    baseUrl: model.baseUrl,
+    headers: model.apiProvider ? { "x-api-provider": model.apiProvider } : undefined,
+    reasoning: model.reasoning,
+    input: model.images ? ["text", "image"] : ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+    compat: {
+      supportsReasoningEffort: model.reasoning,
+      supportsDeveloperRole: false,
+      supportsPdf: model.pdf,
+      ...(model.api === "anthropic-messages" ? { forceAdaptiveThinking: true } : {}),
+    },
+    thinkingLevelMap: thinkingMap(model),
+  };
+}