@ouro.bot/cli 0.1.0-alpha.733 → 0.1.0-alpha.734

package/dist/heart/daemon/supercronic-supervisor.js

@@ -0,0 +1,267 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupercronicSupervisor = void 0;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+const NAMESPACE = /^(?:habit|await):[a-z0-9](?:[a-z0-9._-]{0,62})$/u;
+const SAFE_JOB = /^[^\r\n\0]+$/u;
+const RESTART_DELAYS_MS = [1_000, 5_000, 15_000];
+function defaultDurableWrite(filePath, content, mode) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.tmp`;
+    const fd = fs.openSync(temporary, "w", mode);
+    try {
+        fs.writeFileSync(fd, content, "utf8");
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    fs.chmodSync(temporary, mode);
+    fs.renameSync(temporary, filePath);
+    const directory = fs.openSync(path.dirname(filePath), "r");
+    try {
+        fs.fsyncSync(directory);
+    }
+    finally {
+        fs.closeSync(directory);
+    }
+}
+function defaultDeps() {
+    return {
+        mkdir: (target) => fs.mkdirSync(target, { recursive: true }),
+        readFile: (target) => fs.readFileSync(target, "utf8"),
+        durableWrite: defaultDurableWrite,
+        removeFile: (target) => { try {
+            fs.unlinkSync(target);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        } },
+        processAlive: (pid) => { try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        } },
+        spawn: (binary, args) => (0, node_child_process_1.spawn)(binary, args, { stdio: ["ignore", "inherit", "inherit"] }),
+        setTimer: (callback, delayMs) => setTimeout(callback, delayMs),
+        clearTimer: (timer) => clearTimeout(timer),
+    };
+}
+class SupercronicSupervisor {
+    deps;
+    binaryPath;
+    crontabPath;
+    pidPath;
+    onFatal;
+    manifests = new Map();
+    child = null;
+    restartTimer = null;
+    restartCount = 0;
+    stopping = false;
+    constructor(options) {
+        this.binaryPath = options.binaryPath;
+        this.crontabPath = options.crontabPath;
+        this.pidPath = options.pidPath ?? `${options.crontabPath}.pid`;
+        this.deps = options.deps ?? defaultDeps();
+        this.onFatal = options.onFatal ?? ((error) => { throw error; });
+    }
+    start() {
+        if (this.child || this.restartTimer)
+            return;
+        this.deps.mkdir(path.dirname(this.crontabPath));
+        const priorPid = this.readPriorPid();
+        if (priorPid !== null && this.deps.processAlive(priorPid))
+            throw new Error(`Supercronic is already running with PID ${priorPid}`);
+        this.render();
+        this.stopping = false;
+        this.spawnChild();
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.supercronic_state", message: "Supercronic supervisor started", meta: { crontabPath: this.crontabPath } });
+    }
+    namespace(namespace) {
+        if (!NAMESPACE.test(namespace))
+            throw new Error(`invalid Supercronic namespace: ${namespace}`);
+        return {
+            sync: (jobs) => {
+                const next = new Map();
+                for (const job of jobs) {
+                    if (!SAFE_JOB.test(job.id) || !SAFE_JOB.test(job.taskId) || !SAFE_JOB.test(job.schedule) || !SAFE_JOB.test(job.command)) {
+                        throw new Error("invalid Supercronic job");
+                    }
+                    if (next.has(job.id))
+                        throw new Error(`duplicate Supercronic job: ${job.id}`);
+                    next.set(job.id, structuredClone(job));
+                }
+                this.manifests.set(namespace, next);
+                this.render();
+                (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.supercronic_state", message: "Supercronic manifest synchronized", meta: { namespace, jobCount: jobs.length } });
+            },
+            removeAll: () => {
+                this.manifests.delete(namespace);
+                this.render();
+            },
+            list: () => [...(this.manifests.get(namespace)?.values() ?? [])].map((job) => job.taskId).sort(),
+        };
+    }
+    verifyNamespace(namespace, jobs) {
+        if (!this.isHealthy())
+            return false;
+        const manifest = this.manifests.get(namespace);
+        if (!manifest || manifest.size !== jobs.length)
+            return false;
+        for (const job of jobs) {
+            const existing = manifest.get(job.id);
+            if (!existing || existing.schedule !== job.schedule || existing.command !== job.command)
+                return false;
+        }
+        try {
+            return this.deps.readFile(this.crontabPath) === this.renderedContent();
+        }
+        catch {
+            return false;
+        }
+    }
+    verificationOutput() {
+        if (!this.isHealthy())
+            return "";
+        const expected = this.renderedContent();
+        try {
+            return this.deps.readFile(this.crontabPath) === expected ? expected : "";
+        }
+        catch {
+            return "";
+        }
+    }
+    authenticatedSnapshot(namespace) {
+        if (!NAMESPACE.test(namespace))
+            throw new Error(`invalid Supercronic namespace: ${namespace}`);
+        if (!this.isHealthy() || typeof this.child?.pid !== "number")
+            throw new Error("Supercronic supervisor has no healthy child");
+        const manifest = this.manifests.get(namespace);
+        if (!manifest)
+            throw new Error(`Supercronic supervisor has no manifest for ${namespace}`);
+        const renderedCrontab = this.verificationOutput();
+        if (renderedCrontab.length === 0)
+            throw new Error("Supercronic supervisor crontab is not verified");
+        return {
+            schemaVersion: "supercronic-supervisor-snapshot-v1",
+            daemonPid: process.pid,
+            childCount: 1,
+            childPid: this.child.pid,
+            healthy: true,
+            binaryPath: this.binaryPath,
+            args: ["-split-logs", "-inotify", this.crontabPath],
+            crontabPath: this.crontabPath,
+            namespace,
+            manifest: [...manifest.values()].sort((left, right) => left.id.localeCompare(right.id)).map((job) => structuredClone(job)),
+            renderedCrontab,
+        };
+    }
+    isHealthy() {
+        return this.child !== null && typeof this.child.pid === "number" && this.deps.processAlive(this.child.pid);
+    }
+    async stop() {
+        this.stopping = true;
+        if (this.restartTimer)
+            this.deps.clearTimer(this.restartTimer);
+        this.restartTimer = null;
+        const child = this.child;
+        if (!child) {
+            this.deps.removeFile(this.pidPath);
+            return;
+        }
+        await new Promise((resolve) => {
+            let settled = false;
+            const finish = () => { if (settled)
+                return; settled = true; resolve(); };
+            child.once("exit", finish);
+            const timer = this.deps.setTimer(() => { child.kill("SIGKILL"); finish(); }, 10_000);
+            child.once("exit", () => this.deps.clearTimer(timer));
+            child.kill("SIGTERM");
+        });
+        this.child = null;
+        this.deps.removeFile(this.pidPath);
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.supercronic_state", message: "Supercronic supervisor stopped", meta: { crontabPath: this.crontabPath } });
+    }
+    readPriorPid() {
+        try {
+            const value = Number(this.deps.readFile(this.pidPath).trim());
+            return Number.isSafeInteger(value) && value > 0 ? value : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    renderedContent() {
+        const lines = [];
+        for (const namespace of [...this.manifests.keys()].sort()) {
+            const jobs = [...this.manifests.get(namespace).values()].sort((left, right) => left.id.localeCompare(right.id));
+            for (const job of jobs)
+                lines.push(`# ouro:${namespace}:${job.id}`, `${job.schedule} ${job.command}`);
+        }
+        return lines.length > 0 ? `${lines.join("\n")}\n` : "";
+    }
+    render() {
+        this.deps.durableWrite(this.crontabPath, this.renderedContent(), 0o600);
+    }
+    spawnChild() {
+        const child = this.deps.spawn(this.binaryPath, ["-split-logs", "-inotify", this.crontabPath]);
+        if (!child.pid || child.pid <= 0)
+            throw new Error("Supercronic did not return a child PID");
+        this.child = child;
+        this.deps.durableWrite(this.pidPath, `${child.pid}\n`, 0o600);
+        child.once("exit", (code, signal) => {
+            if (this.child !== child)
+                return;
+            this.child = null;
+            this.deps.removeFile(this.pidPath);
+            if (this.stopping)
+                return;
+            if (this.restartCount >= RESTART_DELAYS_MS.length) {
+                this.onFatal(new Error(`Supercronic exited repeatedly (code=${String(code)}, signal=${String(signal)})`));
+                return;
+            }
+            const delay = RESTART_DELAYS_MS[this.restartCount++];
+            this.restartTimer = this.deps.setTimer(() => { this.restartTimer = null; this.spawnChild(); }, delay);
+        });
+    }
+}
+exports.SupercronicSupervisor = SupercronicSupervisor;

