@codiac.io/codiac-cli 1.3.253 → 1.3.254

package/dist/commands/ai/model/install.js

@@ -0,0 +1,655 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const _ = require("lodash");
+const command_base_exec_1 = require("../../../command-base-exec");
+const model_spec_1 = require("../../../uilogic/model-spec");
+const framework_spec_1 = require("../../../uilogic/framework-spec");
+const SOURCES = ['served', 'byo'];
+const RUNTIME_TIERS = ['cpu', 'gpu'];
+const ATTACH_KINDS = ['existing', 'new', 'none'];
+class AiModelInstall extends command_base_exec_1.CommandBaseExec {
+    constructor() {
+        super(...arguments);
+        this.adminOnly = true;
+    }
+    captureArgs() {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse(AiModelInstall);
+            let partial = {};
+            let explicit = {};
+            if (flags.enterpriseCode)
+                partial.enterprise = flags.enterpriseCode;
+            if (flags.source) {
+                partial.source = flags.source;
+                explicit.source = partial.source;
+            }
+            if (flags.model) {
+                partial.model = flags.model.trim();
+                explicit.model = partial.model;
+            }
+            if (flags.runtime) {
+                partial.runtime = flags.runtime;
+                explicit.runtime = partial.runtime;
+            }
+            if (flags['base-url']) {
+                partial.baseUrl = flags['base-url'].trim();
+                explicit.baseUrl = partial.baseUrl;
+            }
+            if (flags.key) {
+                partial.key = flags.key;
+                explicit.key = partial.key;
+            }
+            if (flags.cabinet) {
+                partial.cabinet = flags.cabinet;
+                explicit.cabinet = partial.cabinet;
+            }
+            if (flags.name) {
+                partial.name = flags.name.trim();
+                explicit.name = partial.name;
+            }
+            if (flags.attach) {
+                partial.attach = flags.attach;
+                explicit.attach = partial.attach;
+            }
+            if (flags.agent) {
+                partial.agent = flags.agent.trim();
+                explicit.agent = partial.agent;
+            }
+            if (flags.framework) {
+                partial.framework = flags.framework.trim();
+                explicit.framework = partial.framework;
+            }
+            // Thread --input onto the candidate here (fixing the ai-agent-install wart of re-parsing
+            // flags inside executeTask). buildCommandString + toProvisionRequest read it from the candidate.
+            const inputs = {};
+            for (const kv of ((_a = flags.input) !== null && _a !== void 0 ? _a : [])) {
+                const eq = kv.indexOf('=');
+                if (eq > 0)
+                    inputs[kv.slice(0, eq)] = kv.slice(eq + 1);
+            }
+            if (Object.keys(inputs).length > 0)
+                partial.inputs = inputs;
+            const takeDefaults = flags['take-defaults'];
+            return [partial, takeDefaults, explicit];
+        });
+    }
+    buildCandidate_silently(partial, _rootMap, _explicit) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (partial.source == undefined)
+                throw new Error("Must specify a model source (--source served|byo).");
+            if (!SOURCES.includes(partial.source))
+                throw new Error(`Invalid source [${partial.source}]; must be one of: served, byo.`);
+            // NOTE: presence-only validation here. Cross-checking the cabinet against the rootMap
+            // (existence, cluster assignment, etc.) is deferred to the relay's provisioning logic.
+            if (partial.cabinet == undefined || _.isEmpty(partial.cabinet))
+                throw new Error("Must specify cabinet.");
+            if (partial.source === 'served') {
+                if (partial.model == undefined || _.isEmpty(partial.model))
+                    throw new Error(`A served model requires --model (one of: ${(0, model_spec_1.supportedModelKinds)().join(', ')}).`);
+                if (!(0, model_spec_1.isServedModelKind)(partial.model))
+                    throw new Error(`Unknown or non-served model [${partial.model}]. Served catalog models: ${(0, model_spec_1.supportedModelKinds)().join(', ')} (use --source byo for external endpoints).`);
+                const spec = (0, model_spec_1.resolveModelSpec)(partial.model);
+                if (!spec.supported)
+                    throw new Error(`Model [${partial.model}] is not yet supported.`);
+                if (partial.runtime == undefined)
+                    throw new Error("A served model requires --runtime cpu|gpu.");
+                if (!RUNTIME_TIERS.includes(partial.runtime))
+                    throw new Error(`Invalid runtime [${partial.runtime}]; must be cpu or gpu.`);
+            }
+            if (partial.source === 'byo') {
+                if (partial.baseUrl == undefined || _.isEmpty(partial.baseUrl))
+                    throw new Error("A BYO model requires --base-url (the OpenAI-compatible endpoint, e.g. https://host/v1).");
+            }
+            const attach = (_a = partial.attach) !== null && _a !== void 0 ? _a : 'none';
+            if (!ATTACH_KINDS.includes(attach))
+                throw new Error(`Invalid attach [${attach}]; must be one of: existing, new, none.`);
+            if (attach === 'existing' && (partial.agent == undefined || _.isEmpty(partial.agent)))
+                throw new Error("--attach existing requires --agent <name> (the agent to wire the model into).");
+            if (attach === 'new' && (partial.framework == undefined || _.isEmpty(partial.framework)))
+                throw new Error("--attach new requires --framework <framework> (the agent framework to install and wire).");
+            return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ enterprise: partial.enterprise, cabinet: partial.cabinet, source: partial.source }, (partial.model ? { model: partial.model } : {})), (partial.runtime ? { runtime: partial.runtime } : {})), (partial.baseUrl ? { baseUrl: partial.baseUrl } : {})), (partial.key ? { key: partial.key } : {})), { attach }), (attach === 'existing' && partial.agent ? { agent: partial.agent } : {})), (attach === 'new' && partial.framework ? { framework: partial.framework } : {})), (partial.name && !_.isEmpty(partial.name) ? { name: partial.name } : {})), (partial.inputs ? { inputs: partial.inputs } : {}));
+        });
+    }
+    buildCandidate_interactively(partial, rootMap, takeDefaults, explicit) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const overrides = [];
+            // --- source -----------------------------------------------------------
+            partial.source = yield this.setSource(partial.source, overrides);
+            // --- served: model + runtime -----------------------------------------
+            if (partial.source === 'served') {
+                partial.model = yield this.setModel(partial.model, overrides);
+                partial.runtime = yield this.setRuntime(partial.model, partial.runtime, takeDefaults, overrides);
+            }
+            // --- cabinet ----------------------------------------------------------
+            // Reuse the rootMapUtils cabinet picker rather than hand-rolling selection/validation
+            // (it already implements the User Input Philosophy Rules 1-3).
+            const [cabinet] = yield this.rootMapUtils.promptForCabinet(partial.enterprise, rootMap, partial.cabinet, takeDefaults, undefined, explicit === null || explicit === void 0 ? void 0 : explicit.cabinet);
+            partial.cabinet = cabinet.name;
+            // --- attach -----------------------------------------------------------
+            partial.attach = yield this.setAttach(partial.attach, takeDefaults, overrides);
+            if (partial.attach === 'existing') {
+                partial.agent = yield this.setAgent(partial.agent, explicit === null || explicit === void 0 ? void 0 : explicit.agent);
+            }
+            else if (partial.attach === 'new') {
+                partial.framework = yield this.setFramework(partial.framework, explicit === null || explicit === void 0 ? void 0 : explicit.framework);
+            }
+            // --- CSP creds for the cabinet's cluster ------------------------------
+            // Any path that touches the cluster (a served deploy, or attaching to/redeploying an agent)
+            // needs the tenant's cloud credentials — the same gate `cod asset deploy` uses. A BYO
+            // registration with no attach never touches the cluster, so it needs no creds.
+            const touchesCluster = !(partial.source === 'byo' && partial.attach === 'none');
+            if (touchesCluster) {
+                const cluster = rootMap.clusters.find(c => c.name === cabinet.cluster);
+                if (cluster == undefined) {
+                    throw new Error(`Cabinet [${cabinet.name}] has no recognized cluster [${cabinet.cluster}].`);
+                }
+                yield this.cspContextualizer.promptForCloudProviderCreds(this.ioc, cluster.provider, takeDefaults, undefined, undefined, cluster.providerSubscriptionId);
+            }
+            // --- byo: base-url + key ----------------------------------------------
+            if (partial.source === 'byo') {
+                partial.baseUrl = yield this.setBaseUrl(partial.baseUrl, explicit === null || explicit === void 0 ? void 0 : explicit.baseUrl);
+                partial.key = yield this.setKey(partial.key);
+            }
+            // --- name -------------------------------------------------------------
+            partial.name = yield this.setName(partial.name, takeDefaults, explicit === null || explicit === void 0 ? void 0 : explicit.name);
+            if (overrides.length > 0) {
+                this._ui.userMessage(this._styler.colorWarning("One or more provided values were invalid and have been replaced:"));
+                for (const o of overrides) {
+                    this._ui.userMessage(`  ${o.param}: ${this._styler.colorWarning(o.given)} → ${this._styler.hilite(o.using)}`);
+                }
+                const confirmed = yield this._ui.promptConfirm("confirmOverrides", "Proceed with the above substitutions?", true);
+                if (!confirmed)
+                    return undefined;
+            }
+            return yield this.buildCandidate_silently(partial, rootMap, explicit);
+        });
+    }
+    setSource(userInput, overrides) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let invalidInput = false;
+            if (userInput != undefined && !SOURCES.includes(userInput)) {
+                invalidInput = true;
+                overrides.push({ param: 'source', given: String(userInput), using: '(to be selected)' });
+                userInput = undefined;
+            }
+            if (userInput != undefined) {
+                this._ui.userMessage(`Model source: ${this._styler.hilite(userInput)}`);
+                return userInput;
+            }
+            if (invalidInput) {
+                this._ui.userMessage(this._styler.colorWarning("Provided source was not valid; please select from the list below."));
+            }
+            const selected = yield this._ui.promptSelect('source', 'Serve a catalog model in-cluster, or register a BYO endpoint?', [
+                { name: 'served — in-cluster (ClusterIP) catalog model', value: 'served' },
+                { name: 'byo — external OpenAI-compatible endpoint', value: 'byo' },
+            ], false, false);
+            const resolved = selected !== null && selected !== void 0 ? selected : SOURCES[0];
+            if (invalidInput)
+                overrides[overrides.length - 1].using = resolved;
+            return resolved;
+        });
+    }
+    setModel(userInput, overrides) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let invalidInput = false;
+            if (userInput != undefined && !(0, model_spec_1.isServedModelKind)(userInput)) {
+                invalidInput = true;
+                overrides.push({ param: 'model', given: String(userInput), using: '(to be selected)' });
+                userInput = undefined;
+            }
+            if (userInput != undefined) {
+                const spec = (0, model_spec_1.resolveModelSpec)(userInput);
+                this._ui.userMessage(`Model: ${this._styler.hilite(userInput)} (${spec.defaultTag}, ${spec.license})`);
+                return userInput;
+            }
+            if (invalidInput) {
+                this._ui.userMessage(this._styler.colorWarning("Provided model is not in the served catalog; please select from the list below."));
+            }
+            const choices = (0, model_spec_1.supportedModelKinds)().map(k => {
+                const s = (0, model_spec_1.resolveModelSpec)(k);
+                return { name: `${k} — ${s.defaultTag} (${s.license}, ${s.runtimeTier})`, value: k };
+            });
+            const selected = yield this._ui.promptSelect('model', 'Select a catalog model to serve:', choices, false, false);
+            const resolved = selected !== null && selected !== void 0 ? selected : (0, model_spec_1.supportedModelKinds)()[0];
+            if (invalidInput)
+                overrides[overrides.length - 1].using = resolved;
+            return resolved;
+        });
+    }
+    setRuntime(modelKind, userInput, takeDefaults, overrides) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const spec = (0, model_spec_1.resolveModelSpec)(modelKind);
+            let invalidInput = false;
+            if (userInput != undefined && !RUNTIME_TIERS.includes(userInput)) {
+                invalidInput = true;
+                overrides.push({ param: 'runtime', given: String(userInput), using: '(to be selected)' });
+                userInput = undefined;
+            }
+            if (userInput != undefined) {
+                this._ui.userMessage(`Runtime tier: ${this._styler.hilite(userInput)}`);
+                return userInput;
+            }
+            // One-and-only-ish default: the catalog's natural tier for this model.
+            const defaultTier = spec.runtimeTier;
+            if (!invalidInput) {
+                if (takeDefaults) {
+                    this._ui.userMessage(`Runtime tier: ${this._styler.hilite(defaultTier)}`);
+                    return defaultTier;
+                }
+                const hint = spec.minGpu ? ` (${modelKind} is impractical CPU-only; GPU recommended)` : '';
+                if (yield this._ui.promptConfirm('runtime', `Runtime tier: ${this._styler.hilite(defaultTier)}${hint} `, true)) {
+                    return defaultTier;
+                }
+            }
+            else {
+                this._ui.userMessage(this._styler.colorWarning("Provided runtime was not valid; please select from the list below."));
+            }
+            const selected = yield this._ui.promptSelect('runtimeSelect', 'Select a runtime tier:', RUNTIME_TIERS, false, false);
+            const resolved = selected !== null && selected !== void 0 ? selected : defaultTier;
+            if (invalidInput)
+                overrides[overrides.length - 1].using = resolved;
+            return resolved;
+        });
+    }
+    setAttach(userInput, takeDefaults, overrides) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let invalidInput = false;
+            if (userInput != undefined && !ATTACH_KINDS.includes(userInput)) {
+                invalidInput = true;
+                overrides.push({ param: 'attach', given: String(userInput), using: '(to be selected)' });
+                userInput = undefined;
+            }
+            if (userInput != undefined) {
+                this._ui.userMessage(`Attach to agent: ${this._styler.hilite(userInput)}`);
+                return userInput;
+            }
+            const defaultKind = 'none';
+            if (takeDefaults) {
+                this._ui.userMessage(`Attach to agent: ${this._styler.hilite(defaultKind)}`);
+                return defaultKind;
+            }
+            if (invalidInput) {
+                this._ui.userMessage(this._styler.colorWarning("Provided attach mode was not valid; please select from the list below."));
+            }
+            const selected = yield this._ui.promptSelect('attach', 'Wire this model to an agent?', [
+                { name: 'none — provision the model only', value: 'none' },
+                { name: 'existing — attach to an already-installed agent', value: 'existing' },
+                { name: 'new — install a fresh agent wired to this model', value: 'new' },
+            ], false, false);
+            const resolved = selected !== null && selected !== void 0 ? selected : defaultKind;
+            if (invalidInput)
+                overrides[overrides.length - 1].using = resolved;
+            return resolved;
+        });
+    }
+    setAgent(userInput, userSuppliedValue) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (userInput && !_.isEmpty(userInput) && userSuppliedValue === userInput) {
+                this._ui.userMessage(`Agent to attach: ${this._styler.hilite(userInput)}`);
+                return userInput;
+            }
+            const typed = yield this._ui.prompt('agent', 'Name of the agent to wire the model into:', true, userInput);
+            return (typed !== null && typed !== void 0 ? typed : '').trim();
+        });
+    }
+    setFramework(userInput, userSuppliedValue) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (userInput && !_.isEmpty(userInput) && userSuppliedValue === userInput) {
+                this._ui.userMessage(`Agent framework to install: ${this._styler.hilite(userInput)}`);
+                return userInput;
+            }
+            const typed = yield this._ui.prompt('framework', 'Agent framework to install and wire (e.g. hermes):', true, userInput);
+            return (typed !== null && typed !== void 0 ? typed : '').trim();
+        });
+    }
+    setBaseUrl(userInput, userSuppliedValue) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (userInput && !_.isEmpty(userInput) && userSuppliedValue === userInput) {
+                this._ui.userMessage(`Endpoint base URL: ${this._styler.hilite(userInput)}`);
+                return userInput;
+            }
+            const typed = yield this._ui.prompt('baseUrl', 'OpenAI-compatible base URL (e.g. https://host/v1):', true, userInput);
+            return (typed !== null && typed !== void 0 ? typed : '').trim();
+        });
+    }
+    setKey(userInput) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Already provided on the CLI (Rule 2 — do not re-prompt for an explicitly supplied value).
+            if (userInput && !_.isEmpty(userInput))
+                return userInput;
+            const key = yield this._ui.promptPassword('key', 'API key for the endpoint (leave blank if none):');
+            return (key && !_.isEmpty(key)) ? key : undefined;
+        });
+    }
+    setName(userInput, takeDefaults, userSuppliedValue) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (userInput && !_.isEmpty(userInput) && userSuppliedValue === userInput) {
+                this._ui.userMessage(`Model name: ${this._styler.hilite(userInput)}`);
+                return userInput;
+            }
+            // No explicit name: the server assigns a default handle. Offer to set a custom one, unless
+            // --take-defaults, in which case accept the server default silently.
+            if (takeDefaults)
+                return userInput && !_.isEmpty(userInput) ? userInput : undefined;
+            const setCustom = yield this._ui.promptConfirm('setName', 'Assign a custom model name? (default: server-assigned)', false);
+            if (!setCustom)
+                return undefined;
+            const typed = yield this._ui.prompt('name', 'Enter model name:', true, userInput);
+            return (typed && !_.isEmpty(typed)) ? typed.trim() : undefined;
+        });
+    }
+    buildCommandString(candidate, cmd) {
+        var _a;
+        cmd.push("-e", candidate.enterprise);
+        cmd.push("--source", candidate.source);
+        if (candidate.model)
+            cmd.push("-m", candidate.model);
+        if (candidate.runtime)
+            cmd.push("--runtime", candidate.runtime);
+        if (candidate.baseUrl)
+            cmd.push("--base-url", candidate.baseUrl);
+        if (candidate.key)
+            cmd.push("--key", candidate.key);
+        cmd.push("-c", candidate.cabinet);
+        if (candidate.name)
+            cmd.push("-n", candidate.name);
+        cmd.push("--attach", candidate.attach);
+        if (candidate.agent)
+            cmd.push("--agent", candidate.agent);
+        if (candidate.framework)
+            cmd.push("--framework", candidate.framework);
+        for (const [k, v] of Object.entries((_a = candidate.inputs) !== null && _a !== void 0 ? _a : {}))
+            cmd.push("--input", `${k}=${v}`);
+        cmd.push("--silent");
+        return cmd;
+    }
+    // NOTE: thin client over `post.ai-model-provision` — all provisioning logic (chart repo, GPU
+    // preflight, asset deploy, secret + scoped-settings, attach) lives server-side in the relay.
+    // This method only builds the request, calls the endpoint, and drives the needs_action loop.
+    executeTask(candidate) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Seed inputs from the candidate's threaded --input values (captured in captureArgs — this
+            // command never re-parses flags downstream). Remediation answers accumulate here across re-calls.
+            const inputs = Object.assign({}, ((_a = candidate.inputs) !== null && _a !== void 0 ? _a : {}));
+            const attemptedCodes = new Set();
+            while (true) {
+                const request = this.toProvisionRequest(candidate, inputs);
+                // ASYNC (ack-then-stream): the endpoint acks immediately; the rich result (ok / needs_action
+                // / failed) arrives as the terminal status event's resultPayload, surfaced here as this
+                // SingleResult. A long synchronous reply would hang across the tenant→hub NATS service-import.
+                const result = yield this.watcher.triggerAndWatch((correlationId, socketId) => this.genRelayClient.Call.aiModelProvision(Object.assign(Object.assign({}, request), { correlationId, socketId })));
+                if (result.error || !result.output) {
+                    const label = candidate.source === 'byo' ? ((_b = candidate.baseUrl) !== null && _b !== void 0 ? _b : 'byo endpoint') : ((_c = candidate.model) !== null && _c !== void 0 ? _c : 'model');
+                    const msg = `Error provisioning model [${label}]: ${(_d = result.message) !== null && _d !== void 0 ? _d : ''} ${(_f = (_e = result.error) === null || _e === void 0 ? void 0 : _e.message) !== null && _f !== void 0 ? _f : ''}`.trimEnd();
+                    this.logger.error(msg, result.error);
+                    this._ui.userMessage(`${this._styler.colorCritical('ERROR!')} ${msg}`);
+                    throw (_g = result.error) !== null && _g !== void 0 ? _g : new Error(msg);
+                }
+                const out = result.output;
+                this.printStepResults(out.steps);
+                if (out.status === 'ok') {
+                    this.printModelInfo(candidate, out.model);
+                    // attach === 'new' is composed here, CLI-side (no new relay code): once the model is
+                    // ready, install a fresh agent already wired to it by threading the model's endpoint
+                    // through the existing agent-provision `overrides` (the modelBaseUrl/modelApiKey chart
+                    // values Task 2 added to the hermes chart). 'existing'/'none' were handled server-side
+                    // by the relay from the `attach` passed on the provision request above.
+                    if (candidate.attach === 'new' && out.model) {
+                        yield this.wireNewAgent(candidate, out.model);
+                    }
+                    return;
+                }
+                if (out.status === 'failed') {
+                    const msg = `Failed provisioning model: ${(_j = (_h = out.error) === null || _h === void 0 ? void 0 : _h.message) !== null && _j !== void 0 ? _j : ''}`.trimEnd();
+                    this.logger.notice(msg, out);
+                    this._ui.userMessage(`${this._styler.colorCritical('FAILED!')} ${msg}`);
+                    throw new Error(msg);
+                }
+                // status === 'needs_action'
+                const rem = out.nextAction;
+                const needs = (_l = (_k = rem.resolvedBy) === null || _k === void 0 ? void 0 : _k.needs) !== null && _l !== void 0 ? _l : [];
+                if (this.isSilentMode()) {
+                    const missing = needs.map(f => f.name).join(', ');
+                    const hint = ((_m = rem.resolvedBy) === null || _m === void 0 ? void 0 : _m.cliCommand) ? ` Resolve with: ${rem.resolvedBy.cliCommand}` : '';
+                    throw new Error(`Cannot proceed in --silent mode: ${rem.reason}${missing ? ` (missing: ${missing})` : ''}.${hint}`);
+                }
+                this.renderRemediationGuidance(rem, candidate);
+                if (needs.length > 0) {
+                    for (const f of needs) {
+                        const value = f.secret
+                            ? yield this._ui.promptPassword(f.name, `${rem.reason}\n${f.label}:`)
+                            : yield this._ui.prompt(f.name, `${rem.reason}\n${f.label}:`, true);
+                        // Only carry a non-empty answer forward — an empty string is "not provided", never a
+                        // real value. Seeding inputs[key]="" would re-block on recheck.
+                        if (value != undefined && value.trim() !== "")
+                            inputs[f.name] = value;
+                    }
+                }
+                else {
+                    this._ui.userMessage(this._styler.colorWarning(`Action needed (${rem.code}): ${rem.reason}`));
+                    if ((_o = rem.resolvedBy) === null || _o === void 0 ? void 0 : _o.cliCommand)
+                        this._ui.userMessage(`Resolve with:  ${this._styler.hilite(rem.resolvedBy.cliCommand)}`);
+                    const proceed = yield this._ui.promptConfirm('recheck', "Re-check after you've resolved this?", true);
+                    if (!proceed)
+                        return;
+                }
+                // Loop guard: same remediation code twice with no new inputs → abort (never spin forever).
+                if (attemptedCodes.has(rem.code) && needs.length === 0) {
+                    const msg = `Still blocked on [${rem.code}]: ${rem.reason}`;
+                    this._ui.userMessage(this._styler.colorCritical(msg));
+                    throw new Error(msg);
+                }
+                attemptedCodes.add(rem.code);
+            }
+        });
+    }
+    /** Maps the resolved candidate (plus any remediation inputs gathered so far) to the
+     *  `post.ai-model-provision` request shape. */
+    toProvisionRequest(candidate, inputs) {
+        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ enterprise: candidate.enterprise, cabinet: candidate.cabinet, mode: candidate.source }, (candidate.model ? { model: candidate.model } : {})), (candidate.runtime ? { runtime: candidate.runtime } : {})), (candidate.baseUrl ? { baseUrl: candidate.baseUrl } : {})), (candidate.key ? { key: candidate.key } : {})), { 
+            // Pass attach straight through — the relay handles kind 'existing'/'none'; 'new' is
+            // CLI-composed in Task 8 (see the TODO in executeTask).
+            attach: Object.assign(Object.assign({ kind: candidate.attach }, (candidate.agent ? { agentName: candidate.agent } : {})), (candidate.framework ? { framework: candidate.framework } : {})) }), (candidate.name ? { name: candidate.name } : {})), { inputs });
+    }
+    /** attach === 'new': installs a fresh agent already wired to the just-provisioned model, entirely
+     *  CLI-side (no new relay endpoint) — it reuses the existing `aiAgentProvision` op, threading the
+     *  model's endpoint through `overrides` as the `modelBaseUrl`/`modelApiKey` chart values the
+     *  hermes chart consumes. Runs the same ack-then-stream needs_action loop shape as `cod ai agent
+     *  install`. Never exposes ingress (`hasIngress:false`) so the wiring cannot demand a host-naming
+     *  strategy — the wiring is env-only and must succeed headlessly; the agent still reaches the
+     *  model in-cluster. */
+    wireNewAgent(candidate, model) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const framework = candidate.framework;
+            const name = this.deriveAgentName(framework);
+            // Served models front an unauthenticated in-cluster Ollama, so a placeholder key is used;
+            // BYO models pass through the real --key the caller supplied (or the same placeholder if none).
+            const modelApiKey = candidate.source === 'byo' ? ((_a = candidate.key) !== null && _a !== void 0 ? _a : 'ollama') : 'ollama';
+            this._ui.userMessage(`Installing a new ${this._styler.hilite(framework)} agent [${this._styler.hilite(name)}] wired to model ${this._styler.hilite(model.handle)}...`);
+            const inputs = {};
+            const attemptedCodes = new Set();
+            while (true) {
+                const request = {
+                    enterprise: candidate.enterprise,
+                    cabinet: candidate.cabinet,
+                    framework: framework,
+                    name,
+                    hasIngress: false,
+                    overrides: { modelBaseUrl: model.endpoint, modelApiKey },
+                    inputs,
+                };
+                // Same ASYNC ack-then-stream contract as the model provision above and `cod ai agent install`.
+                const result = yield this.watcher.triggerAndWatch((correlationId, socketId) => this.genRelayClient.Call.aiAgentProvision(Object.assign(Object.assign({}, request), { correlationId, socketId })));
+                if (result.error || !result.output) {
+                    const msg = `Error installing the wired agent [${name}]: ${(_b = result.message) !== null && _b !== void 0 ? _b : ''} ${(_d = (_c = result.error) === null || _c === void 0 ? void 0 : _c.message) !== null && _d !== void 0 ? _d : ''}`.trimEnd();
+                    this.logger.error(msg, result.error);
+                    this._ui.userMessage(`${this._styler.colorCritical('ERROR!')} ${msg}`);
+                    throw (_e = result.error) !== null && _e !== void 0 ? _e : new Error(msg);
+                }
+                const out = result.output;
+                this.printStepResults(out.steps);
+                if (out.status === 'ok') {
+                    this.printAgentInfo(name, out.agent);
+                    return;
+                }
+                if (out.status === 'failed') {
+                    const msg = `Failed installing the wired agent [${name}]: ${(_g = (_f = out.error) === null || _f === void 0 ? void 0 : _f.message) !== null && _g !== void 0 ? _g : ''}`.trimEnd();
+                    this.logger.notice(msg, out);
+                    this._ui.userMessage(`${this._styler.colorCritical('FAILED!')} ${msg}`);
+                    throw new Error(msg);
+                }
+                // status === 'needs_action'
+                const rem = out.nextAction;
+                const needs = (_j = (_h = rem.resolvedBy) === null || _h === void 0 ? void 0 : _h.needs) !== null && _j !== void 0 ? _j : [];
+                if (this.isSilentMode()) {
+                    const missing = needs.map(f => f.name).join(', ');
+                    const hint = ((_k = rem.resolvedBy) === null || _k === void 0 ? void 0 : _k.cliCommand) ? ` Resolve with: ${rem.resolvedBy.cliCommand}` : '';
+                    throw new Error(`Cannot install the wired agent in --silent mode: ${rem.reason}${missing ? ` (missing: ${missing})` : ''}.${hint}`);
+                }
+                if (needs.length > 0) {
+                    for (const f of needs) {
+                        const value = f.secret
+                            ? yield this._ui.promptPassword(f.name, `${rem.reason}\n${f.label}:`)
+                            : yield this._ui.prompt(f.name, `${rem.reason}\n${f.label}:`, true);
+                        if (value != undefined && value.trim() !== "")
+                            inputs[f.name] = value;
+                    }
+                }
+                else {
+                    this._ui.userMessage(this._styler.colorWarning(`Action needed (${rem.code}): ${rem.reason}`));
+                    if ((_l = rem.resolvedBy) === null || _l === void 0 ? void 0 : _l.cliCommand)
+                        this._ui.userMessage(`Resolve with:  ${this._styler.hilite(rem.resolvedBy.cliCommand)}`);
+                    const proceed = yield this._ui.promptConfirm('recheckAgent', "Re-check after you've resolved this?", true);
+                    if (!proceed)
+                        return;
+                }
+                if (attemptedCodes.has(rem.code) && needs.length === 0) {
+                    const msg = `Still blocked installing the wired agent on [${rem.code}]: ${rem.reason}`;
+                    this._ui.userMessage(this._styler.colorCritical(msg));
+                    throw new Error(msg);
+                }
+                attemptedCodes.add(rem.code);
+            }
+        });
+    }
+    /** Derives the fresh agent's name from its framework — the framework's catalog default name
+     *  (e.g. hermes → "hermes-agent") when known, else "<framework>-agent". */
+    deriveAgentName(framework) {
+        try {
+            return (0, framework_spec_1.resolveFrameworkSpec)(framework).defaultName;
+        }
+        catch (_a) {
+            return `${framework}-agent`;
+        }
+    }
+    /** Best-effort note about the freshly wired agent — prefers the server-resolved URL, else states
+     *  it is reachable in-cluster (attach=new never requests ingress). */
+    printAgentInfo(name, agent) {
+        if (agent === null || agent === void 0 ? void 0 : agent.url) {
+            this._ui.userMessage(`${this._styler.colorGood('READY')} Wired agent ${this._styler.hilite(name)}: ${this._styler.hilite(agent.url)}`);
+        }
+        else {
+            this._ui.userMessage(`${this._styler.colorGood('READY')} Wired agent ${this._styler.hilite(name)} installed (reachable in-cluster; no ingress).`);
+        }
+    }
+    /** Adds code-specific guidance ahead of the generic needs/consent handling for the model-side
+     *  remediation codes. */
+    renderRemediationGuidance(rem, candidate) {
+        var _a, _b, _c, _d, _e, _f;
+        switch (rem.code) {
+            case 'NO_GPU_NODEPOOL': {
+                const cluster = (_f = (_c = (_b = (_a = rem.resolvedBy) === null || _a === void 0 ? void 0 : _a.params) === null || _b === void 0 ? void 0 : _b.cluster) !== null && _c !== void 0 ? _c : (_e = (_d = rem.resolvedBy) === null || _d === void 0 ? void 0 : _d.params) === null || _e === void 0 ? void 0 : _e.clusterName) !== null && _f !== void 0 ? _f : `cabinet ${candidate.cabinet}`;
+                this._ui.userMessage(this._styler.colorWarning(`No GPU node pool found. Add a GPU node pool to ${cluster}, then re-check — or re-run with --runtime cpu if this model is CPU-viable.`));
+                break;
+            }
+            case 'MODEL_NOT_READY':
+                this._ui.userMessage(this._styler.colorWarning(`The model endpoint is not ready yet: ${rem.reason}. Verify the endpoint is reachable, or pass --input skipReachabilityCheck=true to skip the probe.`));
+                break;
+            case 'NEEDS_AGENT_NAME':
+                this._ui.userMessage(this._styler.colorWarning(`An agent name is required to attach this model: ${rem.reason}. Provide one with --agent <name>.`));
+                break;
+            default:
+                break;
+        }
+    }
+    /** One line per step: `<step>: <status>` (+ detail when present). */
+    printStepResults(steps) {
+        for (const s of steps) {
+            const line = s.detail ? `${s.step}: ${s.status} — ${s.detail}` : `${s.step}: ${s.status}`;
+            if (s.status === 'failed')
+                this._ui.userMessage(this._styler.colorCritical(line));
+            else if (s.status === 'blocked')
+                this._ui.userMessage(this._styler.colorWarning(line));
+            else
+                this._ui.userMessage(this._styler.colorGood(line));
+        }
+    }
+    /** Prints the ready model's handle + in-cluster (or BYO) endpoint. */
+    printModelInfo(candidate, model) {
+        if (model) {
+            this._ui.userMessage(`${this._styler.colorGood('READY')} Model ${this._styler.hilite(model.handle)} (${model.mode}, ${model.exposure}) in cabinet [${model.cabinet}].`);
+            this._ui.userMessage(`  Endpoint: ${this._styler.hilite(model.endpoint)}`);
+        }
+        else {
+            this._ui.userMessage(`${this._styler.colorGood('READY')} Model provisioned in cabinet [${this._styler.hilite(candidate.cabinet)}].`);
+        }
+    }
+    /** Silent mode disables all prompting (the base lifecycle rebinds `_ui` to a throwing
+     *  provider) — mirrors the same detection `CommandBaseExec.runAsync()` uses, so a
+     *  `needs_action` response can fail fast with a clear message. */
+    isSilentMode() {
+        return this.argv.includes('--silent') || this.pipedInput != undefined;
+    }
+}
+exports.default = AiModelInstall;
+AiModelInstall.description = 'Provisions a private LLM into an enterprise cabinet — either an in-cluster (ClusterIP-only) catalog model served via Ollama, or a registered bring-your-own OpenAI-compatible endpoint.';
+AiModelInstall.examples = [
+    {
+        description: 'Serve the Qwen3 catalog model (CPU) into the dev cabinet of the ben enterprise.',
+        command: '<%= config.bin %> <%= command.id %> -e ben --source served -m qwen3 --runtime cpu -c dev',
+    },
+    {
+        description: 'Non-interactive (scripted) served install; a served model needs both --model and --runtime.',
+        command: '<%= config.bin %> <%= command.id %> -e ben --source served -m qwen3 --runtime cpu -c dev --attach none --silent',
+    },
+    {
+        description: 'Register a BYO OpenAI-compatible endpoint and attach it to an existing agent.',
+        command: '<%= config.bin %> <%= command.id %> -e ben --source byo --base-url https://host/v1 --key sk-... -c dev --attach existing --agent hermes-agent --silent',
+    },
+    {
+        description: 'Renders the equivalent silent command and then executes.',
+        command: '<%= config.bin %> <%= command.id %> -e ben --source served -m qwen3 --runtime cpu -c dev --echo',
+    },
+    {
+        description: 'Renders the equivalent silent command without executing.',
+        command: '<%= config.bin %> <%= command.id %> -e ben --source served -m qwen3 --runtime cpu -c dev --to-script',
+    },
+];
+AiModelInstall.flags = {
+    help: core_1.Flags.help({ char: 'h' }),
+    enterpriseCode: core_1.Flags.string({ char: 'e', required: false, description: 'Code name identifying the target enterprise.' }),
+    source: core_1.Flags.string({ options: ['served', 'byo'], description: 'Serve a license-clean catalog model in-cluster (served) or register an external OpenAI-compatible endpoint (byo).' }),
+    model: core_1.Flags.string({ char: 'm', description: `Catalog model kind to serve when --source served (one of: ${(0, model_spec_1.supportedModelKinds)().join(', ')}).` }),
+    runtime: core_1.Flags.string({ options: ['cpu', 'gpu'], description: 'Compute tier for a served model: cpu-only, or scheduled onto a GPU node pool.' }),
+    'base-url': core_1.Flags.string({ description: 'OpenAI-compatible base URL of the endpoint to register when --source byo (e.g. https://host/v1).' }),
+    key: core_1.Flags.string({ description: 'API key for the BYO endpoint (prompted as a secret during install when omitted; stored server-side as a secret).' }),
+    cabinet: core_1.Flags.string({ char: 'c', description: 'Cabinet (environment) the model is deployed into (served) or registered against (byo).' }),
+    name: core_1.Flags.string({ char: 'n', description: 'Handle for the model workload (server-assigns a default when omitted).' }),
+    attach: core_1.Flags.string({ options: ['existing', 'new', 'none'], description: 'Wire the model to an agent once ready: attach to an existing agent, install a new one, or neither (defaults to none).' }),
+    agent: core_1.Flags.string({ description: 'Name of the already-installed agent to wire the model into (required with --attach existing).' }),
+    framework: core_1.Flags.string({ description: 'Agent framework to install and wire to the model (required with --attach new).' }),
+    input: core_1.Flags.string({ multiple: true, description: 'Pre-supply a needs_action input as key=value (repeatable), e.g. --input skipReachabilityCheck=true . Lets --silent/headless runs resolve secret/decision prompts without interaction.' }),
+    // Interaction mode flags (TODO: will eventually move to base class)
+    "take-defaults": core_1.Flags.boolean({ exclusive: ["silent"], description: "Prevents prompting for confirmation on parameters that were passed in or were automatically set to default values (Irrelevant in --silent mode).  This behavior does NOT apply to scenarios where the command needs to override invalid user input; such cases will always prompt for confirmation." }),
+    silent: core_1.Flags.boolean({ exclusive: ["echo", "to-script"], description: 'Executes without any user interaction; fails on missing or invalid arguments.' }),
+    echo: core_1.Flags.boolean({ exclusive: ["to-script", "silent"], description: 'Renders the equivalent non-interactive command for future use before executing.' }),
+    "to-script": core_1.Flags.boolean({ exclusive: ["echo", "silent"], description: 'Renders the equivalent non-interactive command without executing it.' }),
+};
+AiModelInstall.args = {};
+//# sourceMappingURL=install.js.map