@skaile/workspaces 3.27.1 → 4.1.0

package/dist/bridge/drivers/codex.js

@@ -1,18 +1,32 @@
-import { CodexAppServerClient } from '../../chunk-PHBYB4XT.js';
-import { parseCodexCredential, prepareNativePolicy, prepareCodexInstance, codexInstanceEnvironment, isNativeApprovalPolicyActive, activateNativeApprovalPolicy, parseCodexRefreshResult, allowsNativeApprovalPath } from '../../chunk-T3YLZQS4.js';
+import { CodexAppServerClient } from '../../chunk-MLDJHV2U.js';
+import { managedCodexRegistryViolation, parseCodexCredential, prepareNativePolicy, prepareCodexInstance, codexInstanceEnvironment, isNativeApprovalPolicyActive, activateNativeApprovalPolicy, parseCodexRefreshResult, allowsNativeApprovalPath } from '../../chunk-45LLHKQ2.js';
 import { CodexNativeStateUnavailable } from '../../chunk-LOO5CB5M.js';
-import { fetchProviderModels } from '../../chunk-GURXUF2J.js';
+import { fetchProviderModels } from '../../chunk-R2GE2NXM.js';
 import { classifyGenericErrorMessage } from '../../chunk-GAH4YRCI.js';
-import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-AQW4BWNR.js';
+import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger, registryCredentialEnv, entryCredentialValue, registryDriverConfig, getProviderPreset, providerCredentialEnvName } from '../../chunk-5DQWB5TW.js';
 import '../../chunk-6E6PKKAD.js';
+import '../../chunk-3VSRJE3M.js';
+import '../../chunk-REILIKVM.js';
+import '../../chunk-F3HNW354.js';
+import '../../chunk-K5GBV4SA.js';
+import '../../chunk-QVZA2MDT.js';
+import { globalSkaileDir } from '../../chunk-K27T47OO.js';
+import '../../chunk-MENCWIHW.js';
+import '../../chunk-P4VHQA4N.js';
+import '../../chunk-MKZOK4JU.js';
+import '../../chunk-GEEW6SY2.js';
 import '../../chunk-FTG7CRFD.js';
+import '../../chunk-KSIRR5PL.js';
+import { resolveEntryBaseUrl, registryEntries, parseModelRef, isEntryEnabled } from '../../chunk-ILG4BXYE.js';
 import '../../chunk-W4IPN3DD.js';
+import '../../chunk-N7B3LZ7V.js';
 import '../../chunk-NSBPE2FW.js';
 import { join, dirname, isAbsolute, relative } from 'path';
 import { isDeepStrictEqual } from 'util';
-import { existsSync, readFileSync, mkdirSync, writeFileSync, realpathSync, statSync } from 'fs';
-import { randomUUID } from 'crypto';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, rmSync, renameSync, realpathSync, statSync } from 'fs';
+import { createHash, randomUUID } from 'crypto';
 import * as z from 'zod';
+import { stringify } from 'smol-toml';
 
 var invalid = () => new Error("CODEX_INPUT_INVALID");
 var inside = (root, path) => {
@@ -442,7 +456,13 @@ var ManagedCodexDriver = class extends AgentDriver {
     if (this.killed) throw failure();
     const options = this.config.driverOptions?.codex?.managedRuntime;
     const tuning = this.config.driverOptions?.codex;
-    if (tuning?.authSource !== "managed" || !options || typeof options.prepareTools !== "function" || !isAbsolute(options.executable) || !this.config.model || !tuning.reasoningEffort || !tuning.approvalPolicy || tuning.approvalPolicy === "on-failure" || !tuning.sandboxMode || tuning.sandboxMode === "danger-full-access" || this.config.provider && this.config.provider !== "openai" || this.config.apiKeys?.openai || this.config.env?.OPENAI_API_KEY || options.nativeTurnBudget !== void 0 && options.nativeTurnBudget !== 1)
+    if (tuning?.authSource !== "managed" || !options || typeof options.prepareTools !== "function" || !isAbsolute(options.executable) || !this.config.model || !tuning.reasoningEffort || !tuning.approvalPolicy || tuning.approvalPolicy === "on-failure" || !tuning.sandboxMode || tuning.sandboxMode === "danger-full-access" || // A managed session runs on the platform-minted credential alone: an
+    // OpenAI key handed in through the child environment would be a second,
+    // unaudited authority.
+    this.config.env?.OPENAI_API_KEY || // Credential isolation, stated on the AI provider registry: one entry,
+    // codex's own OpenAI surface, a platform-injected oauth reference. See
+    // `managedCodexRegistryViolation`.
+    managedCodexRegistryViolation(this.config.registry) !== void 0 || options.nativeTurnBudget !== void 0 && options.nativeTurnBudget !== 1)
       throw failure("AI_PROFILE_INVALID");
     this.options = options;
     const timeout = limit(options.requestTimeoutMs, 15e3);
@@ -1202,17 +1222,100 @@ var ManagedCodexDriver = class extends AgentDriver {
     }
   }
 };