package/dist/heart/habits/habit-scheduler.js

@@ -49,6 +49,7 @@ class HabitScheduler {
     onHabitFire;
     deps;
     execForVerify;
+    verifyJobs;
     platform;
     watcher = null;
     debounceTimer = null;
@@ -65,6 +66,7 @@ class HabitScheduler {
         this.onHabitFire = options.onHabitFire;
         this.deps = options.deps;
         this.execForVerify = options.execForVerify;
+        this.verifyJobs = options.verifyJobs;
         this.platform = options.platform ?? process.platform;
     }
     start() {
@@ -268,11 +270,13 @@ class HabitScheduler {
         }, intervalMs);
     }
     verifyCronAndCreateFallbacks(state) {
-        if (!this.execForVerify || state.jobs.length === 0)
+        if ((!this.execForVerify && !this.verifyJobs) || state.jobs.length === 0)
             return state;
         let currentState = state;
         for (let attempt = 1; attempt <= MAX_CRON_VERIFICATION_ATTEMPTS; attempt += 1) {
-            const verifiedLabels = this.verifyCronEntries();
+            const verifiedLabels = this.verifyJobs?.(currentState.jobs)
+                ? new Set(currentState.jobs.map((job) => this.platform === "darwin" ? `bot.ouro.${job.agent}.${job.taskId}` : job.taskId))
+                : this.execForVerify ? this.verifyCronEntries() : new Set();
             const revalidatedState = this.revalidateAndCorrectJobs(currentState);
             if (revalidatedState === null)
                 return null;
@@ -586,7 +590,7 @@ class HabitScheduler {
                 taskId: habit.name,
                 schedule: cronSchedule,
                 lastRun: habit.lastRun,
-                command: `${this.deps.ouroPath} poke ${this.agent} --habit ${habit.name} --trigger launchd`,
+                command: `${this.deps.ouroPath} poke ${this.agent} --habit ${habit.name} --trigger ${this.platform === "darwin" ? "launchd" : "cron"}`,
                 taskPath: path.join(this.habitsDir, `${habit.name}.md`),
             });
         }

