@ouro.bot/cli 0.1.0-alpha.7 → 0.1.0-alpha.700

package/dist/heart/provider-binding-resolver.js

@@ -0,0 +1,273 @@
+"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.normalizeProviderLane = normalizeProviderLane;
+exports.resolveEffectiveProviderBinding = resolveEffectiveProviderBinding;
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("./identity");
+const auth_flow_1 = require("./auth/auth-flow");
+const provider_credentials_1 = require("./provider-credentials");
+const provider_readiness_cache_1 = require("./provider-readiness-cache");
+const provider_models_1 = require("./provider-models");
+function legacyLaneWarning(selector, lane) {
+    return {
+        code: "legacy-lane-selector",
+        message: `${selector} is legacy provider wording; using ${lane} lane`,
+    };
+}
+function facingKeyForProviderLane(lane) {
+    return lane === "outward" ? "humanFacing" : "agentFacing";
+}
+function normalizeProviderLane(selector) {
+    switch (selector) {
+        case "outward":
+            return { lane: "outward", warnings: [] };
+        case "inner":
+            return { lane: "inner", warnings: [] };
+        case "human":
+        case "humanFacing":
+            return { lane: "outward", warnings: [legacyLaneWarning(selector, "outward")] };
+        case "agent":
+        case "agentFacing":
+            return { lane: "inner", warnings: [legacyLaneWarning(selector, "inner")] };
+    }
+}
+function buildUseRepair(agentName, lane) {
+    return {
+        command: `ouro use --agent ${agentName} --lane ${lane} --provider <provider> --model <model>`,
+        message: `Choose the provider/model ${agentName}'s ${lane} lane should use in agent.json.`,
+    };
+}
+function buildAuthRepair(agentName, provider) {
+    return {
+        command: `ouro auth --agent ${agentName} --provider ${provider}`,
+        message: `Store ${provider} credentials in ${agentName}'s vault.`,
+    };
+}
+function invalidAgentConfigWarning(agentName, error) {
+    return {
+        code: "agent-config-invalid",
+        message: `agent.json provider selection for ${agentName} is invalid: ${error}`,
+    };
+}
+function missingCredentialWarning(provider) {
+    return {
+        code: "credential-missing",
+        message: `${provider} has no credential record in the agent vault.`,
+    };
+}
+function invalidCredentialPoolWarning(provider) {
+    return {
+        code: "credential-pool-invalid",
+        message: `${provider} cannot read credentials from the agent vault.`,
+    };
+}
+function presentCredential(record) {
+    return {
+        status: "present",
+        provider: record.provider,
+        revision: record.revision,
+        source: record.provenance.source,
+        updatedAt: record.updatedAt,
+        credentialFields: Object.keys(record.credentials).sort(),
+        configFields: Object.keys(record.config).sort(),
+    };
+}
+function resolveCredential(poolResult, provider, agentName) {
+    if (poolResult.ok) {
+        const record = poolResult.pool.providers[provider];
+        if (record)
+            return { credential: presentCredential(record), warnings: [] };
+        return {
+            credential: {
+                status: "missing",
+                provider,
+                poolPath: poolResult.poolPath,
+                repair: buildAuthRepair(agentName, provider),
+            },
+            warnings: [missingCredentialWarning(provider)],
+        };
+    }
+    if ((0, provider_credentials_1.isProviderCredentialPoolNotLoaded)(poolResult)) {
+        return {
+            credential: {
+                status: "not-loaded",
+                provider,
+                poolPath: poolResult.poolPath,
+            },
+            warnings: [],
+        };
+    }
+    if (poolResult.reason === "invalid" || poolResult.reason === "unavailable") {
+        return {
+            credential: {
+                status: "invalid-pool",
+                provider,
+                poolPath: poolResult.poolPath,
+                error: poolResult.error,
+                repair: buildAuthRepair(agentName, provider),
+            },
+            warnings: [invalidCredentialPoolWarning(provider)],
+        };
+    }
+    return {
+        credential: {
+            status: "missing",
+            provider,
+            poolPath: poolResult.poolPath,
+            repair: buildAuthRepair(agentName, provider),
+        },
+        warnings: [missingCredentialWarning(provider)],
+    };
+}
+function resolveReadiness(agentName, agentRoot, lane, provider, model, credential) {
+    if (credential.status === "missing") {
+        return { status: "unknown", reason: "credential-missing" };
+    }
+    if (credential.status === "invalid-pool") {
+        return { status: "unknown", reason: "credential-pool-invalid" };
+    }
+    if (credential.status === "present") {
+        const cached = (0, provider_readiness_cache_1.readProviderLaneReadiness)({
+            agentRoot,
+            agentName,
+            lane,
+            provider,
+            model,
+            credentialRevision: credential.revision,
+        });
+        if (cached) {
+            return {
+                status: cached.status,
+                checkedAt: cached.checkedAt,
+                ...(cached.error ? { error: cached.error } : {}),
+                ...(cached.attempts !== undefined ? { attempts: cached.attempts } : {}),
+            };
+        }
+    }
+    return { status: "unknown" };
+}
+function isAgentProvider(value) {
+    return typeof value === "string" && Object.prototype.hasOwnProperty.call(identity_1.PROVIDER_CREDENTIALS, value);
+}
+function resolveAgentConfigLane(input, lane) {
+    const configPath = path.join(input.agentRoot, "agent.json");
+    try {
+        const { config, configPath: resolvedConfigPath } = (0, auth_flow_1.readAgentConfigForAgent)(input.agentName, path.dirname(input.agentRoot));
+        const facingKey = facingKeyForProviderLane(lane);
+        const binding = config[facingKey];
+        /* v8 ignore next -- readAgentConfigForAgent rejects unsupported providers before this defensive guard @preserve */
+        if (!isAgentProvider(binding.provider)) {
+            return { ok: false, configPath: resolvedConfigPath, error: `${facingKey}.provider must be a supported provider` };
+        }
+        const model = typeof binding.model === "string" ? binding.model.trim() : "";
+        if (model.length === 0) {
+            return { ok: false, configPath: resolvedConfigPath, error: `${facingKey}.model must be a non-empty string` };
+        }
+        const mismatch = (0, provider_models_1.getProviderModelMismatchMessage)(binding.provider, model);
+        if (mismatch) {
+            return { ok: false, configPath: resolvedConfigPath, error: mismatch };
+        }
+        return {
+            ok: true,
+            configPath: resolvedConfigPath,
+            provider: binding.provider,
+            model,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            configPath,
+            /* v8 ignore next -- readAgentConfigForAgent/file IO failures are Error instances in supported runtimes @preserve */
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function resolveEffectiveProviderBinding(input) {
+    const laneResolution = normalizeProviderLane(input.lane);
+    const agentConfigResult = resolveAgentConfigLane(input, laneResolution.lane);
+    if (!agentConfigResult.ok) {
+        const result = {
+            ok: false,
+            lane: laneResolution.lane,
+            reason: "agent-config-invalid",
+            configPath: agentConfigResult.configPath,
+            error: agentConfigResult.error,
+            warnings: [...laneResolution.warnings, invalidAgentConfigWarning(input.agentName, agentConfigResult.error)],
+            repair: buildUseRepair(input.agentName, laneResolution.lane),
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "config/identity",
+            event: "config.provider_binding_resolution_failed",
+            message: "provider binding resolution failed",
+            meta: { agentName: input.agentName, lane: laneResolution.lane, reason: result.reason },
+        });
+        return result;
+    }
+    const poolResult = (0, provider_credentials_1.readProviderCredentialPool)(input.agentName);
+    const credentialResult = resolveCredential(poolResult, agentConfigResult.provider, input.agentName);
+    const readiness = resolveReadiness(input.agentName, input.agentRoot, laneResolution.lane, agentConfigResult.provider, agentConfigResult.model, credentialResult.credential);
+    const warnings = [
+        ...laneResolution.warnings,
+        ...credentialResult.warnings,
+    ];
+    const binding = {
+        lane: laneResolution.lane,
+        provider: agentConfigResult.provider,
+        model: agentConfigResult.model,
+        source: "agent.json",
+        configPath: agentConfigResult.configPath,
+        credential: credentialResult.credential,
+        readiness,
+        warnings,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config.provider_binding_resolved",
+        message: "resolved effective provider binding",
+        meta: {
+            agentName: input.agentName,
+            lane: binding.lane,
+            provider: binding.provider,
+            model: binding.model,
+            credentialStatus: binding.credential.status,
+            readinessStatus: binding.readiness.status,
+            warningCount: warnings.length,
+        },
+    });
+    return { ok: true, binding };
+}