@skaile/workspaces 3.27.1 → 4.1.0

package/dist/bridge/drivers/omp.js

@@ -1,80 +1,293 @@
 import { classifyGenericErrorMessage } from '../../chunk-GAH4YRCI.js';
-import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-AQW4BWNR.js';
+import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger, registryDriverConfig, entryCredentialValue, providerCredentialEnvName } from '../../chunk-5DQWB5TW.js';
 import '../../chunk-6E6PKKAD.js';
 import '../../chunk-FTG7CRFD.js';
+import '../../chunk-KSIRR5PL.js';
+import { AI_PROVIDER_SURFACES, registryEntries, isEntryEnabled, parseModelRef, resolveEntryBaseUrl } from '../../chunk-ILG4BXYE.js';
 import '../../chunk-W4IPN3DD.js';
 import '../../chunk-NSBPE2FW.js';
-import { spawn, execFile } from 'child_process';
+import { spawn } from 'child_process';
 import fs from 'fs/promises';
 import path from 'path';
 import { createInterface } from 'readline';
 import * as z from 'zod';
+import { createHash } from 'crypto';
+import os from 'os';
+import { parse, stringify } from 'yaml';
 
-var OMP_BASE_ENV_KEYS = ["PATH", "HOME", "USER", "HOSTNAME", "SKAILE_SESSION_ID"];
-var OMP_PROVIDER_ENV_KEYS = [
-  // ── Anthropic (direct, gateway, and Foundry/mTLS transports) ──────────────
-  "ANTHROPIC_API_KEY",
-  "ANTHROPIC_AUTH_TOKEN",
-  "ANTHROPIC_OAUTH_TOKEN",
-  "ANTHROPIC_BASE_URL",
-  "ANTHROPIC_CUSTOM_HEADERS",
-  "ANTHROPIC_FOUNDRY_API_KEY",
-  "FOUNDRY_BASE_URL",
-  "CLAUDE_CODE_USE_FOUNDRY",
-  "CLAUDE_CODE_CLIENT_CERT",
-  "CLAUDE_CODE_CLIENT_KEY",
-  "NODE_EXTRA_CA_CERTS",
-  // ── Other first-party model providers ─────────────────────────────────────
-  "OPENAI_API_KEY",
-  "OPENAI_BASE_URL",
-  "GEMINI_API_KEY",
-  "COPILOT_GITHUB_TOKEN",
-  "AZURE_OPENAI_API_KEY",
-  "GROQ_API_KEY",
-  "CEREBRAS_API_KEY",
-  "XAI_API_KEY",
-  "MISTRAL_API_KEY",
-  "ZAI_API_KEY",
-  "MINIMAX_API_KEY",
-  "DEEPSEEK_API_KEY",
-  // ── Aggregators / gateways ────────────────────────────────────────────────
-  "OPENROUTER_API_KEY",
-  "KILO_API_KEY",
-  "AI_GATEWAY_API_KEY",
-  "OPENCODE_API_KEY",
-  "CURSOR_ACCESS_TOKEN",
-  "CLINE_API_KEY",
-  "WAFER_SERVERLESS_API_KEY",
-  "YOLO_AUTO_API_KEY",
-  "ABLITERATION_API_KEY",
-  "UMANS_AI_CODING_PLAN_API_KEY",
-  "UMANS_WEBSEARCH_PROVIDER",
-  // ── Cloud model planes ────────────────────────────────────────────────────
-  "AWS_PROFILE",
-  "AWS_ACCESS_KEY_ID",
-  "AWS_SECRET_ACCESS_KEY",
-  "AWS_SESSION_TOKEN",
-  "AWS_REGION",
-  "AWS_DEFAULT_REGION",
-  "GOOGLE_CLOUD_PROJECT",
-  "GOOGLE_CLOUD_LOCATION",
-  "GOOGLE_APPLICATION_CREDENTIALS",
-  // ── Search / tool backends ────────────────────────────────────────────────
-  "EXA_API_KEY",
-  "BRAVE_API_KEY",
-  "PERPLEXITY_API_KEY",
-  "PERPLEXITY_COOKIES",
-  "TAVILY_API_KEY",
-  "TINYFISH_API_KEY",
-  "FIRECRAWL_API_KEY",
-  "ANTHROPIC_SEARCH_API_KEY",
-  "ANTHROPIC_SEARCH_BASE_URL",
-  // ── omp's own configuration ───────────────────────────────────────────────
-  "OMP_PROFILE"
+var OMP_API_VALUES = [...AI_PROVIDER_SURFACES, "google-gemini-cli"];
+var OMP_DISCOVERY_TYPES = [
+  "ollama",
+  "llama.cpp",
+  "lm-studio",
+  "openai-models-list",
+  "proxy",
+  "litellm"
 ];
+var OMP_MODELS_FILENAME = "models.yml";
+var OMP_CONFIG_FILENAME = "config.yml";
+var OWNED_AGENT_DIR_FILES = {
+  "models.yml": true,
+  "models.yaml": true,
+  "models.json": true,
+  "config.yml": true,
+  "config.yaml": true,
+  "config.yml.lock": true,
+  "config.yaml.lock": true,
+  "settings.json": true
+};
+function entryModelIds(entry) {
+  const logical = /* @__PURE__ */ new Set([
+    ...Object.keys(entry.model_map ?? {}),
+    ...Object.keys(entry.capabilities ?? {})
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const id of logical) {
+    const providerSide = entry.model_map?.[id] ?? id;
+    if (seen.has(providerSide)) continue;
+    seen.add(providerSide);
+    out.push([id, providerSide]);
+  }
+  return out;
+}
+function renderProvider(id, entry, warnings) {
+  const baseUrl = resolveEntryBaseUrl(entry);
+  if (!baseUrl) {
+    warnings.push(
+      `provider '${id}' has no resolvable base_url (missing transport params?) \u2014 omitted from models.yml`
+    );
+    return void 0;
+  }
+  const surface = entry.surface;
+  if (surface && !OMP_API_VALUES.includes(surface)) {
+    warnings.push(
+      `provider '${id}' has surface '${surface}', which omp's api enum does not accept`
+    );
+    return void 0;
+  }
+  const block = { baseUrl };
+  if (surface) block.api = surface;
+  const kind = entry.credential?.kind ?? "none";
+  if (kind === "none") {
+    block.auth = "none";
+  } else if (kind === "sigv4" || kind === "google_adc" || kind === "azure_entra") {
+    block.auth = "none";
+  } else {
+    block.apiKey = providerCredentialEnvName(id);
+    if (kind === "bearer" || kind === "oauth") block.authHeader = true;
+  }
+  const headers = { ...entry.headers };
+  if (entry.query_params && Object.keys(entry.query_params).length > 0) {
+    if (surface === "bedrock-converse-stream") {
+      const search = new URLSearchParams(entry.query_params).toString();
+      block.baseUrl = `${baseUrl}${baseUrl.includes("?") ? "&" : "?"}${search}`;
+    } else {
+      warnings.push(
+        `provider '${id}' declares query_params, which omp's models.yml has no slot for on surface '${surface ?? "unset"}' \u2014 they were dropped`
+      );
+    }
+  }
+  if (Object.keys(headers).length > 0) block.headers = headers;
+  const discoveryType = entry.discovery?.type;
+  if (discoveryType) {
+    if (!OMP_DISCOVERY_TYPES.includes(discoveryType)) {
+      warnings.push(
+        `provider '${id}' declares discovery '${discoveryType}', which omp does not implement \u2014 models come from model_map only`
+      );
+    } else if (!surface && discoveryType !== "proxy") {
+      warnings.push(
+        `provider '${id}' declares discovery '${discoveryType}' but no surface \u2014 omp requires provider-level api for every discovery type but 'proxy'`
+      );
+    } else {
+      block.discovery = { type: discoveryType };
+    }
+  }
+  const models = [];
+  for (const [logical, providerSide] of entryModelIds(entry)) {
+    const model = { id: providerSide };
+    if (logical !== providerSide) model.name = logical;
+    const caps = entry.capabilities?.[logical];
+    if (caps?.context_window !== void 0) model.contextWindow = caps.context_window;
+    if (caps?.images !== void 0) model.input = caps.images ? ["text", "image"] : ["text"];
+    if (caps?.tools !== void 0) model.supportsTools = caps.tools;
+    models.push(model);
+  }
+  if (models.length > 0) {
+    if (!surface) {
+      warnings.push(
+        `provider '${id}' declares models but no surface \u2014 omp requires api at provider or model level`
+      );
+      return void 0;
+    }
+    block.models = models;
+  } else if (!block.discovery) {
+    warnings.push(
+      `provider '${id}' declares neither model_map/capabilities nor a discovery omp implements \u2014 it will only override an omp built-in provider of the same id`
+    );
+  }
+  return block;
+}
+function renderModelRoles(registry, roles, modelRef, warnings) {
+  const out = {};
+  for (const [role, selector] of Object.entries(roles ?? {})) {
+    const trimmed = selector.trim();
+    if (!trimmed) continue;
+    const ref = parseModelRef(trimmed, registry);
+    if (!ref?.providerModelId) {
+      warnings.push(
+        `role '${role}' ('${selector}') resolves to no model in this registry \u2014 dropped`
+      );
+      continue;
+    }
+    out[role] = `${ref.providerId}/${ref.providerModelId}`;
+  }
+  if (out.default === void 0 && modelRef) {
+    const ref = parseModelRef(modelRef, registry, roles);
+    if (ref?.providerModelId) out.default = `${ref.providerId}/${ref.providerModelId}`;
+  }
+  return out;
+}
+function renderOmpRegistry(registry, options = {}) {
+  const warnings = [];
+  const providers = {};
+  const providerIds = [];
+  const credentialEnv = {};
+  for (const [id, entry] of registryEntries(registry)) {
+    if (entry.kind !== "llm" && entry.kind !== "embed") continue;
+    if (!isEntryEnabled(entry)) continue;
+    const block = renderProvider(id, entry, warnings);
+    if (!block) continue;
+    providers[id] = block;
+    providerIds.push(id);
+    const secret = entryCredentialValue(id, entry, options);
+    if (secret) credentialEnv[providerCredentialEnvName(id)] = secret;
+  }
+  const modelRoles = renderModelRoles(registry, options.roles, options.modelRef, warnings);
+  const settings = { ...options.baseSettings };
+  if (Object.keys(modelRoles).length > 0) settings.modelRoles = modelRoles;
+  return {
+    modelsYml: stringify({ providers }),
+    configYml: stringify(settings),
+    credentialEnv,
+    providerIds,
+    modelRoles,
+    warnings
+  };
+}
+function registryModelEntries(registry) {
+  if (!registry) return [];
+  const out = [];
+  for (const [id, entry] of registryEntries(registry)) {
+    if (entry.kind !== "llm" && entry.kind !== "embed") continue;
+    if (!isEntryEnabled(entry)) continue;
+    const label = entry.label ?? id;
+    for (const [logical, providerSide] of entryModelIds(entry)) {
+      out.push({ id: `${id}/${providerSide}`, name: `${label} ${logical}` });
+    }
+  }
+  return out;
+}
+async function planOmpAgentDir(input) {
+  const options = input.options;
+  const key = input.sessionId?.trim() || createHash("sha256").update(path.resolve(input.cwd)).digest("hex").slice(0, 16);
+  const agentDir = options?.agentHome ?? path.join(input.tmpDir ?? os.tmpdir(), "skaile-omp-agent", key);
+  if (options?.seedUserAgentDir === false) return { agentDir };
+  const seedFrom = options?.userAgentDir ?? path.join(input.homeDir ?? os.homedir(), ".omp", "agent");
+  if (path.resolve(seedFrom) === path.resolve(agentDir)) return { agentDir };
+  try {
+    if (!(await fs.stat(seedFrom)).isDirectory()) return { agentDir };
+  } catch {
+    return { agentDir };
+  }
+  return { agentDir, seedFrom };
+}
+async function removeEntry(target) {
+  let stat;
+  try {
+    stat = await fs.lstat(target);
+  } catch {
+    return;
+  }
+  if (stat.isSymbolicLink() || stat.isFile()) {
+    await fs.unlink(target);
+    return;
+  }
+  await fs.rm(target, { recursive: true, force: true });
+}
+async function linkInto(dir, sourceDir, skip) {
+  let names;
+  try {
+    names = await fs.readdir(sourceDir);
+  } catch {
+    return [];
+  }
+  const linked = [];
+  for (const name of names) {
+    if (skip[name]) continue;
+    const target = path.join(dir, name);
+    await removeEntry(target);
+    await fs.symlink(path.join(sourceDir, name), target);
+    linked.push(name);
+  }
+  return linked;
+}
+async function readSeededSettings(seedFrom) {
+  for (const name of ["config.yml", "config.yaml"]) {
+    let raw;
+    try {
+      raw = await fs.readFile(path.join(seedFrom, name), "utf-8");
+    } catch {
+      continue;
+    }
+    const parsed = parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  }
+  return {};
+}
+async function materializeOmpAgentDir(agentDir, registry, options = {}) {
+  await fs.mkdir(agentDir, { recursive: true });
+  const seeded = options.seedFrom ? await linkInto(agentDir, options.seedFrom, OWNED_AGENT_DIR_FILES) : [];
+  const identity = options.identityDir ? await linkInto(agentDir, options.identityDir, OWNED_AGENT_DIR_FILES) : [];
+  const baseSettings = options.baseSettings ?? (options.seedFrom ? await readSeededSettings(options.seedFrom) : void 0);
+  const render = renderOmpRegistry(registry, { ...options, baseSettings });
+  await fs.writeFile(path.join(agentDir, OMP_MODELS_FILENAME), render.modelsYml, "utf-8");
+  await fs.writeFile(path.join(agentDir, OMP_CONFIG_FILENAME), render.configYml, "utf-8");
+  return { ...render, agentDir, seeded, identity };
+}
+async function materializeOmpProviders(config) {
+  const registry = config.registry;
+  if (!registry) return void 0;
+  const selectable = registryEntries(registry).some(
+    ([, entry]) => (entry.kind === "llm" || entry.kind === "embed") && isEntryEnabled(entry)
+  );
+  if (!selectable) return void 0;
+  const plan = await planOmpAgentDir({
+    cwd: config.cwd,
+    ...config.sessionId ? { sessionId: config.sessionId } : {},
+    ...config.driverOptions?.omp ? { options: config.driverOptions.omp } : {}
+  });
+  const rendered = await materializeOmpAgentDir(plan.agentDir, registry, {
+    env: { ...process.env, ...config.env },
+    ...plan.seedFrom ? { seedFrom: plan.seedFrom } : {},
+    ...config.agentDir ? { identityDir: config.agentDir } : {},
+    ...config.roles ? { roles: config.roles } : {},
+    ...config.modelRef ? { modelRef: config.modelRef } : {}
+  });
+  const selected = config.modelRef ? parseModelRef(config.modelRef, registry, config.roles) : void 0;
+  return {
+    ...rendered,
+    ...selected?.providerModelId ? { modelArg: `${selected.providerId}/${selected.providerModelId}` } : {}
+  };
+}
+
+// bridge/src/drivers/omp.ts
+var OMP_BASE_ENV_KEYS = ["PATH", "HOME", "USER", "HOSTNAME", "SKAILE_SESSION_ID"];
 function buildOmpChildEnv(parent) {
   const out = {};
-  for (const key of [...OMP_BASE_ENV_KEYS, ...OMP_PROVIDER_ENV_KEYS]) {
+  for (const key of OMP_BASE_ENV_KEYS) {
     const v = parent[key];
     if (typeof v === "string") out[key] = v;
   }
@@ -205,10 +418,24 @@ var OmpDriver = class extends AgentDriver {
       this.log.info("resuming OMP session", { sessionId: this.config.resumeSessionId });
       args.push("--session", this.config.resumeSessionId);
     }
-    if (this.config.model) {
-      const modelArg = this.config.provider ? `${this.config.provider}/${this.config.model}` : this.config.model;
-      args.push("--model", modelArg);
+    const providers = await materializeOmpProviders(this.config);
+    if (providers) {
+      for (const warning of providers.warnings) this.log.warn("registry", { warning });
+      if (providers.providerIds.length === 0) {
+        this.log.error("registry rendered no omp providers", new Error("empty models.yml"), {
+          agentDir: providers.agentDir
+        });
+      } else {
+        this.log.info("rendered omp models.yml", {
+          agentDir: providers.agentDir,
+          providers: providers.providerIds,
+          modelRoles: providers.modelRoles,
+          seeded: providers.seeded.length
+        });
+      }
     }
+    const modelArg = providers?.modelArg ?? this.config.model;
+    if (modelArg) args.push("--model", modelArg);
     const toolArgs = buildOmpToolArgs(this.config.tools);
     if (toolArgs.length > 0) {
       this.log.info("applying tool restrictions", { args: toolArgs });
@@ -222,7 +449,10 @@ var OmpDriver = class extends AgentDriver {
       args.push("--append-system-prompt", systemFile);
     }
     const env = this.config.env ? { ...this.config.env } : buildOmpChildEnv(process.env);
-    if (this.config.agentDir) {
+    if (providers) {
+      env.PI_CODING_AGENT_DIR = providers.agentDir;
+      Object.assign(env, providers.credentialEnv);
+    } else if (this.config.agentDir) {
       env.PI_CODING_AGENT_DIR = this.config.agentDir;
     }
     if (this.config.sshKeyPath) {
@@ -543,33 +773,24 @@ var OmpDriver = class extends AgentDriver {
     );
     return { message: msg, category: generic.category, retryable: generic.retryable, hint };
   }
+  /**
+   * The models this session can select.
+   *
+   * Answered entirely from the registry: the ids are exactly the
+   * `<providerId>/<modelId>` selectors rendered into `models.yml`, so a
+   * picker offers every enabled endpoint instead of whichever one the
+   * ambient binary happens to be authenticated for. A registry whose
+   * entries name no models yields no entries here — that gap is closed by
+   * giving the entry a `discovery:` block (`PROVIDER-CONFIG-PLAN.md` §1.1),
+   * not by asking the omp binary what it happens to know. omp's own catalog
+   * (`omp models --json`) answers a different question — every model omp
+   * knows across every provider, regardless of what this session's registry
+   * enables or has credentials for — and shelling out to an ambient binary
+   * from this code path is itself a liability: it can block indefinitely
+   * reading a prompt from stdin when run inside another interactive session.
+   */
   async listModels() {
-    return new Promise((resolve, reject) => {
-      execFile("omp", ["--list-models"], { timeout: 1e4 }, (err, stdout, stderr) => {
-        if (err) {
-          reject(new Error(`omp --list-models failed: ${stderr || err.message}`));
-          return;
-        }
-        const models = [];
-        let inCanonical = false;
-        let headerSkipped = false;
-        for (const raw of stdout.split("\n")) {
-          const line = raw.trimEnd();
-          if (!inCanonical) {
-            if (line.startsWith("Canonical models")) inCanonical = true;
-            continue;
-          }
-          if (!headerSkipped) {
-            headerSkipped = true;
-            continue;
-          }
-          if (line === "" || !line.startsWith(" ") && line.endsWith("models")) break;
-          const canonical = line.split(/\s{2,}/)[0]?.trim();
-          if (canonical) models.push({ id: canonical, name: canonical });
-        }
-        resolve(models);
-      });
-    });
+    return registryModelEntries(this.config.registry);
   }
   cleanup() {
     this.rl?.close();
@@ -587,9 +808,13 @@ var ompDriverTarget = {
   // Drivers take AgentConfig; passthrough — full schema validation is out of scope.
   configSchema: z.custom(() => true),
   create: async (config, _ctx) => new OmpDriver(config),
-  listModels: async (apiKeys) => new OmpDriver({ cwd: process.cwd(), sessionId: "model-list", apiKeys }).listModels()
+  listModels: async (registry, options) => new OmpDriver({
+    cwd: process.cwd(),
+    sessionId: "model-list",
+    ...registryDriverConfig(registry, options)
+  }).listModels()
 };
 
-export { OMP_BUILTIN_TOOLS, OMP_DEFAULT_TOOLS, OMP_PROVIDER_ENV_KEYS, OmpDriver, buildOmpChildEnv, buildOmpToolArgs, ompDriverTarget };
+export { OMP_BUILTIN_TOOLS, OMP_DEFAULT_TOOLS, OmpDriver, buildOmpChildEnv, buildOmpToolArgs, ompDriverTarget };
 //# sourceMappingURL=omp.js.map
 //# sourceMappingURL=omp.js.map