package/dist/heart/identity.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HARNESS_CANONICAL_REPO_URL = exports.DEFAULT_AGENT_SENSES = exports.LEGACY_VAULT_SERVER_URL_ALIASES = exports.DEFAULT_VAULT_SERVER_URL = exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = exports.PROVIDER_CREDENTIALS = void 0;
+exports.HARNESS_CANONICAL_REPO_URL = exports.DEFAULT_AGENT_SENSES = exports.LEGACY_VAULT_SERVER_URL_ALIASES = exports.DEFAULT_VAULT_SERVER_URL = exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = exports.PROVIDER_CREDENTIALS = exports.normalizeHabitPaidTurnsPerDay = void 0;
 exports.normalizeVaultServerUrl = normalizeVaultServerUrl;
 exports.getVaultServerUrlCandidates = getVaultServerUrlCandidates;
 exports.defaultStableVaultEmail = defaultStableVaultEmail;
@@ -62,6 +62,9 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
 const migrate_config_1 = require("./migrate-config");
+const autonomy_budget_1 = require("./autonomy-budget");
+var autonomy_budget_2 = require("./autonomy-budget");
+Object.defineProperty(exports, "normalizeHabitPaidTurnsPerDay", { enumerable: true, get: function () { return autonomy_budget_2.normalizeHabitPaidTurnsPerDay; } });
 /** Single source of truth for per-provider credential field names, env var mappings, and prompt labels. */
 exports.PROVIDER_CREDENTIALS = {
     anthropic: { required: ["setupToken"], envVars: { ANTHROPIC_API_KEY: "setupToken" }, promptLabels: { setupToken: "Anthropic setup-token" } },
@@ -69,6 +72,8 @@ exports.PROVIDER_CREDENTIALS = {
     azure: { required: ["apiKey", "endpoint", "deployment"], envVars: { AZURE_OPENAI_API_KEY: "apiKey", AZURE_OPENAI_KEY: "apiKey", AZURE_OPENAI_ENDPOINT: "endpoint", AZURE_OPENAI_DEPLOYMENT: "deployment" }, promptLabels: { apiKey: "Azure API key", endpoint: "Azure endpoint", deployment: "Azure deployment" } },
     minimax: { required: ["apiKey"], envVars: { MINIMAX_API_KEY: "apiKey" }, promptLabels: { apiKey: "MiniMax API key" } },
     "github-copilot": { required: ["githubToken", "baseUrl"], envVars: { GH_TOKEN: "githubToken", GITHUB_TOKEN: "githubToken" }, promptLabels: { githubToken: "GitHub token" } },
+    "openai-compatible": { required: ["apiKey", "baseUrl"], envVars: {}, promptLabels: { apiKey: "Z.ai API key", baseUrl: "Z.ai canonical base URL" } },
+    "openai-compatible-gemini": { required: ["apiKey", "baseUrl"], envVars: {}, promptLabels: { apiKey: "Gemini API key", baseUrl: "Gemini canonical base URL" } },
 };
 exports.DEFAULT_AGENT_CONTEXT = {
     maxTokens: 80000,
@@ -138,6 +143,7 @@ exports.DEFAULT_AGENT_SENSES = {
     mail: { enabled: false },
     voice: { enabled: false },
     a2a: { enabled: false },
+    telegram: { enabled: false },
     workbench: { enabled: false },
 };
 function normalizeSenses(value, configFile) {
@@ -148,6 +154,7 @@ function normalizeSenses(value, configFile) {
         mail: { ...exports.DEFAULT_AGENT_SENSES.mail },
         voice: { ...exports.DEFAULT_AGENT_SENSES.voice },
         a2a: { ...exports.DEFAULT_AGENT_SENSES.a2a },
+        telegram: { ...exports.DEFAULT_AGENT_SENSES.telegram },
         workbench: { ...exports.DEFAULT_AGENT_SENSES.workbench },
     };
     if (value === undefined) {
@@ -164,7 +171,7 @@ function normalizeSenses(value, configFile) {
         throw new Error(`agent.json at ${configFile} must include senses as an object when present.`);
     }
     const raw = value;
-    const senseNames = ["cli", "teams", "bluebubbles", "mail", "voice", "a2a", "workbench"];
+    const senseNames = ["cli", "teams", "bluebubbles", "mail", "voice", "a2a", "telegram", "workbench"];
     for (const senseName of senseNames) {
         const rawSense = raw[senseName];
         if (rawSense === undefined) {
@@ -202,6 +209,7 @@ function buildDefaultAgentTemplate(_agentName) {
         humanFacing: { provider: "anthropic", model: "claude-opus-4-6" },
         agentFacing: { provider: "anthropic", model: "claude-opus-4-6" },
         context: { ...exports.DEFAULT_AGENT_CONTEXT },
+        habitPaidTurnsPerDay: autonomy_budget_1.DEFAULT_HABIT_PAID_TURNS_PER_DAY,
         senses: {
             cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
             teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
@@ -209,6 +217,7 @@ function buildDefaultAgentTemplate(_agentName) {
             mail: { ...exports.DEFAULT_AGENT_SENSES.mail },
             voice: { ...exports.DEFAULT_AGENT_SENSES.voice },
             a2a: { ...exports.DEFAULT_AGENT_SENSES.a2a },
+            telegram: { ...exports.DEFAULT_AGENT_SENSES.telegram },
             workbench: { ...exports.DEFAULT_AGENT_SENSES.workbench },
         },
         phrases: {
@@ -301,7 +310,7 @@ function getAgentMailroomRoot(agentName) {
 function getAgentToolsRoot(agentName) {
     return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "tools");
 }
-const VALID_PROVIDERS = ["azure", "minimax", "anthropic", "openai-codex", "github-copilot"];
+const VALID_PROVIDERS = ["azure", "minimax", "anthropic", "openai-codex", "github-copilot", "openai-compatible", "openai-compatible-gemini"];
 function isValidProvider(value) {
     return typeof value === "string" && VALID_PROVIDERS.includes(value);
 }
@@ -464,6 +473,7 @@ function loadAgentConfig() {
         enabled,
         humanFacing,
         agentFacing,
+        habitPaidTurnsPerDay: (0, autonomy_budget_1.normalizeHabitPaidTurnsPerDay)(getAgentName(), parsed.habitPaidTurnsPerDay, configFile),
         senses: normalizeSenses(parsed.senses, configFile),
         phrases: parsed.phrases,
     };

package/dist/heart/provider-credentials.js

@@ -53,7 +53,7 @@ const crypto = __importStar(require("node:crypto"));
 const os = __importStar(require("node:os"));
 const runtime_1 = require("../nerves/runtime");
 const credential_access_1 = require("../repertoire/credential-access");
-const VALID_PROVIDERS = ["azure", "minimax", "anthropic", "openai-codex", "github-copilot"];
+const VALID_PROVIDERS = ["azure", "minimax", "anthropic", "openai-codex", "github-copilot", "openai-compatible", "openai-compatible-gemini"];
 const VALID_PROVENANCE_SOURCES = ["auth-flow", "manual"];
 const VAULT_ITEM_PREFIX = "providers/";
 exports.PROVIDER_CREDENTIAL_POOL_NOT_LOADED_ERROR = "provider credentials have not been loaded from vault";
@@ -78,6 +78,14 @@ const PROVIDER_FIELD_SPLITS = {
         credentials: ["githubToken"],
         config: ["baseUrl"],
     },
+    "openai-compatible": {
+        credentials: ["apiKey"],
+        config: ["baseUrl"],
+    },
+    "openai-compatible-gemini": {
+        credentials: ["apiKey"],
+        config: ["baseUrl"],
+    },
 };
 let cachedPools = new Map();
 function isRecord(value) {

package/dist/heart/provider-models.js

@@ -14,6 +14,8 @@ exports.DEFAULT_PROVIDER_MODELS = {
     minimax: "MiniMax-M2.7",
     "openai-codex": "gpt-5.4",
     "github-copilot": "claude-sonnet-4.6",
+    "openai-compatible": "glm-5.2",
+    "openai-compatible-gemini": "gemini-3.6-flash",
 };
 const PROVIDER_NAMES = {
     anthropic: "Anthropic",
@@ -21,6 +23,8 @@ const PROVIDER_NAMES = {
     minimax: "MiniMax",
     "openai-codex": "OpenAI Codex",
     "github-copilot": "GitHub Copilot",
+    "openai-compatible": "Z.ai OpenAI-compatible",
+    "openai-compatible-gemini": "Gemini OpenAI-compatible",
 };
 function normalized(model) {
     return model.trim().toLowerCase();
@@ -46,6 +50,10 @@ function isModelClearlyIncompatibleWithProvider(provider, model) {
             return value.startsWith("claude-") || value.startsWith("minimax");
         case "github-copilot":
             return false;
+        case "openai-compatible":
+            return value !== "glm-5.2" && value !== "glm-5-turbo";
+        case "openai-compatible-gemini":
+            return value !== "gemini-3.6-flash";
     }
 }
 function resolveModelForProviderSelection(provider, currentModel) {

package/dist/heart/provider-ping.js

@@ -11,6 +11,7 @@ const azure_1 = require("./providers/azure");
 const minimax_1 = require("./providers/minimax");
 const openai_codex_1 = require("./providers/openai-codex");
 const github_copilot_1 = require("./providers/github-copilot");
+const openai_compatible_1 = require("./providers/openai-compatible");
 const provider_models_1 = require("./provider-models");
 const runtime_1 = require("../nerves/runtime");
 const provider_attempt_1 = require("./provider-attempt");
@@ -177,7 +178,9 @@ function createProviderRuntimeForConfig(provider, config, options = {}) {
             return (0, openai_codex_1.createOpenAICodexProviderRuntime)(resolvedModel, config);
         case "github-copilot":
             return (0, github_copilot_1.createGithubCopilotProviderRuntime)(resolvedModel, config);
-        /* v8 ignore next 2 -- exhaustive: all providers handled above @preserve */
+        case "openai-compatible":
+        case "openai-compatible-gemini":
+            return (0, openai_compatible_1.createOpenAICompatibleProviderRuntime)(provider, resolvedModel, config);
         default:
             throw new Error(`unsupported provider for ping: ${provider}`);
     }
@@ -233,7 +236,7 @@ async function pingProvider(provider, config, options = {}) {
         attempts: attempt.attempts,
     };
 }
-const PINGABLE_PROVIDERS = ["anthropic", "openai-codex", "azure", "minimax", "github-copilot"];
+const PINGABLE_PROVIDERS = ["anthropic", "openai-codex", "azure", "minimax", "github-copilot", "openai-compatible", "openai-compatible-gemini"];
 async function runHealthInventory(agentName, currentProvider, deps = {}) {
     /* v8 ignore next -- default: tests inject ping dep @preserve */
     const ping = deps.ping ?? pingProvider;

package/dist/heart/providers/openai-compatible.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAICompatibleProviderRuntime = createOpenAICompatibleProviderRuntime;
+const bundle_manifest_1 = require("../../mind/bundle-manifest");
+const runtime_1 = require("../../nerves/runtime");
+const error_classification_1 = require("./error-classification");
+const CANONICAL_BASE_URLS = {
+    "openai-compatible": "https://api.z.ai/api/paas/v4/",
+    "openai-compatible-gemini": "https://generativelanguage.googleapis.com/v1beta/openai/",
+};
+function canonicalBaseUrl(provider, value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error(`${provider} requires its canonical base URL`);
+    }
+    const normalized = parsed.toString().replace(/\/+$/u, "/");
+    const normalizedInput = value.replace(/\/+$/u, "/");
+    if (normalizedInput !== CANONICAL_BASE_URLS[provider] || normalized !== CANONICAL_BASE_URLS[provider]) {
+        throw new Error(`${provider} requires its canonical base URL ${CANONICAL_BASE_URLS[provider]}`);
+    }
+    return normalized;
+}
+function safeError(error, apiKey) {
+    const redact = (value) => value.split(apiKey).join("[redacted]");
+    const message = redact(error instanceof Error ? error.message : String(error));
+    const safe = new Error(message);
+    if (error instanceof Error) {
+        const source = error;
+        if (typeof source.status === "number" && Number.isFinite(source.status))
+            safe.status = source.status;
+        if (typeof source.code === "string")
+            safe.code = redact(source.code);
+    }
+    return safe;
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        throw new Error(`OpenAI-compatible response ${label} is missing`);
+    return value;
+}
+function parseUsage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const usage = value;
+    const input = usage.prompt_tokens;
+    const output = usage.completion_tokens;
+    const total = usage.total_tokens;
+    if (![input, output, total].every((entry) => Number.isSafeInteger(entry) && entry >= 0))
+        return undefined;
+    const details = usage.completion_tokens_details;
+    const reasoning = details && typeof details === "object" && !Array.isArray(details)
+        && Number.isSafeInteger(details.reasoning_tokens)
+        ? Number(details.reasoning_tokens)
+        : 0;
+    return { input_tokens: Number(input), output_tokens: Number(output), reasoning_tokens: reasoning, total_tokens: Number(total) };
+}
+function parseCompletion(value, callbacks) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("OpenAI-compatible response envelope is invalid");
+    const choices = value.choices;
+    if (!Array.isArray(choices) || choices.length !== 1 || !choices[0] || typeof choices[0] !== "object") {
+        throw new Error("OpenAI-compatible response must contain exactly one choice");
+    }
+    const choice = choices[0];
+    const message = choice.message;
+    if (!message || typeof message !== "object" || Array.isArray(message))
+        throw new Error("OpenAI-compatible choice message is invalid");
+    const record = message;
+    if (Object.prototype.hasOwnProperty.call(record, "function_call")) {
+        throw new Error("OpenAI-compatible legacy function_call is unsupported");
+    }
+    const rawCalls = record.tool_calls;
+    const calls = rawCalls === undefined || rawCalls === null ? [] : rawCalls;
+    if (!Array.isArray(calls))
+        throw new Error("OpenAI-compatible tool_calls must be an array");
+    const toolCalls = calls.map((call) => {
+        if (!call || typeof call !== "object" || Array.isArray(call))
+            throw new Error("OpenAI-compatible tool call is invalid");
+        const callRecord = call;
+        const fn = callRecord.function;
+        if (callRecord.type !== "function" || !fn || typeof fn !== "object" || Array.isArray(fn)) {
+            throw new Error("OpenAI-compatible tool call must be a function");
+        }
+        return {
+            id: requiredString(callRecord.id, "tool call id"),
+            name: requiredString(fn.name, "tool name"),
+            arguments: requiredString(fn.arguments, "tool arguments"),
+        };
+    });
+    const content = typeof record.content === "string" ? record.content : "";
+    if (choice.finish_reason === "stop") {
+        if (toolCalls.length !== 0 || content.trim().length === 0)
+            throw new Error("OpenAI-compatible stop response shape is invalid");
+    }
+    else if (choice.finish_reason === "tool_calls") {
+        if (toolCalls.length < 1 || toolCalls.length > 8 || content.trim().length !== 0) {
+            throw new Error("OpenAI-compatible tool_calls response shape is invalid");
+        }
+    }
+    else {
+        throw new Error("OpenAI-compatible finish_reason is unsupported");
+    }
+    callbacks.onModelStreamStart();
+    if (content)
+        callbacks.onTextChunk(content);
+    return {
+        content,
+        toolCalls,
+        outputItems: [],
+        usage: parseUsage(value.usage),
+    };
+}
+function createOpenAICompatibleProviderRuntime(provider, model, config, deps = {}) {
+    const apiKey = config.apiKey?.trim();
+    if (!apiKey)
+        throw new Error(`provider '${provider}' is selected but apiKey is missing in the agent vault`);
+    const baseUrl = canonicalBaseUrl(provider, config.baseUrl);
+    const fetchImpl = deps.fetch ?? fetch;
+    const packageVersion = deps.packageVersion ?? (0, bundle_manifest_1.getPackageVersion)();
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.provider_init",
+        message: "OpenAI-compatible provider init",
+        meta: { provider },
+    });
+    const request = async (messages, tools, signal, toolChoiceRequired = false) => {
+        const body = { model, messages, tools, stream: false };
+        if (provider === "openai-compatible")
+            body.temperature = 0;
+        if (toolChoiceRequired)
+            body.tool_choice = "required";
+        try {
+            const response = await fetchImpl(new URL("chat/completions", baseUrl), {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                    ...(provider === "openai-compatible-gemini"
+                        ? { "x-goog-api-client": `ouroboros-harness-oai/${packageVersion}` }
+                        : {}),
+                },
+                body: JSON.stringify(body),
+                signal,
+            });
+            if (!response.ok)
+                throw Object.assign(new Error(`provider request failed with HTTP ${response.status}`), { status: response.status });
+            return await response.json();
+        }
+        catch (error) {
+            throw safeError(error, apiKey);
+        }
+    };
+    return {
+        id: provider,
+        model,
+        client: { baseUrl },
+        capabilities: new Set(),
+        resetTurnState() { },
+        appendToolOutput() { },
+        async streamTurn(turnRequest) {
+            return parseCompletion(await request(turnRequest.messages, turnRequest.activeTools, turnRequest.signal, turnRequest.toolChoiceRequired), turnRequest.callbacks);
+        },
+        async ping(signal) {
+            const callbacks = {
+                onModelStreamStart() { },
+                onTextChunk() { },
+            };
+            parseCompletion(await request([{ role: "user", content: "ping" }], [], signal), callbacks);
+        },
+        classifyError(error) {
+            return (0, error_classification_1.classifyHttpError)(error);
+        },
+    };
+}