-function buildCodexChildEnv(parent) {
+var CODEX_WIRE_API = {
+  "openai-codex-responses": "responses",
+  "openai-responses": "responses",
+  "azure-openai-responses": "responses"
+};
+var ENV_DELIVERED_CREDENTIALS = {
+  api_key_header: true,
+  bearer: true,
+  command: true
+};
+function renderCodexProviderTable(id, entry) {
+  if (!isEntryEnabled(entry)) return { skipped: "entry is disabled" };
+  if (entry.kind !== "llm" && entry.kind !== "embed")
+    return { skipped: `kind '${entry.kind}' is not a model endpoint` };
+  const llm = entry;
+  const preset = entry.preset ? getProviderPreset(entry.preset) : void 0;
+  const surface = llm.surface ?? preset?.surface;
+  const wireApi = surface ? CODEX_WIRE_API[surface] : void 0;
+  if (!wireApi)
+    return {
+      skipped: surface ? `codex has no wire_api for surface '${surface}'` : "entry declares no surface"
+    };
+  const credentialKind = entry.credential?.kind;
+  const table = { name: entry.label ?? id };
+  const baseUrl = resolveEntryBaseUrl(entry) ?? preset?.base_url;
+  if (baseUrl) table.base_url = baseUrl;
+  if (credentialKind && ENV_DELIVERED_CREDENTIALS[credentialKind])
+    table.env_key = providerCredentialEnvName(id);
+  table.wire_api = wireApi;
+  if (credentialKind === "oauth") table.requires_openai_auth = true;
+  if (llm.query_params && Object.keys(llm.query_params).length > 0)
+    table.query_params = { ...llm.query_params };
+  if (entry.headers && Object.keys(entry.headers).length > 0)
+    table.http_headers = { ...entry.headers };
+  return { table };
+}
+function buildCodexConfigDocument(input) {
+  const document = { model_providers: {} };
+  const skipped = [];
+  const entries = input.registry ? registryEntries(input.registry) : [];
+  for (const [id, entry] of entries) {
+    const rendered = renderCodexProviderTable(id, entry);
+    if ("skipped" in rendered) skipped.push({ id, reason: rendered.skipped });
+    else document.model_providers[id] = rendered.table;
+  }
+  if (!input.registry) return { document, skipped, warnings: [] };
+  const selected = parseModelRef(
+    input.modelRef?.trim() || input.model?.trim() || "",
+    input.registry,
+    input.roles
+  );
+  if (!selected) return { document, skipped, warnings: [] };
+  const warnings = selected.warnings;
+  if (!document.model_providers[selected.providerId]) return { document, skipped, warnings };
+  document.model_provider = selected.providerId;
+  if (selected.providerModelId) document.model = selected.providerModelId;
+  return {
+    document,
+    providerId: selected.providerId,
+    ...selected.providerModelId ? { model: selected.providerModelId } : {},
+    skipped,
+    warnings
+  };
+}
+function renderCodexConfigToml(document) {
+  const ordered = {};
+  if (document.model_provider) ordered.model_provider = document.model_provider;
+  if (document.model) ordered.model = document.model;
+  ordered.model_providers = document.model_providers;
+  return `${stringify(ordered)}
+`;
+}
+function codexSessionHome(config) {
+  const key = config.sessionId && /^[A-Za-z0-9._-]{1,128}$/.test(config.sessionId) ? config.sessionId : createHash("sha256").update(config.sessionId ?? config.cwd).digest("hex").slice(0, 32);
+  return join(globalSkaileDir(), "codex", key);
+}
+function writeCodexConfigToml(home, document) {
+  const path = join(home, "config.toml");
+  if (Object.keys(document.model_providers).length === 0) {
+    rmSync(path, { force: true });
+    return void 0;
+  }
+  mkdirSync(home, { recursive: true, mode: 448 });
+  const temporary = join(home, "config.toml.new");
+  rmSync(temporary, { force: true });
+  writeFileSync(temporary, renderCodexConfigToml(document), { mode: 384, flag: "wx" });
+  renameSync(temporary, path);
+  return path;
+}
+
+// bridge/src/drivers/codex.ts
+function buildCodexChildEnv(parent, codexHome) {
   const out = {};
-  const explicit = [
-    "OPENAI_API_KEY",
-    "ANTHROPIC_API_KEY",
-    "PATH",
-    "HOME",
-    "USER",
-    "HOSTNAME",
-    "SKAILE_SESSION_ID"
-  ];
+  const explicit = ["PATH", "HOME", "USER", "HOSTNAME", "SKAILE_SESSION_ID"];
   for (const key of explicit) {
     const v = parent[key];
     if (v !== void 0) out[key] = v;
@@ -1220,6 +1323,7 @@ function buildCodexChildEnv(parent) {
   for (const [key, value] of Object.entries(parent)) {
     if (key.startsWith("PI_") && typeof value === "string") out[key] = value;
   }
+  out.CODEX_HOME = codexHome;
   return out;
 }
 var CodexDriver = class extends AgentDriver {
@@ -1279,16 +1383,34 @@ var CodexDriver = class extends AgentDriver {
       this.log.error("codex SDK load failed", err);
       throw new Error("Codex SDK not installed. Run: bun add @openai/codex-sdk");
     }
-    const env = this.config.env ? { ...this.config.env } : buildCodexChildEnv(process.env);
+    const codexHome = codexSessionHome(this.config);
+    const build = buildCodexConfigDocument({
+      registry: this.config.registry,
+      modelRef: this.config.modelRef,
+      model: this.config.model,
+      roles: this.config.roles
+    });
+    writeCodexConfigToml(codexHome, build.document);
+    for (const warning of build.warnings) this.log.warn("codex model selection", { warning });
+    for (const entry of build.skipped)
+      this.log.warn("codex cannot address an AI provider entry", {
+        provider: entry.id,
+        reason: entry.reason
+      });
+    const env = this.config.env ? { ...this.config.env, CODEX_HOME: codexHome } : buildCodexChildEnv(process.env, codexHome);
+    Object.assign(
+      env,
+      registryCredentialEnv(this.config.registry ?? {}, { env: { ...process.env, ...env } })
+    );
     const instructionsFile = this.writeInstructionsFile();
     const client = new sdk.Codex({
-      apiKey: this.config.apiKeys?.openai ?? this.config.env?.OPENAI_API_KEY ?? process.env.OPENAI_API_KEY,
+      apiKey: env.OPENAI_API_KEY,
       env: Object.fromEntries(Object.entries(env).filter(([, value]) => value != null)),
       ...instructionsFile ? { config: { model_instructions_file: instructionsFile } } : {}
     });
     const codexOptions = this.config.driverOptions?.codex;
     const threadOptions = {
-      model: this.config.model,
+      model: build.model ?? this.config.model,
       sandboxMode: codexOptions?.sandboxMode ?? "workspace-write",
       workingDirectory: this.config.cwd,
       skipGitRepoCheck: true,
@@ -1369,13 +1491,43 @@ var CodexDriver = class extends AgentDriver {
     this.abortController = null;
     this.log.info("codex driver killed");
   }
+  /**
+   * Discover models from the endpoint this session actually addresses.
+   *
+   * The registry entry codex would talk to supplies both the base URL and the
+   * credential, so a session pointed at a gateway lists that gateway's models
+   * instead of api.openai.com's. A `platform:` reference the session boundary
+   * already resolved is picked up from `SKAILE_AIP_<ID>_KEY` in the session
+   * env. Without a registry entry codex can address, an ambient
+   * `OPENAI_API_KEY` is the last resort.
+   */
   async listModels() {
     if (this.managed) return this.managed.listModels();
-    const apiKey = this.config.apiKeys?.openai || this.config.env?.OPENAI_API_KEY || process.env.OPENAI_API_KEY;
+    const selected = this.selectedProviderEntry();
+    const sessionEnv = { ...process.env, ...this.config.env };
+    const apiKey = selected ? entryCredentialValue(selected.id, selected.entry, { env: sessionEnv }) : sessionEnv.OPENAI_API_KEY;
     if (!apiKey) return [];
-    const result = await fetchProviderModels("openai", apiKey);
+    const baseUrl = selected ? resolveEntryBaseUrl(selected.entry) : void 0;
+    const result = await fetchProviderModels("openai", apiKey, baseUrl ? { baseUrl } : {});
     return result.ok ? result.models : [];
   }
+  /**
+   * The registry entry codex addresses this session — the same selection the
+   * rendered `config.toml` names in `model_provider`.
+   */
+  selectedProviderEntry() {
+    const registry = this.config.registry;
+    if (!registry) return void 0;
+    const { providerId } = buildCodexConfigDocument({
+      registry,
+      modelRef: this.config.modelRef,
+      model: this.config.model,
+      roles: this.config.roles
+    });
+    if (!providerId) return void 0;
+    const match = registryEntries(registry).find(([id]) => id === providerId);
+    return match ? { id: match[0], entry: match[1] } : void 0;
+  }
   async resetSession() {
     if (this.managed) return this.managed.resetSession();
     this.kill();
@@ -1687,7 +1839,11 @@ var codexDriverTarget = {
   // Drivers take AgentConfig; passthrough — full schema validation is out of scope.
   configSchema: z.custom(() => true),
   create: async (config, _ctx) => new CodexDriver(config),
-  listModels: async (apiKeys) => new CodexDriver({ cwd: process.cwd(), sessionId: "model-list", apiKeys }).listModels()
+  listModels: async (registry, options) => new CodexDriver({
+    cwd: process.cwd(),
+    sessionId: "model-list",
+    ...registryDriverConfig(registry, options)
+  }).listModels()
 };
 
 export { CodexDriver, codexDriverTarget };