@theokit/sdk 4.24.0 → 4.26.0

package/dist/chunk-KAP4GJHO.js

@@ -0,0 +1,546 @@
+import { resolveCredential, readStoredOAuth } from './chunk-LU7VALW5.js';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+import { homedir } from 'os';
+
+// src/internal/global-singleton.ts
+function globalSingleton(key, create) {
+  const g = globalThis;
+  const sym = Symbol.for(key);
+  if (g[sym] === void 0) g[sym] = create();
+  return g[sym];
+}
+
+// src/internal/providers/registry.ts
+var REGISTRY = globalSingleton(
+  "theokit-sdk.providers.registry",
+  () => /* @__PURE__ */ new Map()
+);
+var ALIASES = globalSingleton("theokit-sdk.providers.aliases", () => /* @__PURE__ */ new Map());
+function registerProvider(profile) {
+  if (REGISTRY.has(profile.name)) {
+    process.stderr.write(`[theokit-sdk] Provider "${profile.name}" overridden by user plugin.
+`);
+  }
+  REGISTRY.set(profile.name, profile);
+  for (const alias of profile.aliases ?? []) {
+    const previous = ALIASES.get(alias);
+    if (previous !== void 0 && previous !== profile.name) {
+      process.stderr.write(
+        `[theokit-sdk] Alias "${alias}" collision: was "${previous}", now "${profile.name}".
+`
+      );
+    }
+    ALIASES.set(alias, profile.name);
+  }
+}
+function getProviderProfile(name) {
+  const canonical = ALIASES.get(name) ?? name;
+  return REGISTRY.get(canonical);
+}
+function listProviders() {
+  return Array.from(REGISTRY.values());
+}
+var MODALITIES = ["text", "audio", "image", "video", "pdf"];
+var costSchema = z.object({
+  /** USD per 1M tokens (models.dev convention). */
+  input: z.number().nonnegative(),
+  output: z.number().nonnegative(),
+  cache_read: z.number().nonnegative().optional(),
+  cache_write: z.number().nonnegative().optional()
+}).loose();
+var limitSchema = z.object({
+  context: z.number().positive(),
+  input: z.number().positive().optional(),
+  output: z.number().positive().optional()
+}).loose();
+var modalitiesSchema = z.object({
+  input: z.array(z.enum(MODALITIES)).optional(),
+  output: z.array(z.enum(MODALITIES)).optional()
+}).loose();
+var catalogModelSchema = z.object({
+  name: z.string().optional(),
+  release_date: z.string().optional(),
+  attachment: z.boolean().optional(),
+  reasoning: z.boolean().optional(),
+  temperature: z.boolean().optional(),
+  tool_call: z.boolean().optional(),
+  /** theokit extension — maps to ModelCapabilities.supportsStructuredOutput. */
+  structured_output: z.boolean().optional(),
+  /** theokit extension — maps to ModelCapabilities.supportsCacheControl. */
+  cache_control: z.boolean().optional(),
+  cost: costSchema.optional(),
+  limit: limitSchema.optional(),
+  modalities: modalitiesSchema.optional(),
+  status: z.enum(["alpha", "beta", "deprecated"]).optional()
+}).loose();
+
+// src/internal/providers/catalog-loader.ts
+var __dirname_resolved = dirname(fileURLToPath(import.meta.url));
+var modelInfoIndex = globalSingleton(
+  "theokit-sdk.providers.model-info-index",
+  () => /* @__PURE__ */ new Map()
+);
+var patchedModelKeys = globalSingleton(
+  "theokit-sdk.providers.model-info-patched",
+  () => /* @__PURE__ */ new Set()
+);
+var indexState = globalSingleton("theokit-sdk.providers.model-info-loaded", () => ({
+  loaded: false
+}));
+function getCatalogModelInfo(key) {
+  ensureModelIndexLoaded();
+  return modelInfoIndex.get(key);
+}
+function isPatchedModelKey(key) {
+  return patchedModelKeys.has(key);
+}
+function patchModelInfo(key, model) {
+  ensureModelIndexLoaded();
+  const existing = modelInfoIndex.get(key);
+  modelInfoIndex.set(key, existing === void 0 ? model : { ...existing, ...model });
+  patchedModelKeys.add(key);
+}
+function ensureModelIndexLoaded() {
+  if (indexState.loaded) return;
+  indexState.loaded = true;
+  try {
+    const catalog = loadProviderCatalog();
+    for (const entry of Object.values(catalog)) {
+      indexEntryModels(entry);
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[theokit-sdk] WARN: provider catalog unavailable (${err.message}) \u2014 per-model data disabled
+`
+    );
+  }
+}
+function indexEntryModels(entry) {
+  if (entry.models === void 0 || typeof entry.models !== "object") return;
+  for (const [modelId, raw] of Object.entries(entry.models)) {
+    const parsed = catalogModelSchema.safeParse(raw);
+    if (!parsed.success) {
+      process.stderr.write(
+        `[theokit-sdk] WARN: Skipping malformed catalog model "${entry.id}/${modelId}": ${parsed.error.issues[0]?.message ?? "invalid"}
+`
+      );
+      continue;
+    }
+    modelInfoIndex.set(`${entry.id}/${modelId}`, parsed.data);
+    for (const alias of entry.aliases ?? []) {
+      const key = `${alias}/${modelId}`;
+      if (!modelInfoIndex.has(key)) modelInfoIndex.set(key, parsed.data);
+    }
+  }
+}
+function validateEntry(raw) {
+  if (typeof raw.id !== "string" || typeof raw.displayName !== "string" || typeof raw.apiMode !== "string" || typeof raw.authType !== "string" || typeof raw.baseUrl !== "string" || !Array.isArray(raw.envVars) || !Array.isArray(raw.fallbackModels) || raw.capabilities == null || typeof raw.capabilities !== "object") {
+    return null;
+  }
+  return raw;
+}
+function loadProviderCatalog(opts) {
+  const catalogPath = join(__dirname_resolved, "provider-catalog.json");
+  const rawText = readFileSync(catalogPath, "utf-8");
+  let entries = JSON.parse(rawText);
+  if (opts?._testInjectMalformed) {
+    entries = [
+      ...entries,
+      { id: "malformed-provider", displayName: "Bad" }
+    ];
+  }
+  const result = {};
+  for (const raw of entries) {
+    const validated = validateEntry(raw);
+    if (validated === null) {
+      process.stderr.write(
+        `[theokit-sdk] WARN: Skipping malformed catalog entry: ${JSON.stringify(raw).slice(0, 100)}
+`
+      );
+      continue;
+    }
+    result[validated.id] = validated;
+  }
+  return result;
+}
+var _capabilitiesCache = null;
+function getCatalogCapabilities(providerId) {
+  if (_capabilitiesCache === null) {
+    const catalog = loadProviderCatalog();
+    _capabilitiesCache = {};
+    for (const entry of Object.values(catalog)) {
+      _capabilitiesCache[entry.id] = entry.capabilities;
+      for (const alias of entry.aliases ?? []) {
+        if (_capabilitiesCache[alias] === void 0) _capabilitiesCache[alias] = entry.capabilities;
+      }
+    }
+  }
+  return _capabilitiesCache[providerId];
+}
+function registerCatalogProviders(opts) {
+  const catalog = loadProviderCatalog(opts);
+  for (const entry of Object.values(catalog)) {
+    if (getProviderProfile(entry.id) !== void 0) continue;
+    if (entry.aliases?.some((a) => getProviderProfile(a) !== void 0)) continue;
+    const profile = {
+      name: entry.id,
+      apiMode: entry.apiMode,
+      authType: entry.authType,
+      baseUrl: entry.baseUrl,
+      envVars: entry.envVars,
+      fallbackModels: entry.fallbackModels,
+      displayName: entry.displayName,
+      aliases: entry.aliases,
+      modelsUrl: entry.modelsUrl,
+      hostname: entry.hostname,
+      extraHeaders: entry.extraHeaders
+    };
+    registerProvider(profile);
+  }
+}
+
+// src/internal/providers/builtin/anthropic.ts
+var ANTHROPIC = {
+  name: "anthropic",
+  apiMode: "anthropic_messages",
+  envVars: ["ANTHROPIC_API_KEY"],
+  authType: "api_key",
+  baseUrl: "https://api.anthropic.com",
+  modelsUrl: "https://api.anthropic.com/v1/models",
+  hostname: "api.anthropic.com",
+  fallbackModels: ["claude-opus-4-7", "claude-sonnet-4-6", "claude-haiku-4-5-20251001"],
+  // M45 — the Anthropic beta-features header (interleaved thinking + fine-grained tool streaming). An
+  // Anthropic API constant, adapted verbatim from OpenCode's anthropic plugin (MIT © 2025 opencode). The
+  // SANCTIONED behavior delta of M45 (ADR D4) — consumed by the anthropic transport's extraHeaders wiring.
+  extraHeaders: {
+    "anthropic-beta": "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14"
+  }
+};
+
+// src/internal/providers/builtin/bedrock.ts
+var BEDROCK = {
+  name: "bedrock",
+  apiMode: "bedrock_anthropic",
+  envVars: ["AWS_BEARER_TOKEN_BEDROCK"],
+  authType: "aws_bearer",
+  baseUrl: "https://bedrock-runtime.us-east-1.amazonaws.com",
+  modelsUrl: void 0,
+  hostname: "bedrock-runtime.amazonaws.com",
+  fallbackModels: [
+    "bedrock/us.anthropic.claude-sonnet-4-5-v1:0",
+    "bedrock/us.anthropic.claude-opus-4-7-v1:0",
+    "bedrock/global.anthropic.claude-haiku-4-5-v1:0"
+  ]
+};
+function stripBedrockPrefix(modelId) {
+  return modelId.replace(/^bedrock\//, "");
+}
+function inferRegionFromModelId(modelId) {
+  const id = stripBedrockPrefix(modelId);
+  if (id.startsWith("global.")) return "us-east-1";
+  if (id.startsWith("us.")) return process.env.AWS_REGION ?? "us-east-1";
+  if (id.startsWith("eu.")) return process.env.AWS_REGION ?? "eu-west-1";
+  if (id.startsWith("apac.")) return process.env.AWS_REGION ?? "ap-southeast-1";
+  if (id.startsWith("jp.")) return "ap-northeast-1";
+  return void 0;
+}
+function resolveBedrockBaseUrl(modelId) {
+  const region = inferRegionFromModelId(modelId) ?? process.env.AWS_REGION ?? "us-east-1";
+  return `https://bedrock-runtime.${region}.amazonaws.com`;
+}
+
+// src/internal/providers/builtin/openai-compatible.ts
+function openAiCompatibleProfile(p) {
+  return {
+    apiMode: "chat_completions",
+    authType: "api_key",
+    fallbackModels: [],
+    ...p
+  };
+}
+
+// src/internal/providers/builtin/cerebras.ts
+var CEREBRAS = openAiCompatibleProfile({
+  name: "cerebras",
+  baseUrl: "https://api.cerebras.ai/v1",
+  envVars: ["CEREBRAS_API_KEY"],
+  fallbackModels: ["gpt-oss-120b", "zai-glm-4.7"],
+  extraHeaders: { "X-Cerebras-3rd-Party-Integration": "theokit" },
+  hostname: "api.cerebras.ai"
+});
+
+// src/internal/providers/builtin/cohere.ts
+var COHERE = openAiCompatibleProfile({
+  name: "cohere",
+  baseUrl: "https://api.cohere.ai/compatibility/v1",
+  envVars: ["COHERE_API_KEY", "CO_API_KEY"],
+  fallbackModels: ["command-a-03-2025"],
+  hostname: "api.cohere.ai"
+});
+
+// src/internal/providers/builtin/deepinfra.ts
+var DEEPINFRA = openAiCompatibleProfile({
+  name: "deepinfra",
+  baseUrl: "https://api.deepinfra.com/v1/openai",
+  envVars: ["DEEPINFRA_API_KEY"],
+  fallbackModels: ["Qwen/Qwen3-32B"],
+  hostname: "api.deepinfra.com"
+});
+
+// src/internal/providers/builtin/gemini.ts
+var GEMINI = {
+  name: "gemini",
+  apiMode: "chat_completions",
+  envVars: ["OPENROUTER_API_KEY"],
+  authType: "api_key",
+  baseUrl: "https://openrouter.ai/api",
+  hostname: "openrouter.ai",
+  fallbackModels: ["google/gemini-2.0-flash-001"]
+};
+
+// src/internal/providers/builtin/google.ts
+var GOOGLE = openAiCompatibleProfile({
+  name: "google",
+  baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+  envVars: ["GOOGLE_API_KEY", "GEMINI_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
+  fallbackModels: ["gemini-2.5-pro", "gemini-2.5-flash"],
+  hostname: "generativelanguage.googleapis.com"
+});
+
+// src/internal/providers/builtin/groq.ts
+var GROQ = openAiCompatibleProfile({
+  name: "groq",
+  baseUrl: "https://api.groq.com/openai/v1",
+  envVars: ["GROQ_API_KEY"],
+  fallbackModels: ["llama-3.3-70b-versatile", "llama-3.1-8b-instant"],
+  hostname: "api.groq.com"
+});
+
+// src/internal/providers/builtin/llamacpp.ts
+var LLAMACPP = {
+  name: "llamacpp",
+  aliases: ["llama-cpp", "llama.cpp"],
+  apiMode: "chat_completions",
+  envVars: ["LLAMACPP_API_KEY"],
+  authType: "none",
+  baseUrl: "http://localhost:8080",
+  modelsUrl: "http://localhost:8080/v1/models",
+  hostname: "localhost",
+  fallbackModels: ["loaded-model"]
+};
+
+// src/internal/providers/builtin/lmstudio.ts
+var LMSTUDIO = {
+  name: "lmstudio",
+  aliases: ["lm-studio", "lm_studio"],
+  apiMode: "chat_completions",
+  envVars: ["LMSTUDIO_API_KEY"],
+  authType: "none",
+  baseUrl: "http://localhost:1234",
+  modelsUrl: "http://localhost:1234/v1/models",
+  hostname: "localhost",
+  fallbackModels: ["loaded-model"]
+};
+
+// src/internal/providers/builtin/mistral.ts
+var MISTRAL = openAiCompatibleProfile({
+  name: "mistral",
+  baseUrl: "https://api.mistral.ai/v1",
+  envVars: ["MISTRAL_API_KEY"],
+  fallbackModels: ["mistral-large-latest", "codestral-latest"],
+  hostname: "api.mistral.ai"
+});
+
+// src/internal/providers/builtin/ollama.ts
+var OLLAMA = {
+  name: "ollama",
+  apiMode: "chat_completions",
+  envVars: ["OLLAMA_API_KEY"],
+  authType: "none",
+  baseUrl: "http://localhost:11434",
+  modelsUrl: "http://localhost:11434/v1/models",
+  hostname: "localhost",
+  fallbackModels: ["llama3.2", "qwen2.5", "mistral"]
+};
+
+// src/internal/providers/builtin/openai.ts
+var OPENAI = {
+  name: "openai",
+  apiMode: "chat_completions",
+  envVars: ["OPENAI_API_KEY"],
+  authType: "api_key",
+  baseUrl: "https://api.openai.com",
+  modelsUrl: "https://api.openai.com/v1/models",
+  hostname: "api.openai.com",
+  fallbackModels: ["gpt-4o", "gpt-4o-mini"]
+};
+var DEFAULT_STORE = {
+  home: homedir(),
+  dirName: ".theokit",
+  fileName: "auth.json",
+  homeEnvVar: "THEOKIT_AUTH_HOME"
+};
+var OPENAI_OAUTH_CONFIG = {
+  provider: "openai",
+  authorizeEndpoint: "https://auth.openai.com/oauth/authorize",
+  tokenEndpoint: "https://auth.openai.com/oauth/token",
+  clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+  scopes: ["openid", "profile", "email", "offline_access"],
+  redirectUri: "https://auth.openai.com/deviceauth/callback"
+};
+function codexFetch() {
+  return (async (input, init) => {
+    const env = process.env;
+    const resolved = await resolveCredential({
+      provider: "openai",
+      store: DEFAULT_STORE,
+      oauth: OPENAI_OAUTH_CONFIG,
+      env
+    });
+    if (resolved === void 0) {
+      throw new Error(
+        'openai-chatgpt: no ChatGPT credential found \u2014 run the OpenAI device login (e.g. "/login openai") first.'
+      );
+    }
+    const accountId = readStoredOAuth(DEFAULT_STORE, env)?.account_id;
+    const headers = new Headers(init?.headers);
+    headers.set("authorization", `Bearer ${resolved.apiKey}`);
+    if (accountId !== void 0) headers.set("ChatGPT-Account-Id", accountId);
+    return fetch(input, { ...init, headers });
+  });
+}
+var OPENAI_CHATGPT = {
+  name: "openai-chatgpt",
+  apiMode: "responses_api",
+  authType: "oauth_device_code",
+  baseUrl: "https://chatgpt.com/backend-api/codex",
+  envVars: [],
+  fallbackModels: [
+    "openai-chatgpt/gpt-5.4",
+    "openai-chatgpt/gpt-5.4-mini",
+    "openai-chatgpt/gpt-5.5"
+  ],
+  extraHeaders: { originator: "codex_cli_rs" },
+  transform: {
+    // Only `fetch` (async) can await the credential refresh; `headers` is sync and cannot.
+    fetch: () => codexFetch()
+  }
+};
+
+// src/internal/providers/builtin/openrouter.ts
+var OPENROUTER = {
+  name: "openrouter",
+  apiMode: "chat_completions",
+  aliases: ["or"],
+  // Ordered fallback (EC-10): OPENROUTER_API_KEY preferred, OPENAI_API_KEY as compat.
+  envVars: ["OPENROUTER_API_KEY", "OPENAI_API_KEY"],
+  authType: "api_key",
+  baseUrl: "https://openrouter.ai/api",
+  modelsUrl: "https://openrouter.ai/api/v1/models",
+  hostname: "openrouter.ai",
+  // M45 — models refreshed (claude-3-haiku retired upstream).
+  fallbackModels: ["openai/gpt-4o-mini", "anthropic/claude-haiku-4-5"],
+  // M45 — OpenRouter app-attribution headers (mechanism from OpenCode's openrouter plugin, MIT; VALUES are
+  // theokit's own — copying another app's referer would misattribute traffic).
+  extraHeaders: { "HTTP-Referer": "https://usetheo.dev", "X-Title": "theokit" }
+};
+
+// src/internal/providers/builtin/perplexity.ts
+var PERPLEXITY = openAiCompatibleProfile({
+  name: "perplexity",
+  baseUrl: "https://api.perplexity.ai",
+  chatCompletionsPath: "/chat/completions",
+  envVars: ["PERPLEXITY_API_KEY"],
+  fallbackModels: ["sonar-pro", "sonar"],
+  hostname: "api.perplexity.ai"
+});
+
+// src/internal/providers/builtin/together.ts
+var TOGETHER = openAiCompatibleProfile({
+  name: "together",
+  aliases: ["togetherai"],
+  baseUrl: "https://api.together.xyz/v1",
+  envVars: ["TOGETHER_API_KEY"],
+  fallbackModels: ["Qwen/Qwen2.5-7B-Instruct-Turbo"],
+  hostname: "api.together.xyz"
+});
+
+// src/internal/providers/builtin/vertex.ts
+var VERTEX = {
+  name: "vertex",
+  apiMode: "anthropic_messages",
+  // sub-dispatched in selectTransport by profile.name
+  envVars: ["GOOGLE_APPLICATION_CREDENTIALS"],
+  authType: "gcp_oauth",
+  baseUrl: "https://us-central1-aiplatform.googleapis.com",
+  modelsUrl: void 0,
+  hostname: "aiplatform.googleapis.com",
+  fallbackModels: [
+    "vertex/anthropic/claude-sonnet-4-5@20250929",
+    "vertex/google/gemini-2.0-flash-001"
+  ]
+};
+function resolveVertexBaseUrl(opts) {
+  const host = opts.location === "global" ? "aiplatform.googleapis.com" : `${opts.location}-aiplatform.googleapis.com`;
+  if (opts.modelDialect === "gemini") {
+    return `https://${host}/v1/projects/${opts.projectId}/locations/${opts.location}/endpoints/openapi`;
+  }
+  return `https://${host}/v1/projects/${opts.projectId}/locations/${opts.location}/publishers/anthropic`;
+}
+function inferModelDialect(modelId) {
+  if (modelId.includes("/anthropic/")) return "anthropic";
+  if (modelId.includes("/google/")) return "gemini";
+  return "gemini";
+}
+function stripVertexPrefix(modelId) {
+  return modelId.replace(/^vertex\/(anthropic|google)\//, "");
+}
+
+// src/internal/providers/builtin/xai.ts
+var XAI = openAiCompatibleProfile({
+  name: "xai",
+  aliases: ["grok"],
+  baseUrl: "https://api.x.ai/v1",
+  envVars: ["XAI_API_KEY"],
+  fallbackModels: ["grok-4.5", "grok-4.3"],
+  hostname: "api.x.ai"
+});
+
+// src/internal/providers/builtin/index.ts
+var _registeredState = (() => {
+  const g = globalThis;
+  const sym = /* @__PURE__ */ Symbol.for("theokit-sdk.providers.builtins-registered");
+  if (g[sym] === void 0) g[sym] = { done: false };
+  return g[sym];
+})();
+function registerBuiltins() {
+  if (_registeredState.done) return;
+  _registeredState.done = true;
+  registerProvider(ANTHROPIC);
+  registerProvider(OPENAI);
+  registerProvider(OPENAI_CHATGPT);
+  registerProvider(OPENROUTER);
+  registerProvider(GEMINI);
+  registerProvider(OLLAMA);
+  registerProvider(LMSTUDIO);
+  registerProvider(LLAMACPP);
+  registerProvider(BEDROCK);
+  registerProvider(VERTEX);
+  registerProvider(GOOGLE);
+  registerProvider(MISTRAL);
+  registerProvider(GROQ);
+  registerProvider(COHERE);
+  registerProvider(DEEPINFRA);
+  registerProvider(TOGETHER);
+  registerProvider(XAI);
+  registerProvider(PERPLEXITY);
+  registerProvider(CEREBRAS);
+  registerCatalogProviders();
+}
+
+export { catalogModelSchema, getCatalogCapabilities, getCatalogModelInfo, getProviderProfile, globalSingleton, inferModelDialect, inferRegionFromModelId, isPatchedModelKey, listProviders, loadProviderCatalog, patchModelInfo, registerBuiltins, registerProvider, resolveBedrockBaseUrl, resolveVertexBaseUrl, stripBedrockPrefix, stripVertexPrefix };
+//# sourceMappingURL=chunk-KAP4GJHO.js.map
+//# sourceMappingURL=chunk-KAP4GJHO.js.map