@theokit/sdk 4.15.0 → 4.15.2

package/dist/eval.js

@@ -1,13 +1,13 @@
 import { z, toJSONSchema } from 'zod';
 import { createRequire } from 'module';
 import { randomUUID, createHash, randomBytes } from 'crypto';
-import { mkdir, writeFile, stat, readFile, rename, readdir, open, unlink, statfs, access } from 'fs/promises';
+import { mkdir, writeFile, readdir, stat, readFile, rename, open, unlink, statfs, access } from 'fs/promises';
 import { join, dirname, resolve, sep, relative, isAbsolute } from 'path';
-import { readFileSync, mkdirSync, appendFileSync, existsSync, realpathSync, lstatSync, readlinkSync, readdirSync, statSync, chmodSync, openSync, writeFileSync, fsyncSync, closeSync, renameSync, unlinkSync } from 'fs';
+import { readFileSync, existsSync, mkdirSync, appendFileSync, realpathSync, lstatSync, readlinkSync, statSync, chmodSync, openSync, writeFileSync, fsyncSync, closeSync, renameSync, unlinkSync, readdirSync } from 'fs';
 import { AsyncLocalStorage } from 'async_hooks';
 import { homedir } from 'os';
 import { execFile, spawn } from 'child_process';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -8932,14 +8932,14 @@ var PluginsManager = class {
   // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: MD-first + JSON fallback + both-present detection per plugin folder — branch table is clearer inlined.
   async refresh() {
     this.plugins = [];
-    const pluginsRoot = join(this.cwd, ".theokit", "plugins");
-    const entries = await readWorkspaceDir(pluginsRoot, "plugins_read_error", "plugins directory");
+    const pluginsRoot2 = join(this.cwd, ".theokit", "plugins");
+    const entries = await readWorkspaceDir(pluginsRoot2, "plugins_read_error", "plugins directory");
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const folderName = entry.name;
-      const mdPath = join(pluginsRoot, folderName, "PLUGIN.md");
-      const jsonPath = join(pluginsRoot, folderName, "plugin.json");
-      const metadata = existsSync(mdPath) ? await loadPluginManifestFromMarkdown(pluginsRoot, folderName) : await loadPluginManifestFromJson(jsonPath, folderName);
+      const mdPath = join(pluginsRoot2, folderName, "PLUGIN.md");
+      const jsonPath = join(pluginsRoot2, folderName, "plugin.json");
+      const metadata = existsSync(mdPath) ? await loadPluginManifestFromMarkdown(pluginsRoot2, folderName) : await loadPluginManifestFromJson(jsonPath, folderName);
       if (existsSync(mdPath) && existsSync(jsonPath)) {
         warnOnce(
           `plugin-${folderName}-both`,
@@ -9018,8 +9018,8 @@ async function loadPluginManifestFromJson(manifestPath, folderName) {
   if (typeof record.entry === "string") metadata.entry = record.entry;
   return metadata;
 }
-async function loadPluginManifestFromMarkdown(pluginsRoot, folderName) {
-  const mdPath = join(pluginsRoot, folderName, "PLUGIN.md");
+async function loadPluginManifestFromMarkdown(pluginsRoot2, folderName) {
+  const mdPath = join(pluginsRoot2, folderName, "PLUGIN.md");
   let raw;
   try {
     raw = await readFile(mdPath, "utf8");
@@ -9029,7 +9029,7 @@ async function loadPluginManifestFromMarkdown(pluginsRoot, folderName) {
       cause
     });
   }
-  const fakeDir = join(pluginsRoot, folderName);
+  const fakeDir = join(pluginsRoot2, folderName);
   const entities = await loadMarkdownEntities({
     dir: fakeDir,
     schema: PluginFrontmatterSchema,
@@ -12028,6 +12028,103 @@ function registerBuiltins() {
   registerProvider(CEREBRAS);
   registerCatalogProviders();
 }
+function globalSingleton3(key, create) {
+  const g = globalThis;
+  const sym = Symbol.for(key);
+  if (g[sym] === void 0) g[sym] = create();
+  return g[sym];
+}
+var discoveryState = globalSingleton3("theokit-sdk.providers.discovered", () => ({
+  done: false
+}));
+function pluginsRoot() {
+  return join(homedir(), ".theokit", "plugins", "model-providers");
+}
+function trustFilePath() {
+  return join(homedir(), ".theokit", "plugins", "trusted-providers.json");
+}
+function loadTrustedNames() {
+  const trusted = /* @__PURE__ */ new Set();
+  const path = trustFilePath();
+  if (existsSync(path)) {
+    try {
+      const parsed = JSON.parse(readFileSync(path, "utf-8"));
+      if (Array.isArray(parsed)) {
+        let discarded = 0;
+        for (const name of parsed) {
+          if (typeof name === "string" && name.length > 0) trusted.add(name);
+          else discarded += 1;
+        }
+        if (discarded > 0) {
+          process.stderr.write(
+            `[theokit-sdk] WARN: ${path} contains ${discarded} non-string entr${discarded === 1 ? "y" : "ies"} \u2014 discarded (entries must be plugin-name strings)
+`
+          );
+        }
+      } else {
+        process.stderr.write(
+          `[theokit-sdk] WARN: ${path} is not a JSON array \u2014 trusting NO provider plugins (fail-closed)
+`
+        );
+      }
+    } catch {
+      process.stderr.write(
+        `[theokit-sdk] WARN: ${path} is not valid JSON \u2014 trusting NO provider plugins (fail-closed)
+`
+      );
+    }
+  }
+  for (const name of (process.env.THEOKIT_TRUSTED_PROVIDERS ?? "").split(",")) {
+    const trimmed = name.trim();
+    if (trimmed.length > 0) trusted.add(trimmed);
+  }
+  return trusted;
+}
+async function discoverProviderPlugins() {
+  if (discoveryState.done) return;
+  discoveryState.done = true;
+  const root = pluginsRoot();
+  if (!existsSync(root)) return;
+  let entries;
+  try {
+    entries = await readdir(root);
+  } catch {
+    return;
+  }
+  const trusted = loadTrustedNames();
+  for (const entry of entries) {
+    if (!trusted.has(entry)) {
+      process.stderr.write(
+        `[theokit-sdk] WARN: provider plugin "${entry}" is present but NOT trusted \u2014 skipped. To trust it, add "${entry}" to ${trustFilePath()} (JSON array of names) or THEOKIT_TRUSTED_PROVIDERS (comma-separated), then restart the process.
+`
+      );
+      continue;
+    }
+    await loadOne(join(root, entry), entry);
+  }
+}
+async function loadOne(dir, entryName) {
+  for (const ext of ["index.mjs", "index.js"]) {
+    const indexPath = join(dir, ext);
+    if (!existsSync(indexPath)) continue;
+    try {
+      const mod = await import(pathToFileURL(indexPath).href);
+      const plugin = mod.default ?? mod[entryName] ?? mod;
+      if (plugin !== null && typeof plugin === "object" && plugin.kind === "model-provider") {
+        const profile = plugin.profile;
+        if (profile !== void 0 && typeof profile === "object") {
+          registerProvider(profile);
+        }
+      }
+      return;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[theokit-sdk] failed to load provider plugin "${entryName}": ${msg}
+`);
+      return;
+    }
+  }
+}
 
 // src/internal/llm/anthropic.ts
 init_errors();
@@ -18576,6 +18673,7 @@ function resolveAgentPersistenceCwd(options) {
   return process.cwd();
 }
 async function rehydrateExistingAgent(agentId, existing, options) {
+  await discoverProviderPlugins();
   await validateRehydratedAgent(agentId, existing);
   const mergedLocal = options.local !== void 0 && existing.options.local !== void 0 ? { ...existing.options.local, ...options.local } : options.local ?? existing.options.local;
   const mergedOptions = {
@@ -18705,6 +18803,7 @@ var Agent = class _Agent {
       pluginCount: enabledPluginNames(options.plugins).length
     });
     try {
+      await discoverProviderPlugins();
       const agent = await runCreateUnderSpan(options, span);
       return agent;
     } catch (err) {