@xiaoso/dsh-tool-plus 0.1.5 → 0.1.7-beta.0

package/lib/{deterministic-id-D-yIV_eI.mjs → deterministic-id-CUEIMSqR.mjs}

@@ -1,6 +1,6 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/deterministic-id.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/deterministic-id.ts
 /**
 * Format the leading 128 bits of `seed`'s SHA-256 digest as a v4-shape UUID
 * (8-4-4-4-12 hex groups).

package/lib/devin-BMTdx_hx.mjs

@@ -0,0 +1,316 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { C as warn } from "./src-BwW51vA5.mjs";
+import { n as discoveryFetch } from "./utils-DeWqNWV8.mjs";
+import { n as THINKING_EFFORTS } from "./effort-BdtQMN-_.mjs";
+import { t as collapseVariants } from "./collapse-DOR8sOGf.mjs";
+import { r as devinDiscoveryMetadata } from "./devin-ExGIghmx.mjs";
+import { o as toBinary, t as create } from "./protobuf-aab1UGVn.mjs";
+import { d as GetCliModelConfigsRequestSchema, f as GetCliModelConfigsResponseSchema, t as decodeDevinUnaryMessage, v as MetadataSchema } from "./devin-proto-Br8fdyNl.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/discovery/devin.ts
+const DEVIN_GET_CLI_MODEL_CONFIGS_PATH = "/exa.api_server_pb.ApiServerService/GetCliModelConfigs";
+const DEFAULT_CONTEXT_WINDOW = 2e5;
+const DEFAULT_MAX_TOKENS = 64e3;
+/**
+* `DISPLAY_OPTION_INTERNAL_DEFAULT` — display slot for configs the server only
+* reveals to clients that opt in, used for internal default/eval models.
+*
+* The vendored descriptor predates display options 6-8, so the generated
+* `DisplayOption` enum stops at `QUICK_REVIEW` (4). Wire display options are
+* plain int32, so the extra values decode and re-encode faithfully; casting
+* here keeps the generated code untouched.
+*/
+const DEVIN_DISPLAY_OPTION_INTERNAL_DEFAULT = 6;
+/**
+* Display slots the native client advertises. `UNSPECIFIED` (0) is implicit —
+* it is the default for configs with no display opinion. Asking for the
+* internal slots is what makes the server return its full catalog; the
+* internal ones are filtered client-side, exactly as native does.
+*/
+const DEVIN_SUPPORTED_MODEL_DISPLAYS = [
+	3,
+	4,
+	DEVIN_DISPLAY_OPTION_INTERNAL_DEFAULT,
+	7,
+	8
+];
+/** Display slots requested but never surfaced: quick-review and internal defaults. */
+const DEVIN_INTERNAL_MODEL_DISPLAYS = /* @__PURE__ */ new Set([4, DEVIN_DISPLAY_OPTION_INTERNAL_DEFAULT]);
+/** Best-effort match for labels whose wording implies a thinking / reasoning-effort variant. */
+const REASONING_LABEL_PATTERN = /think|thinking|minimal|high|medium|low|xhigh|max|reasoning/i;
+const NO_REASONING_LABEL_PATTERN = /\bno thinking\b/i;
+/**
+* Server model features are authoritative for reasoning support; the label
+* heuristic only covers configs that ship no `modelFeatures` at all.
+*/
+function supportsDevinThinking(config) {
+	const features = config.modelInfo?.modelFeatures;
+	if (features !== void 0) return features.supportsThinking;
+	if (NO_REASONING_LABEL_PATTERN.test(config.label)) return false;
+	return REASONING_LABEL_PATTERN.test(config.label);
+}
+/** Cost `modelDimensions` labels, normalized, mapped onto catalog token rates. */
+const DEVIN_COST_LABEL_INPUT = "input";
+const DEVIN_COST_LABEL_CACHE_READ = "cached input";
+const DEVIN_COST_LABEL_OUTPUT = "output";
+/** Leading token count of a cost denominator ("1M tokens", "1K tokens"). */
+const DEVIN_COST_DENOMINATOR_PATTERN = /(\d+(?:\.\d+)?)\s*([kmb])?/i;
+const DEVIN_COST_DENOMINATOR_SCALE = {
+	k: 1e3,
+	m: 1e6,
+	b: 1e9
+};
+/**
+* Tokens covered by one cost dimension. Native prices per `1M tokens`; the
+* scale is parsed instead of assumed so a future `1K` denominator still
+* normalizes to catalog per-million rates.
+*/
+function devinCostDenominatorTokens(denominator) {
+	const match = DEVIN_COST_DENOMINATOR_PATTERN.exec(denominator);
+	if (match === null) return 1e6;
+	const suffix = match[2];
+	const scale = suffix === void 0 ? 1 : DEVIN_COST_DENOMINATOR_SCALE[suffix.toLowerCase()] ?? 1;
+	const tokens = Number(match[1]) * scale;
+	return tokens > 0 ? tokens : 1e6;
+}
+/**
+* Per-million-token rates from the config's cost dimensions. `COST_FUZZY` marks
+* an estimated rate, not a different unit, so both kinds are read. `cacheWrite`
+* has no Cascade dimension — Devin bills cache writes at the input rate — and
+* stays 0.
+*/
+function devinModelCost(config) {
+	const cost = {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0
+	};
+	for (const dimension of config.modelDimensions) {
+		if (dimension.kind !== 1 && dimension.kind !== 2) continue;
+		const perMillion = Math.round(dimension.value * 1e6 / devinCostDenominatorTokens(dimension.denominator) * 1e6) / 1e6;
+		switch (dimension.label.trim().toLowerCase()) {
+			case DEVIN_COST_LABEL_INPUT:
+				cost.input = perMillion;
+				break;
+			case DEVIN_COST_LABEL_CACHE_READ:
+				cost.cacheRead = perMillion;
+				break;
+			case DEVIN_COST_LABEL_OUTPUT: cost.output = perMillion;
+		}
+	}
+	return cost;
+}
+/** `modelFamilyMetadata` entry keys that carry the family's effort axis. */
+const DEVIN_FAMILY_EFFORT_KEYS = {
+	effort: true,
+	"reasoning effort": true
+};
+/** `modelFamilyMetadata` entry key for the service-tier axis; order 1 is the fast lane. */
+const DEVIN_FAMILY_FAST_KEY = "fast mode";
+const DEVIN_FAMILY_FAST_ORDER = 1;
+/** Boolean reasoning axis used by Claude families whose effort name alone is ambiguous. */
+const DEVIN_FAMILY_THINKING_KEY = "thinking";
+const DEVIN_FAMILY_THINKING_ORDER = 1;
+/** Context-window axis; order 1 selects the separate 1M-context lane. */
+const DEVIN_FAMILY_CONTEXT_1M_KEY = "1m context";
+const DEVIN_FAMILY_CONTEXT_1M_ORDER = 1;
+/** Effort-entry display names, normalized to a space-free token, mapped onto pi efforts. */
+const DEVIN_FAMILY_EFFORT_BY_NAME = {
+	none: "off",
+	nothinking: "off",
+	minimal: "minimal",
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh",
+	max: "max"
+};
+/**
+* File `config` under its server-declared family lane. Configs with no family
+* metadata, or whose family carries no effort axis, are left alone and stay
+* standalone specs.
+*/
+function collectDevinFamilyLane(lanes, config, uid) {
+	const metadata = config.modelFamilyMetadata;
+	if (metadata === void 0) return;
+	const label = metadata.modelFamilyLabel.trim();
+	if (!label) return;
+	let effort;
+	let thinking;
+	let fast = false;
+	let oneMillionContext = false;
+	for (const entry of metadata.entries) {
+		const value = entry.value;
+		if (value === void 0) continue;
+		const key = entry.key.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+		if (key === DEVIN_FAMILY_FAST_KEY) {
+			fast = value.order === DEVIN_FAMILY_FAST_ORDER;
+			continue;
+		}
+		if (key === DEVIN_FAMILY_THINKING_KEY) {
+			thinking = value.order === DEVIN_FAMILY_THINKING_ORDER;
+			continue;
+		}
+		if (key === DEVIN_FAMILY_CONTEXT_1M_KEY) {
+			oneMillionContext = value.order === DEVIN_FAMILY_CONTEXT_1M_ORDER;
+			continue;
+		}
+		if (DEVIN_FAMILY_EFFORT_KEYS[key]) effort = DEVIN_FAMILY_EFFORT_BY_NAME[value.name.toLowerCase().replace(/[^a-z0-9]+/g, "")];
+	}
+	if (thinking === false) effort = "off";
+	const baseId = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+	if (!baseId) return;
+	const laneId = `${baseId}${oneMillionContext ? "-1m" : ""}${fast ? "-fast" : ""}`;
+	let lane = lanes.get(laneId);
+	if (lane === void 0) {
+		lane = {
+			id: laneId,
+			name: `${label}${oneMillionContext ? " 1M" : ""}${fast ? " Fast" : ""}`,
+			members: [],
+			routing: {}
+		};
+		lanes.set(laneId, lane);
+	}
+	lane.members.push(uid);
+	if (lane.defaultMember === void 0 && (config.isDefaultModelInFamily || metadata.isDefaultModelInFamily)) lane.defaultMember = uid;
+	if (effort !== void 0 && lane.routing[effort] === void 0) lane.routing[effort] = uid;
+}
+/**
+* Collapse families for the lanes that declare an effort ladder. The server
+* default wire uid is hoisted to the front of `members` so collapsing adopts it
+* as the logical model's default `requestModelId`.
+*
+* A lane with no non-`off` effort route has nothing to route: its members stay
+* standalone rather than collapsing into a family with an empty effort list.
+*/
+function devinDynamicFamilies(lanes) {
+	const families = [];
+	for (const lane of lanes) {
+		const efforts = THINKING_EFFORTS.filter((effort) => lane.routing[effort] !== void 0);
+		if (efforts.length === 0) continue;
+		const defaultMember = lane.defaultMember;
+		const members = defaultMember === void 0 ? lane.members : [defaultMember, ...lane.members.filter((uid) => uid !== defaultMember)];
+		const defaultLevel = defaultMember === void 0 ? void 0 : efforts.find((effort) => lane.routing[effort] === defaultMember);
+		families.push({
+			id: lane.id,
+			name: lane.name,
+			members,
+			routing: lane.routing,
+			...defaultMember !== void 0 ? { defaultMember } : {},
+			thinking: {
+				mode: "effort",
+				efforts,
+				...defaultLevel !== void 0 ? { defaultLevel } : {},
+				...lane.routing.off === void 0 ? { requiresEffort: true } : {}
+			}
+		});
+	}
+	return families;
+}
+/**
+* Fetches Devin models through the `GetCliModelConfigs` unary Connect RPC and
+* normalizes them into canonical model entries.
+*
+* Returns `null` on request/decode failures.
+* Returns `[]` only when the endpoint responds successfully with no usable models.
+*/
+async function fetchDevinModels(options) {
+	const timeoutMs = options.timeoutMs ?? 5e3;
+	const requestUrl = `${(options.baseUrl ?? "https://server.codeium.com").replace(/\/+$/, "")}${DEVIN_GET_CLI_MODEL_CONFIGS_PATH}`;
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	const signal = options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+	try {
+		const request = create(GetCliModelConfigsRequestSchema, { metadata: create(MetadataSchema, {
+			...devinDiscoveryMetadata(options.apiKey),
+			supportedModelDisplays: [...DEVIN_SUPPORTED_MODEL_DISPLAYS]
+		}) });
+		const body = toBinary(GetCliModelConfigsRequestSchema, request);
+		const response = await discoveryFetch(options.fetch)(requestUrl, {
+			method: "POST",
+			headers: {
+				"content-type": "application/proto",
+				"connect-protocol-version": "1",
+				accept: "*/*"
+			},
+			body,
+			signal
+		});
+		if (!response.ok) return null;
+		const decoded = decodeDevinUnaryMessage(GetCliModelConfigsResponseSchema, new Uint8Array(await response.arrayBuffer()));
+		if (!decoded) return null;
+		const models = normalizeDevinModels(decoded.clientModelConfigs, options.baseUrl);
+		if (models.length === 0) {
+			warn("Devin returned an empty native model catalog; the pinned CLI identity may be stale", { metadata: devinDiscoveryMetadata(void 0) });
+			return null;
+		}
+		return models;
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* Wire uids whose configs advertise `supports_images` but whose backend
+* silently drops the `ChatMessagePrompt.images` field. Verified live
+* (2026-08-14, native CLI identity): SWE-1.6 and SWE-1.6 Fast answer as if no
+* image was attached, while SWE-1.7, SWE-1.7 Lightning, and every proxied
+* frontier model (Claude/Gemini/GPT/Kimi) read the same field correctly.
+* Declaring text-only lets clients use their image fallback path instead of
+* silently losing attachments ([#6072](https://github.com/can1357/oh-my-pi/issues/6072)).
+* Remove entries if Devin ever wires SWE-1.6 vision up.
+*/
+const DEVIN_IMAGE_BLIND_UIDS = /* @__PURE__ */ new Set(["swe-1-6", "swe-1-6-fast"]);
+/** One config as a raw (pre-collapse) spec keyed on its wire uid. */
+function devinModelSpec(config, uid, baseUrl, isRouter) {
+	const features = config.modelInfo?.modelFeatures;
+	const input = (features !== void 0 ? features.supportsImages : config.supportsImages) && !DEVIN_IMAGE_BLIND_UIDS.has(uid) ? ["text", "image"] : ["text"];
+	const compat = {};
+	if (isRouter) compat.modelRouter = true;
+	if (features?.supportsParallelToolCalls === true) compat.supportsParallelToolCalls = true;
+	const maxOutputTokens = config.modelInfo?.maxOutputTokens ?? 0;
+	const spec = {
+		id: uid,
+		name: config.label.trim() || uid,
+		api: "devin-agent",
+		provider: "devin",
+		baseUrl,
+		reasoning: supportsDevinThinking(config),
+		input,
+		supportsTools: features !== void 0 ? features.supportsToolCalls : true,
+		cost: devinModelCost(config),
+		contextWindow: config.maxTokens > 0 ? config.maxTokens : DEFAULT_CONTEXT_WINDOW,
+		maxTokens: maxOutputTokens > 0 ? maxOutputTokens : DEFAULT_MAX_TOKENS,
+		...Object.keys(compat).length > 0 ? { compat } : {}
+	};
+	const description = config.description?.trim();
+	if (description) spec.description = description;
+	if (config.isNew) spec.isNew = true;
+	if (config.isBeta) spec.isBeta = true;
+	if (config.isRecommended) spec.isRecommended = true;
+	return spec;
+}
+function normalizeDevinModels(configs, baseUrlOverride) {
+	const baseUrl = baseUrlOverride ?? "https://server.codeium.com";
+	const specs = [];
+	const seen = /* @__PURE__ */ new Set();
+	const lanes = /* @__PURE__ */ new Map();
+	for (const config of configs) {
+		if (config.disabled) continue;
+		const displayOption = config.modelInfo?.displayOption ?? 0;
+		if (DEVIN_INTERNAL_MODEL_DISPLAYS.has(displayOption)) continue;
+		const uid = config.modelUid.trim();
+		if (!uid || seen.has(uid)) continue;
+		seen.add(uid);
+		const isRouter = displayOption === 3 || config.modelInfo?.isModelRouter === true;
+		specs.push(devinModelSpec(config, uid, baseUrl, isRouter));
+		if (!isRouter) collectDevinFamilyLane(lanes, config, uid);
+	}
+	const families = devinDynamicFamilies(lanes.values());
+	const dynamic = families.length > 0 ? collapseVariants(specs, { table: { families } }) : specs;
+	return collapseVariants(dynamic).sort((a, b) => a.id.localeCompare(b.id));
+}
+//#endregion
+export { fetchDevinModels };