@telefonica/ai-sdlc-opencode-plugin-v1-dev 1.0.0 → 1.0.1

package/README.md

@@ -17,4 +17,7 @@ opencode plugin -g @telefonica/ai-sdlc-opencode-plugin-v1-dev
 Restart OpenCode, run `/connect`, choose **CDO.AI**, and enter the gateway URL
 and API key. Restart OpenCode once more after connecting so the model list loads.
 
+The sidebar displays usage, average spend per elapsed workday, and workdays remaining
+this month on a separate line.
+
 Using OpenCode 2.x? Install `@telefonica/ai-sdlc-opencode-plugin-v2` instead.

package/dist/flavor-8QVaVpzl.js

@@ -0,0 +1,405 @@
+//#region ../common/dist/model-name.js
+const SPECIAL_LABELS = {
+	cdo: "CDO",
+	deepseek: "DeepSeek",
+	"d-seek": "DeepSeek",
+	gemi: "Gemini",
+	gpt: "GPT",
+	km: "Kimi"
+};
+function words(value) {
+	return value.trim().split(/[\s-]+/).filter(Boolean);
+}
+function joinAdjacentNumbers(parts) {
+	const result = [];
+	for (let index = 0; index < parts.length; index += 1) if (/^v\d+(?:\.\d+)*$/i.test(parts[index])) {
+		let version = `v${parts[index].slice(1)}`;
+		while (index + 1 < parts.length && /^\d+$/.test(parts[index + 1])) {
+			version += `.${parts[index + 1]}`;
+			index += 1;
+		}
+		result.push(version);
+	} else if (/^\d+(?:\.\d+)*$/.test(parts[index])) {
+		let number = parts[index];
+		while (index + 1 < parts.length && /^\d+$/.test(parts[index + 1])) {
+			number += `.${parts[index + 1]}`;
+			index += 1;
+		}
+		result.push(number);
+	} else result.push(parts[index]);
+	return result;
+}
+function titleCase(word) {
+	return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+}
+/** Converts a provider model ID into a readable label. */
+function unsanitizeModelId(modelId) {
+	const parts = words(modelId.replace(/^claude-/i, ""));
+	const normalized = [];
+	for (let index = 0; index < parts.length; index += 1) {
+		const current = parts[index].toLowerCase();
+		const next = parts[index + 1]?.toLowerCase();
+		if (current === "g" && next === "p" && parts[index + 2]?.toLowerCase() === "t") {
+			normalized.push("GPT");
+			index += 2;
+		} else if (current === "gp" && next === "t") {
+			normalized.push("GPT");
+			index += 1;
+		} else if (current === "gemi" && next === "n") {
+			normalized.push("Gemini");
+			index += 1;
+		} else if (current === "d" && next === "seek") {
+			normalized.push("DeepSeek");
+			index += 1;
+		} else normalized.push(Object.hasOwn(SPECIAL_LABELS, current) ? SPECIAL_LABELS[current] : current);
+	}
+	return joinAdjacentNumbers(normalized.at(-1)?.toLowerCase() === "az" ? normalized.slice(0, -1) : normalized).map((part) => {
+		if (/^(CDO|GPT|Gemini|Kimi|DeepSeek)$/.test(part) || /^v\d/i.test(part) || /^\d/.test(part)) return part;
+		return titleCase(part);
+	}).join(" ");
+}
+//#endregion
+//#region ../common/dist/copy.js
+const PLUGIN_UI = {
+	barWidth: 20,
+	warningPercent: 80,
+	exceededPercent: 100
+};
+const formatMoney = (amount) => `$${amount.toFixed(2)}`;
+const PLUGIN_COPY = {
+	apiKeyLabel: (displayName) => `${displayName} API key`,
+	proxyURLLabel: (displayName) => `${displayName} Proxy URL`,
+	proxyURLPlaceholder: "https://litellm.example.com",
+	proxyURLRequired: "Proxy URL is required",
+	connectCommand: (integrationID) => `/connect ${integrationID}`,
+	usageUnavailable: (message) => `Usage unavailable: ${message}`,
+	notConnected: (command) => `not connected — run ${command}`,
+	formatMoney,
+	usageValues: (spend, budget) => `${formatMoney(spend)} / ${budget == null ? "∞" : formatMoney(budget)}`,
+	formatPercent: (percent) => `${percent.toFixed(1)}%`,
+	budgetSourceLabels: {
+		key: "Personal API key budget",
+		user: "User budget",
+		"team-member": "Team member budget",
+		"team-member-default": "Team default budget",
+		none: "No budget set"
+	},
+	progressBar: (percent, width = PLUGIN_UI.barWidth) => {
+		const filled = Math.round(Math.max(0, Math.min(100, percent)) / 100 * width);
+		return "█".repeat(filled) + "░".repeat(width - filled);
+	},
+	perWorkday: (amount) => `${amount} per work day`,
+	workdaysRemaining: (count) => `${count} work days remaining`
+};
+//#endregion
+//#region ../common/dist/flavors.js
+function defineFlavor(environment, providerID, displayName) {
+	const serverPluginID = `ai-sdlc-opencode-${providerID}-plugin`;
+	return {
+		environment,
+		providerID,
+		integrationID: providerID,
+		rpcID: providerID,
+		serverPluginID,
+		tuiPluginID: `${serverPluginID}.tui`,
+		displayName,
+		connectLabel: PLUGIN_COPY.apiKeyLabel(displayName),
+		keyEnvironmentPrefix: environment === "dev" ? "CDO_AI_DEV" : "CDO_AI",
+		debugFile: `/tmp/${providerID}-debug.json`,
+		budgetStorageKey: `${providerID}.budget`
+	};
+}
+const PLUGIN_FLAVORS = {
+	prod: defineFlavor("prod", "cdo-ai", "CDO.AI"),
+	dev: defineFlavor("dev", "cdo-ai-dev", "CDO.AI (dev)")
+};
+//#endregion
+//#region ../common/dist/reasoning-efforts.js
+const EFFORT_ORDER = [
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const BASELINE_EFFORTS = [
+	"low",
+	"medium",
+	"high"
+];
+const RESTRICTED_EFFORTS = /* @__PURE__ */ new Map([
+	["gpt-5-pro", ["high"]],
+	["gpt-5.2-pro", [
+		"medium",
+		"high",
+		"xhigh"
+	]],
+	["gpt-5.4-pro", [
+		"medium",
+		"high",
+		"xhigh"
+	]]
+]);
+function restrictedEfforts(...identifiers) {
+	for (const identifier of identifiers) {
+		if (typeof identifier !== "string") continue;
+		const model = identifier.split("/").pop()?.replace(/-\d{4}-\d{2}-\d{2}$/, "");
+		const efforts = model ? RESTRICTED_EFFORTS.get(model) : void 0;
+		if (efforts) return efforts;
+	}
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function resolveReasoningEfforts(info, params) {
+	const metadata = { ...params ?? {} };
+	for (const [key, value] of Object.entries(info)) if (value != null) metadata[key] = value;
+	if (metadata.supports_reasoning === false) return [];
+	for (const key of ["reasoning_effort_levels", "supports_reasoning_efforts"]) {
+		const levels = metadata[key];
+		if (Array.isArray(levels)) {
+			const explicit = [...new Set(levels.filter((level) => typeof level === "string"))];
+			const restricted = restrictedEfforts(metadata.key, metadata.model, metadata.base_model);
+			return restricted ? explicit.filter((effort) => restricted.includes(effort)) : explicit;
+		}
+	}
+	const supportedParams = metadata.supported_openai_params;
+	if (Array.isArray(supportedParams) && !supportedParams.includes("reasoning_effort") && !supportedParams.includes("reasoning")) return [];
+	const flags = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(metadata)) {
+		const match = key.match(/^supports_([a-z]+)_reasoning_effort$/);
+		if (match && typeof value === "boolean") flags.set(match[1], value);
+	}
+	if (flags.size === 0 || metadata.supports_reasoning !== true && ![...flags.values()].includes(true)) return;
+	const efforts = /* @__PURE__ */ new Set();
+	for (const effort of BASELINE_EFFORTS) if (flags.get(effort) !== false) efforts.add(effort);
+	for (const [effort, supported] of flags) if (supported) efforts.add(effort);
+	const restricted = restrictedEfforts(metadata.key, metadata.model, metadata.base_model);
+	if (restricted) {
+		for (const effort of [...efforts]) if (!restricted.includes(effort)) efforts.delete(effort);
+	}
+	return [...EFFORT_ORDER.filter((effort) => efforts.has(effort)), ...[...efforts].filter((effort) => !EFFORT_ORDER.includes(effort))];
+}
+//#endregion
+//#region ../common/dist/models.js
+function finiteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function booleanValue(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function normalizeModel(entry, info, params) {
+	const value = {
+		...entry,
+		...info ?? {}
+	};
+	const reasoning = resolveReasoningEfforts(info ?? {}, params);
+	const mode = typeof value.mode === "string" ? value.mode : void 0;
+	return Object.fromEntries(Object.entries({
+		id: entry.id,
+		name: unsanitizeModelId(entry.id),
+		mode,
+		contextTokens: finiteNumber(value.max_input_tokens) ?? finiteNumber(value.max_tokens),
+		inputTokens: finiteNumber(value.max_input_tokens),
+		outputTokens: finiteNumber(value.max_output_tokens),
+		inputCostPerToken: finiteNumber(value.input_cost_per_token),
+		outputCostPerToken: finiteNumber(value.output_cost_per_token),
+		cacheReadCostPerToken: finiteNumber(value.cache_read_input_token_cost),
+		cacheWriteCostPerToken: finiteNumber(value.cache_creation_input_token_cost),
+		supportsTools: booleanValue(value.supports_function_calling),
+		supportsReasoning: booleanValue(info?.supports_reasoning) ?? booleanValue(params?.supports_reasoning),
+		supportsVision: booleanValue(value.supports_vision),
+		supportsPdf: booleanValue(value.supports_pdf_input),
+		supportsAudio: booleanValue(value.supports_audio_input) ?? booleanValue(params?.supports_audio_input),
+		reasoningEfforts: reasoning
+	}).filter(([, value]) => value !== void 0));
+}
+function invalid(message) {
+	return {
+		ok: false,
+		error: {
+			code: "invalid-response",
+			message
+		}
+	};
+}
+function httpError(status) {
+	return {
+		ok: false,
+		error: {
+			code: "http",
+			status,
+			message: `HTTP ${status}`
+		}
+	};
+}
+function safeEndpoint(endpoint) {
+	try {
+		const url = new URL(endpoint);
+		url.username = "";
+		url.password = "";
+		url.search = "";
+		url.hash = "";
+		return url.toString();
+	} catch {
+		return endpoint.split(/[?#]/, 1)[0] ?? endpoint;
+	}
+}
+function emitGatewayLog(options, event) {
+	const level = event.ok ? "info" : "error";
+	const message = `${event.operation} ${event.phase} ${event.ok ? "succeeded" : "failed"}`;
+	try {
+		const result = options.logger?.({
+			...event,
+			level,
+			message,
+			endpoint: safeEndpoint(event.endpoint)
+		});
+		if (result && typeof result.then === "function") result.catch(() => {});
+	} catch {}
+}
+async function fetchJSON(url, options, operation = "models.discover") {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 8e3);
+	const startedAt = Date.now();
+	let status;
+	let result;
+	try {
+		const response = await (options.fetchImpl ?? fetch)(url, {
+			headers: options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {},
+			signal: controller.signal
+		});
+		status = response.status;
+		if (!response.ok) result = httpError(response.status);
+		else try {
+			result = {
+				ok: true,
+				value: await response.json()
+			};
+		} catch {
+			result = invalid(`Invalid JSON from ${url}`);
+		}
+	} catch (error) {
+		result = {
+			ok: false,
+			error: {
+				code: controller.signal.aborted ? "timeout" : "network",
+				message: error instanceof Error ? error.message : "Network error"
+			}
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+	emitGatewayLog(options, {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		operation,
+		phase: "request",
+		endpoint: url,
+		ok: result.ok,
+		status,
+		durationMs: Date.now() - startedAt,
+		...!result.ok ? { errorCode: result.error.code } : {}
+	});
+	return result;
+}
+function modelRows(payload) {
+	if (!isRecord(payload) || !Array.isArray(payload.data) || payload.data.length === 0) return void 0;
+	if (!payload.data.every((entry) => isRecord(entry) && typeof entry.id === "string" && entry.id.length > 0)) return void 0;
+	return payload.data;
+}
+function infoRows(payload) {
+	if (!isRecord(payload) || !Array.isArray(payload.data)) return [];
+	return payload.data.filter(isRecord);
+}
+function usableModel(model) {
+	return !model.mode || model.mode === "chat";
+}
+async function discoverModelsResult(options) {
+	const startedAt = Date.now();
+	const baseURL = options.baseURL.trim().replace(/\/+$/, "").replace(/\/v1$/, "");
+	const [modelsResponse, infoResponse] = await Promise.all([fetchJSON(`${baseURL}/v1/models`, options, "models.discover"), fetchJSON(`${baseURL}/v1/model/info`, options, "models.discover")]);
+	let result;
+	if (!modelsResponse.ok) result = modelsResponse;
+	else {
+		const rows = modelRows(modelsResponse.value);
+		if (!rows) result = invalid("Invalid or empty /v1/models response");
+		else {
+			const infos = /* @__PURE__ */ new Map();
+			if (infoResponse.ok) {
+				for (const row of infoRows(infoResponse.value)) if (typeof row.model_name === "string") infos.set(row.model_name, row);
+			}
+			const models = rows.map((row) => {
+				const metadata = infos.get(row.id);
+				return normalizeModel(row, metadata?.model_info, metadata?.litellm_params);
+			}).filter(usableModel);
+			result = models.length > 0 ? {
+				ok: true,
+				value: models
+			} : invalid("No usable chat models in /v1/models response");
+		}
+	}
+	emitGatewayLog(options, {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		operation: "models.discover",
+		phase: "operation",
+		endpoint: `${baseURL}/v1/models`,
+		ok: result.ok,
+		durationMs: Date.now() - startedAt,
+		...!result.ok ? { errorCode: result.error.code } : {},
+		...result.ok ? { details: { modelCount: result.value.length } } : {}
+	});
+	return result;
+}
+async function discoverModels(options) {
+	return discoverModelsResult(options);
+}
+//#endregion
+//#region ../common/dist/presentation.js
+function normalizeProviderURL(url) {
+	const root = url.trim().replace(/\/+$/, "").replace(/(?:\/v1)+$/i, "");
+	return root ? `${root}/v1` : "";
+}
+function resolveUsagePercent(spend, budget) {
+	const thresholdPercent = budget != null && budget > 0 ? spend / budget * 100 : null;
+	return {
+		percent: thresholdPercent == null ? null : Math.round(thresholdPercent * 10) / 10,
+		thresholdPercent
+	};
+}
+const BUDGET_SOURCE_LABELS = PLUGIN_COPY.budgetSourceLabels;
+function calendarDate(value) {
+	return new Date(value.getFullYear(), value.getMonth(), value.getDate());
+}
+function monthlyUsageMetrics(spend, now = /* @__PURE__ */ new Date()) {
+	const today = calendarDate(now);
+	const monthEnd = new Date(today.getFullYear(), today.getMonth() + 1, 0);
+	let elapsedWeekdays = 0;
+	let remainingWorkdays = 0;
+	for (let day = 1; day <= monthEnd.getDate(); day++) {
+		const weekday = new Date(today.getFullYear(), today.getMonth(), day).getDay();
+		if (weekday === 0 || weekday === 6) continue;
+		if (day <= today.getDate()) elapsedWeekdays++;
+		else remainingWorkdays++;
+	}
+	return {
+		workdayAverage: elapsedWeekdays > 0 ? spend / elapsedWeekdays : null,
+		remainingWorkdays
+	};
+}
+//#endregion
+//#region src/flavor.ts
+function withV1Behavior(flavor, matchesPanelProvider) {
+	const apiKeyEnvVars = [`${flavor.keyEnvironmentPrefix}_API_KEY`, ...flavor.environment === "prod" ? ["LITELLM_API_KEY", "LITELLM_MASTER_KEY"] : []];
+	return {
+		...flavor,
+		connectLabel: PLUGIN_COPY.apiKeyLabel(flavor.displayName),
+		apiKeyEnvVars,
+		matchesPanelProvider
+	};
+}
+withV1Behavior(PLUGIN_FLAVORS.prod, (id) => id === PLUGIN_FLAVORS.prod.providerID || id.includes("litellm"));
+const DEV = withV1Behavior(PLUGIN_FLAVORS.dev, (id) => id === PLUGIN_FLAVORS.dev.providerID);
+//#endregion
+export { resolveUsagePercent as a, fetchJSON as c, PLUGIN_UI as d, unsanitizeModelId as f, normalizeProviderURL as i, isRecord as l, BUDGET_SOURCE_LABELS as n, discoverModels as o, monthlyUsageMetrics as r, emitGatewayLog as s, DEV as t, PLUGIN_COPY as u };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+//#region src/entry-dev.d.ts
+declare const _default: {
+  id: string;
+  server: import("@opencode-ai/plugin").Plugin;
+};
+//#endregion
+export { _default as default };

package/dist/index.js

@@ -1,8 +1,116 @@
-import { t as DEV } from "./flavor-CMZWvD--.js";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { f as unsanitizeModelId, i as normalizeProviderURL, o as discoverModels, t as DEV, u as PLUGIN_COPY } from "./flavor-8QVaVpzl.js";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { createHash } from "node:crypto";
+//#region ../common/dist/cache.js
+function cacheDirectory() {
+	const root = process.env["XDG_CACHE_HOME"] || join(homedir(), ".cache");
+	return join(root, "opencode");
+}
+function cachePath() {
+	return join(cacheDirectory(), "cdo-ai-sdlc-models.json");
+}
+function cacheKey(scope) {
+	const baseURL = scope.baseURL.trim().replace(/\/+$/, "").replace(/\/v1$/, "");
+	const gateway = createHash("sha256").update(baseURL).digest("hex").slice(0, 16);
+	const credential = createHash("sha256").update(scope.apiKey ?? "").digest("hex").slice(0, 16);
+	return `${scope.environment}:${gateway}:${credential}`;
+}
+async function readEntries() {
+	try {
+		const parsed = JSON.parse(await readFile(cachePath(), "utf8"));
+		if (!parsed.entries || typeof parsed.entries !== "object" || Array.isArray(parsed.entries)) return {};
+		return parsed.entries;
+	} catch {
+		return {};
+	}
+}
+function validModels(value) {
+	return Array.isArray(value) && value.length > 0 && value.every((model) => {
+		if (!model || typeof model !== "object" || Array.isArray(model)) return false;
+		const entry = model;
+		return typeof entry.id === "string" && entry.id.length > 0 && [
+			"contextTokens",
+			"inputTokens",
+			"outputTokens",
+			"inputCostPerToken",
+			"outputCostPerToken",
+			"cacheReadCostPerToken",
+			"cacheWriteCostPerToken"
+		].every((key) => entry[key] === void 0 || typeof entry[key] === "number" && Number.isFinite(entry[key])) && [
+			"supportsTools",
+			"supportsReasoning",
+			"supportsVision",
+			"supportsPdf",
+			"supportsAudio"
+		].every((key) => entry[key] === void 0 || typeof entry[key] === "boolean") && (entry.reasoningEfforts === void 0 || Array.isArray(entry.reasoningEfforts) && entry.reasoningEfforts.every((effort) => typeof effort === "string"));
+	});
+}
+async function readModelCache(scope) {
+	const models = (await readEntries())[cacheKey(scope)]?.models;
+	return validModels(models) ? models.map((model) => ({
+		...model,
+		name: unsanitizeModelId(model.id)
+	})) : void 0;
+}
+async function acquireLock(lockPath) {
+	const deadline = Date.now() + 2e3;
+	while (Date.now() < deadline) try {
+		await mkdir(lockPath);
+		return () => rm(lockPath, {
+			recursive: true,
+			force: true
+		});
+	} catch {
+		try {
+			if (Date.now() - (await stat(lockPath)).mtimeMs > 3e4) {
+				await rm(lockPath, {
+					recursive: true,
+					force: true
+				});
+				continue;
+			}
+		} catch {
+			continue;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 25));
+	}
+}
+const pendingWrites = /* @__PURE__ */ new Map();
+async function writeModelCache(scope, models) {
+	if (!validModels(models)) return;
+	const path = cachePath();
+	const current = (pendingWrites.get(path) ?? Promise.resolve()).catch(() => {}).then(async () => {
+		let release;
+		try {
+			await mkdir(cacheDirectory(), {
+				recursive: true,
+				mode: 448
+			});
+			release = await acquireLock(`${path}.lock`);
+			if (!release) return;
+			const entries = await readEntries();
+			const cachedModels = models.map(({ name: _name, ...model }) => model);
+			entries[cacheKey(scope)] = {
+				savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				models: cachedModels
+			};
+			const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+			await writeFile(temp, JSON.stringify({ entries }), {
+				encoding: "utf8",
+				mode: 384
+			});
+			await rename(temp, path);
+		} catch {} finally {
+			await release?.().catch(() => {});
+		}
+	});
+	pendingWrites.set(path, current);
+	await current;
+	if (pendingWrites.get(path) === current) pendingWrites.delete(path);
+}
+//#endregion
 //#region src/server/auth-hook.ts
 function createAuthHook(flavor) {
 	return {
@@ -10,8 +118,9 @@ function createAuthHook(flavor) {
 		async loader(auth) {
 			const creds = await auth();
 			if (!creds || creds.type !== "api") return {};
+			const url = creds.metadata?.["url"];
 			return {
-				baseURL: creds.metadata?.["url"],
+				baseURL: url ? normalizeProviderURL(url) : void 0,
 				apiKey: creds.key
 			};
 		},
@@ -21,8 +130,9 @@ function createAuthHook(flavor) {
 			prompts: [{
 				type: "text",
 				key: "url",
-				message: `${flavor.displayName} proxy URL`,
-				placeholder: "https://litellm.example.com/v1"
+				message: PLUGIN_COPY.proxyURLLabel(flavor.displayName),
+				placeholder: PLUGIN_COPY.proxyURLPlaceholder,
+				validate: (value) => value.trim() ? void 0 : PLUGIN_COPY.proxyURLRequired
 			}]
 		}]
 	};
@@ -30,13 +140,8 @@ function createAuthHook(flavor) {
 //#endregion
 //#region src/server/constants.ts
 const PROVIDER_NPM = "@ai-sdk/openai-compatible";
-const FETCH_TIMEOUT_MS = 8e3;
-const CACHE_TTL_MS = 6048e5;
 //#endregion
 //#region src/server/credentials.ts
-function normalizeRoot(url) {
-	return url.trim().replace(/\/+$/, "").replace(/\/v1$/, "");
-}
 function authFilePath() {
 	const dataHome = process.env["XDG_DATA_HOME"] || join(homedir(), ".local", "share");
 	return join(dataHome, "opencode", "auth.json");
@@ -66,109 +171,129 @@ async function resolveCredentials(flavor, options) {
 	const baseURL = (typeof options.baseURL === "string" ? options.baseURL : void 0) || stored.baseURL;
 	return {
 		apiKey,
-		baseURL: baseURL ? normalizeRoot(baseURL) : void 0
+		baseURL: baseURL ? normalizeProviderURL(baseURL) : void 0
 	};
 }
 //#endregion
 //#region src/server/model-cache.ts
-function cacheDir() {
-	const cacheHome = process.env["XDG_CACHE_HOME"] || join(homedir(), ".cache");
-	return join(cacheHome, "opencode-cdo-ai");
+function scope(root, flavor, apiKey) {
+	return {
+		environment: flavor.environment,
+		baseURL: root,
+		apiKey
+	};
 }
-function cachePath(root) {
-	const key = createHash("sha256").update(root).digest("hex").slice(0, 16);
-	return join(cacheDir(), `models-${key}.json`);
+function toCanonical(models) {
+	return Object.entries(models).map(([id, model]) => ({
+		id,
+		contextTokens: model.limit?.context,
+		outputTokens: model.limit?.output,
+		supportsTools: model.tool_call,
+		supportsReasoning: model.reasoning,
+		supportsVision: model.attachment,
+		reasoningEfforts: model.variants ? Object.keys(model.variants) : void 0,
+		inputCostPerToken: model.cost?.input == null ? void 0 : model.cost.input / 1e6,
+		outputCostPerToken: model.cost?.output == null ? void 0 : model.cost.output / 1e6,
+		cacheReadCostPerToken: model.cost?.cache_read == null ? void 0 : model.cost.cache_read / 1e6,
+		cacheWriteCostPerToken: model.cost?.cache_write == null ? void 0 : model.cost.cache_write / 1e6
+	}));
 }
-async function readCache(root) {
-	try {
-		const parsed = JSON.parse(await readFile(cachePath(root), "utf8"));
-		if (!parsed.models || Object.keys(parsed.models).length === 0) return void 0;
-		return {
-			models: parsed.models,
-			fresh: Date.now() - parsed.savedAt < CACHE_TTL_MS
-		};
-	} catch {
-		return;
-	}
+function fromCanonical(models) {
+	return Object.fromEntries(models.map((model) => {
+		const cost = model.inputCostPerToken != null || model.outputCostPerToken != null ? {
+			input: (model.inputCostPerToken ?? 0) * 1e6,
+			output: (model.outputCostPerToken ?? 0) * 1e6,
+			...model.cacheReadCostPerToken == null ? {} : { cache_read: model.cacheReadCostPerToken * 1e6 },
+			...model.cacheWriteCostPerToken == null ? {} : { cache_write: model.cacheWriteCostPerToken * 1e6 }
+		} : void 0;
+		const input = ["text"];
+		if (model.supportsVision) input.push("image");
+		if (model.supportsPdf) input.push("pdf");
+		if (model.supportsAudio) input.push("audio");
+		return [model.id, {
+			name: unsanitizeModelId(model.id),
+			limit: {
+				context: model.contextTokens ?? 128e3,
+				output: model.outputTokens ?? 16384
+			},
+			tool_call: model.supportsTools ?? true,
+			reasoning: model.supportsReasoning ?? false,
+			attachment: model.supportsVision ?? false,
+			...model.reasoningEfforts?.length ? { variants: Object.fromEntries(model.reasoningEfforts.map((effort) => [effort, { reasoningEffort: effort }])) } : {},
+			...cost ? { cost } : {},
+			modalities: {
+				input,
+				output: ["text"]
+			}
+		}];
+	}));
 }
-async function writeCache(root, models) {
+async function readCache(root, flavor, apiKey) {
+	const models = await readModelCache(scope(root, flavor, apiKey));
+	return models?.length ? fromCanonical(models) : void 0;
+}
+async function writeCache(root, flavor, apiKey, models) {
+	await writeModelCache(scope(root, flavor, apiKey), toCanonical(models));
+}
+async function resolveCachedModels(root, flavor, apiKey, discover) {
 	try {
-		await mkdir(cacheDir(), { recursive: true });
-		const payload = {
-			savedAt: Date.now(),
-			models
-		};
-		await writeFile(cachePath(root), JSON.stringify(payload), "utf8");
+		const models = await discover();
+		if (Object.keys(models).length > 0) {
+			await writeCache(root, flavor, apiKey, models);
+			return models;
+		}
 	} catch {}
+	return readCache(root, flavor, apiKey);
 }
 //#endregion
 //#region src/server/models-client.ts
-async function getJSON(url, apiKey) {
-	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-	try {
-		const res = await fetch(url, {
-			headers: { Authorization: `Bearer ${apiKey}` },
-			signal: controller.signal
-		});
-		if (!res.ok) throw new Error(`HTTP ${res.status}`);
-		return await res.json();
-	} finally {
-		clearTimeout(timer);
-	}
-}
-function parseIds(payload) {
-	const data = payload?.data;
-	if (!Array.isArray(data)) return [];
-	return data.map((m) => m.id).filter((id) => typeof id === "string" && id.length > 0);
-}
-function parseInfo(payload) {
-	const data = payload?.data;
-	if (!Array.isArray(data)) return {};
-	const out = {};
-	for (const row of data) if (typeof row.model_name === "string" && row.model_info) out[row.model_name] = row.model_info;
-	return out;
-}
-function toEntry(id, info) {
+function toModelEntry(model) {
+	const cost = model.inputCostPerToken != null || model.outputCostPerToken != null ? {
+		input: (model.inputCostPerToken ?? 0) * 1e6,
+		output: (model.outputCostPerToken ?? 0) * 1e6,
+		...model.cacheReadCostPerToken == null ? {} : { cache_read: model.cacheReadCostPerToken * 1e6 },
+		...model.cacheWriteCostPerToken == null ? {} : { cache_write: model.cacheWriteCostPerToken * 1e6 }
+	} : void 0;
+	const input = ["text"];
+	if (model.supportsVision) input.push("image");
+	if (model.supportsPdf) input.push("pdf");
+	if (model.supportsAudio) input.push("audio");
 	return {
-		name: id,
+		name: model.name ?? model.id,
 		limit: {
-			context: info?.max_input_tokens ?? info?.max_tokens ?? 128e3,
-			output: info?.max_output_tokens ?? 16384
+			context: model.contextTokens ?? 128e3,
+			output: model.outputTokens ?? 16384
 		},
-		tool_call: info?.supports_function_calling ?? true,
-		reasoning: info?.supports_reasoning ?? false,
-		attachment: info?.supports_vision ?? false
+		tool_call: model.supportsTools ?? true,
+		reasoning: model.supportsReasoning ?? false,
+		attachment: model.supportsVision ?? false,
+		...model.reasoningEfforts?.length ? { variants: Object.fromEntries(model.reasoningEfforts.map((effort) => [effort, { reasoningEffort: effort }])) } : {},
+		...cost ? { cost } : {},
+		modalities: {
+			input,
+			output: ["text"]
+		}
 	};
 }
-async function discoverModels(root, apiKey) {
-	const [idsResult, infoResult] = await Promise.allSettled([getJSON(`${root}/v1/models`, apiKey), getJSON(`${root}/v1/model/info`, apiKey)]);
-	if (idsResult.status !== "fulfilled") throw idsResult.reason;
-	const ids = parseIds(idsResult.value);
-	const info = infoResult.status === "fulfilled" ? parseInfo(infoResult.value) : {};
-	const models = {};
-	for (const id of ids) {
-		const meta = info[id];
-		if (meta?.mode && meta.mode !== "chat") continue;
-		models[id] = toEntry(id, meta);
-	}
-	return models;
+async function discoverModelsForV1(root, apiKey, logger) {
+	const result = await discoverModels({
+		baseURL: root,
+		apiKey,
+		logger
+	});
+	if (!result.ok) throw new Error(result.error.message);
+	return Object.fromEntries(result.value.map((model) => [model.id, toModelEntry(model)]));
 }
 //#endregion
 //#region src/server/config-hook.ts
-async function resolveModels(root, apiKey) {
-	const cached = await readCache(root);
-	if (cached?.fresh) return cached.models;
-	try {
-		const discovered = await discoverModels(root, apiKey);
-		if (Object.keys(discovered).length === 0) return cached?.models;
-		await writeCache(root, discovered);
-		return discovered;
-	} catch {
-		return cached?.models;
-	}
+async function resolveModels(root, apiKey, flavor, logger) {
+	return resolveCachedModels(root, flavor, apiKey, async () => {
+		const models = await discoverModelsForV1(root, apiKey, logger);
+		if (Object.keys(models).length === 0) throw new Error("No usable chat models");
+		return models;
+	});
 }
-function createConfigHook(flavor) {
+function createConfigHook(flavor, logger) {
 	return async function configHook(config) {
 		try {
 			config.provider ??= {};
@@ -179,9 +304,9 @@ function createConfigHook(flavor) {
 			provider.models ??= { ["_"]: {} };
 			const { baseURL, apiKey } = await resolveCredentials(flavor, provider.options);
 			if (!baseURL || !apiKey) return;
-			provider.options.baseURL ??= `${baseURL}/v1`;
+			provider.options.baseURL = baseURL;
 			provider.options.apiKey ??= apiKey;
-			const models = await resolveModels(baseURL, apiKey);
+			const models = await resolveModels(baseURL, apiKey, flavor, logger);
 			if (!models || Object.keys(models).length === 0) return;
 			provider.models = models;
 		} catch {}
@@ -190,10 +315,20 @@ function createConfigHook(flavor) {
 //#endregion
 //#region src/server/plugin.ts
 function createServer(flavor) {
-	return async (_ctx) => ({
-		config: createConfigHook(flavor),
-		auth: createAuthHook(flavor)
-	});
+	return async (ctx) => {
+		const logger = async (event) => {
+			await ctx.client.app.log({ body: {
+				service: "ai-sdlc-opencode",
+				level: event.level,
+				message: event.message,
+				extra: { ...event }
+			} });
+		};
+		return {
+			config: createConfigHook(flavor, logger),
+			auth: createAuthHook(flavor)
+		};
+	};
 }
 //#endregion
 //#region src/entry-dev.ts

package/dist/tui.d.ts

@@ -0,0 +1,7 @@
+//#region src/tui-dev.d.ts
+declare const _default: {
+  id: string;
+  tui: import("@opencode-ai/plugin/tui").TuiPlugin;
+};
+//#endregion
+export { _default as default };

package/dist/tui.js

@@ -1,76 +1,127 @@
-import { t as DEV } from "./flavor-CMZWvD--.js";
+import { a as resolveUsagePercent, c as fetchJSON, d as PLUGIN_UI, l as isRecord, n as BUDGET_SOURCE_LABELS, r as monthlyUsageMetrics, s as emitGatewayLog, t as DEV, u as PLUGIN_COPY } from "./flavor-8QVaVpzl.js";
 import { For, createSignal } from "solid-js";
 import { createTextAttributes } from "@opentui/core";
-import { jsx, jsxs } from "@opentui/solid/jsx-runtime";
-//#region src/usage-client.ts
-function deriveApiUrl(litellmBaseURL) {
-	return litellmBaseURL.replace(/^(https?:\/\/)litellm(\.[^/]+).*/, "$1api$2");
+import { Fragment, jsx, jsxs } from "@opentui/solid/jsx-runtime";
+//#region ../common/dist/usage.js
+function deriveUsageURL(baseURL) {
+	return `${baseURL.replace(/^(https?:\/\/)litellm(\.[^/]+).*/, "$1api$2").replace(/\/+$/, "").replace(/\/v1$/, "")}/v1/usage`;
 }
-async function fetchUsage(baseURL, apiKey, timeoutMs) {
-	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), timeoutMs);
-	try {
-		const res = await fetch(`${deriveApiUrl(baseURL)}/v1/usage`, {
-			headers: { Authorization: `Bearer ${apiKey}` },
-			signal: controller.signal
-		});
-		if (!res.ok) return `HTTP ${res.status}`;
-		return await res.json();
-	} catch (e) {
-		return e instanceof Error ? e.message : "network error";
-	} finally {
-		clearTimeout(timer);
+async function fetchUsage$1(options) {
+	const startedAt = Date.now();
+	const endpoint = deriveUsageURL(options.baseURL);
+	const response = await fetchJSON(endpoint, options, "usage.fetch");
+	let result;
+	if (!response.ok) result = response;
+	else if (!isRecord(response.value)) result = {
+		ok: false,
+		error: {
+			code: "invalid-response",
+			message: "Invalid /v1/usage response"
+		}
+	};
+	else {
+		const { spend, budget, type } = response.value;
+		result = typeof spend !== "number" || !Number.isFinite(spend) || !(budget === null || typeof budget === "number" && Number.isFinite(budget)) || typeof type !== "string" || ![
+			"key",
+			"user",
+			"team-member",
+			"team-member-default",
+			"none"
+		].includes(type) ? {
+			ok: false,
+			error: {
+				code: "invalid-response",
+				message: "Invalid /v1/usage response fields"
+			}
+		} : {
+			ok: true,
+			value: {
+				spend,
+				budget,
+				type
+			}
+		};
 	}
+	emitGatewayLog(options, {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		operation: "usage.fetch",
+		phase: "operation",
+		endpoint,
+		ok: result.ok,
+		durationMs: Date.now() - startedAt,
+		...!result.ok ? { errorCode: result.error.code } : {}
+	});
+	return result;
 }
-function round1(n) {
-	return Math.round(n * 10) / 10;
+//#endregion
+//#region src/usage-client.ts
+async function fetchUsage(baseURL, apiKey, timeoutMs, logger) {
+	const result = await fetchUsage$1({
+		baseURL,
+		apiKey,
+		timeoutMs,
+		logger
+	});
+	return result.ok ? result.value : result.error.message;
 }
 function toEntry(providerName, result) {
 	if (typeof result === "string") return {
 		providerName,
-		error: result
+		error: result,
+		connected: true
 	};
-	const percent = result.budget != null ? round1(result.spend / result.budget * 100) : null;
+	const { percent, thresholdPercent } = resolveUsagePercent(result.spend, result.budget);
 	return {
 		providerName,
 		...result,
-		percent
+		...monthlyUsageMetrics(result.spend),
+		percent,
+		thresholdPercent,
+		connected: true
 	};
 }
 //#endregion
 //#region src/components.tsx
-const BAR_WIDTH = 20;
-function bar(percent) {
-	if (percent == null) return "∞";
-	const filled = Math.min(Math.round(percent / 100 * BAR_WIDTH), BAR_WIDTH);
-	return "█".repeat(filled) + "░".repeat(BAR_WIDTH - filled);
-}
 function barColor(entry, theme) {
-	const pct = entry.percent ?? 0;
-	return pct >= 100 ? theme.error : pct >= 80 ? theme.warning : theme.success;
+	const pct = entry.thresholdPercent ?? 0;
+	return pct >= PLUGIN_UI.exceededPercent ? theme.error : pct >= PLUGIN_UI.warningPercent ? theme.warning : theme.success;
 }
 function valuesLine(entry) {
-	if (entry.error != null) return ` ${entry.error}`;
-	return entry.budget != null ? ` $${entry.spend.toFixed(2)} / $${entry.budget.toFixed(2)} (${entry.percent?.toFixed(1)}%)` : ` $${entry.spend.toFixed(2)} / ∞`;
+	if (entry.error != null) return PLUGIN_COPY.usageUnavailable(entry.error);
+	return PLUGIN_COPY.usageValues(entry.spend ?? 0, entry.budget ?? null);
 }
 function UsagePanel(props) {
-	return /* @__PURE__ */ jsx(For, {
+	return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(For, {
 		each: props.entries,
-		children: (entry) => /* @__PURE__ */ jsxs("box", { children: [
-			/* @__PURE__ */ jsx("text", {
-				attributes: createTextAttributes({ bold: true }),
-				children: entry.providerName
-			}),
-			/* @__PURE__ */ jsx("text", {
-				fg: entry.error != null ? props.theme.error : void 0,
-				children: valuesLine(entry)
-			}),
-			/* @__PURE__ */ jsx("text", {
-				fg: barColor(entry, props.theme),
-				children: entry.error == null ? ` ${bar(entry.percent ?? null)}` : ""
-			})
-		] })
-	});
+		children: (entry) => /* @__PURE__ */ jsxs("box", {
+			flexDirection: "column",
+			children: [
+				/* @__PURE__ */ jsx("text", {
+					attributes: createTextAttributes({ bold: true }),
+					children: entry.providerName
+				}),
+				/* @__PURE__ */ jsx("text", {
+					fg: !entry.connected || entry.error != null ? props.theme.error : void 0,
+					children: !entry.connected ? PLUGIN_COPY.notConnected(props.connectCommand) : valuesLine(entry)
+				}),
+				entry.connected && entry.error == null && entry.percent != null && /* @__PURE__ */ jsx("text", {
+					fg: barColor(entry, props.theme),
+					children: `${PLUGIN_COPY.progressBar(entry.percent, PLUGIN_UI.barWidth)} ${PLUGIN_COPY.formatPercent(entry.percent)}`
+				}),
+				entry.connected && entry.error == null && entry.type != null && /* @__PURE__ */ jsx("text", {
+					fg: props.theme.textMuted,
+					children: BUDGET_SOURCE_LABELS[entry.type]
+				}),
+				entry.connected && entry.error == null && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("text", {
+					fg: props.theme.textMuted,
+					children: PLUGIN_COPY.perWorkday(entry.workdayAverage == null ? "—" : PLUGIN_COPY.formatMoney(entry.workdayAverage))
+				}), /* @__PURE__ */ jsx("text", {
+					fg: props.theme.textMuted,
+					children: PLUGIN_COPY.workdaysRemaining(entry.remainingWorkdays ?? 0)
+				})] })
+			]
+		})
+	}) });
 }
 //#endregion
 //#region src/tui.tsx
@@ -79,16 +130,37 @@ const TIMEOUT_MS = 5e3;
 function createTui(flavor) {
 	return (api) => {
 		const [entries, setEntries] = createSignal([]);
+		const logger = async (event) => {
+			await api.client.app.log({
+				service: "ai-sdlc-opencode",
+				level: event.level,
+				message: event.message,
+				extra: { ...event }
+			});
+		};
 		async function refresh() {
 			try {
 				const providers = api.state.provider.filter((p) => flavor.matchesPanelProvider(p.id));
+				if (providers.length === 0) {
+					setEntries([{
+						providerName: flavor.displayName,
+						connected: false
+					}]);
+					return;
+				}
 				const results = await Promise.all(providers.map(async (p) => {
 					const options = p.options ?? {};
 					const baseURL = options["baseURL"];
 					const apiKey = p.key ?? options["apiKey"];
-					if (!apiKey) return toEntry(p.name, "no API key configured");
-					if (!baseURL) return toEntry(p.name, "no base URL configured");
-					return toEntry(p.name, await fetchUsage(baseURL, apiKey, TIMEOUT_MS));
+					if (!apiKey) return {
+						...toEntry(p.name, ""),
+						connected: false
+					};
+					if (!baseURL) return {
+						...toEntry(p.name, ""),
+						connected: false
+					};
+					return toEntry(p.name, await fetchUsage(baseURL, apiKey, TIMEOUT_MS, logger));
 				}));
 				setEntries(results);
 			} catch {}
@@ -101,7 +173,8 @@ function createTui(flavor) {
 			slots: { sidebar_content(ctx) {
 				return /* @__PURE__ */ jsx(UsagePanel, {
 					entries: entries(),
-					theme: ctx.theme.current
+					theme: ctx.theme.current,
+					connectCommand: PLUGIN_COPY.connectCommand(flavor.providerID)
 				});
 			} }
 		});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telefonica/ai-sdlc-opencode-plugin-v1-dev",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "OpenCode 1.x plugin (dev environment): CDO.AI provider registration, model discovery, and budget panel",
   "type": "module",
   "exports": {

package/dist/flavor-CMZWvD--.js

@@ -1,13 +0,0 @@
-//#region src/flavor.ts
-const DEV = {
-	environment: "dev",
-	serverPluginID: "ai-sdlc-opencode-cdo-ai-dev-plugin",
-	tuiPluginID: "ai-sdlc-opencode-cdo-ai-dev-plugin.tui",
-	providerID: "cdo-ai-dev",
-	displayName: "CDO.AI (dev)",
-	connectLabel: "CDO.AI (dev) API key",
-	apiKeyEnvVars: ["CDO_AI_DEV_API_KEY"],
-	matchesPanelProvider: (id) => id === "cdo-ai-dev"
-};
-//#endregion
-export { DEV as t };

package/dist/index-T2VhrgAK.d.ts

@@ -1,9 +0,0 @@
-import * as _opencode_ai_plugin0 from "@opencode-ai/plugin";
-
-//#region src/entry-dev.d.ts
-declare const _default: {
-  id: string;
-  server: _opencode_ai_plugin0.Plugin;
-};
-//#endregion
-export { _default as default };

package/dist/tui-BTWQZHT5.d.ts

@@ -1,9 +0,0 @@
-import * as _opencode_ai_plugin_tui0 from "@opencode-ai/plugin/tui";
-
-//#region src/tui-dev.d.ts
-declare const _default: {
-  id: string;
-  tui: _opencode_ai_plugin_tui0.TuiPlugin;
-};
-//#endregion
-export { _default as default };