super-dsh 0.1.6 → 0.1.10

package/agent-omp-sdk/dist/models.js

@@ -0,0 +1,299 @@
+/**
+ * OMP model catalog for the Dash model selector.
+ *
+ * The browser model selector is a pure RPC round-trip through the apiproxy:
+ * `session.models` reads `ctx.llm.listProviders/listModels/resolveModelInfo`,
+ * so the OMP provider registers an `LlmAdapter` whose catalog is OMP's real
+ * AVAILABLE model set. This module owns the source of that catalog.
+ *
+ * Source: `omp models --json` (first-party CLI, `omp-cli.ts`) — OMP's own
+ * credential-resolved availability verdict. The documented selectability
+ * rule (provider not in `disabledProviders` and keyless or with a
+ * resolvable credential) runs through a 7-level credential precedence that
+ * includes OAuth/login keys stored in agent.db — a state NO config file
+ * reveals, which is why the catalog must come from OMP itself.
+ *
+ * The authoritative RPC `get_available_models` would serve the same set but
+ * exceeds the 1 MiB transport frame limit for this install; the CLI returns
+ * the compact form (~50 models / 5 providers, 15 KB, ~1.7s). The on-disk
+ * `models.db` ∪ `models.yml` pair remains ONLY as the subprocess-failure
+ * fallback (registry-cache noise included) — never the primary.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { ompAvailableModels, ompAvailableModelsSync, ompModelRolesSync } from "./omp-cli.js";
+import { OMP_NATIVE_HOME } from "./knobs.js";
+import { readOmpModelRolesFromConfig } from "./omp-store.js";
+import { ReasoningEffortId } from "@deepseek-ai/dsh-llm";
+const OMP_AGENT_DIR = join(OMP_NATIVE_HOME, "agent");
+/**
+ * Providers named by config.yml `modelRoles` lead the selector: they are the
+ * roles the operator actually wired (the TUI default-model semantics).
+ */
+let cached = null;
+/**
+ * Read the AVAILABLE OMP model catalog, memoized. First call prefers the CLI
+ * (`omp models --json`, synchronous — the boot route list must be known
+ * before `registerAdapter` returns); a CLI failure falls back to the on-disk
+ * registry cache with a stderr note. Later refreshes go through
+ * `refreshOmpModelsCli` (async, per reconcile tick).
+ */
+export function loadOmpModels() {
+    if (cached === null) {
+        const cli = ompAvailableModelsSync();
+        if (cli !== undefined) {
+            cached = cli.map((model) => normalizeModel(model)).filter((model) => model !== null);
+        }
+        else {
+            process.stderr.write("[omp-provider] omp models --json unavailable; falling back to the on-disk model cache\n");
+            cached = mergeModels(loadModelsDb(), loadModelsYml());
+        }
+    }
+    return cached;
+}
+/**
+ * Re-run the CLI catalog and swap the memo on success.
+ * @returns whether the refresh produced a fresh catalog.
+ */
+export async function refreshOmpModelsCli() {
+    const cli = await ompAvailableModels();
+    if (cli === undefined)
+        return false;
+    cached = cli.map((model) => normalizeModel(model)).filter((model) => model !== null);
+    return true;
+}
+/** The distinct provider ids across the catalog, modelRoles roles first. */
+export function ompProviderIds(models = loadOmpModels()) {
+    const seen = new Set();
+    for (const model of models)
+        seen.add(model.provider);
+    const ordered = [];
+    // Providers the operator wired into modelRoles lead the selector (TUI
+    // semantics: the roles actually in use); everything else follows
+    // alphabetically. Roles come from config.yml ON DISK — never a sidecar
+    // warm (sidecar-decoupling); the memo is only a fallback for a sidecar
+    // that is already live.
+    const roles = readOmpModelRolesFromConfig() ?? ompModelRolesSync();
+    for (const selector of Object.values(roles ?? {})) {
+        const slash = selector.indexOf("/");
+        const provider = slash > 0 ? selector.slice(0, slash) : "";
+        if (provider !== "" && seen.has(provider) && !ordered.includes(provider))
+            ordered.push(provider);
+    }
+    for (const provider of [...seen].sort((a, b) => a.localeCompare(b))) {
+        if (!ordered.includes(provider))
+            ordered.push(provider);
+    }
+    return ordered;
+}
+/** Human-readable provider name for `LlmProviderInfo.name`. */
+export function providerDisplayName(provider) {
+    const titles = { zai: "Z.AI", xai: "xAI", openrouter: "OpenRouter" };
+    return titles[provider] ?? (provider.charAt(0).toUpperCase() + provider.slice(1));
+}
+/** Merge the registry cache under the user overlay (later models win per provider+id). */
+function mergeModels(cache, overlay) {
+    if (overlay.length === 0)
+        return cache;
+    const byKey = new Map();
+    for (const model of cache)
+        byKey.set(model.provider + "/" + model.id, model);
+    for (const model of overlay)
+        byKey.set(model.provider + "/" + model.id, model);
+    return [...byKey.values()];
+}
+/**
+ * Read `~/.omp/agent/models.db` (`model_cache.models` JSON column). This is
+ * the on-disk form of the registry `get_available_models` serves. Read-only
+ * and tolerant of a missing/empty file (OMP may not have refreshed it yet).
+ */
+function loadModelsDb() {
+    const out = [];
+    try {
+        const db = new DatabaseSync(join(OMP_AGENT_DIR, "models.db"), { readOnly: true });
+        try {
+            const rows = db.prepare("SELECT models FROM model_cache").all();
+            for (const row of rows) {
+                try {
+                    const models = JSON.parse(row.models);
+                    if (!Array.isArray(models))
+                        continue;
+                    for (const model of models) {
+                        const parsed = normalizeModel(model);
+                        if (parsed !== null)
+                            out.push(parsed);
+                    }
+                }
+                catch {
+                    // one malformed provider row must not sink the whole catalog
+                }
+            }
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        // absent db / schema drift → fall through to the overlay alone
+    }
+    return out;
+}
+/**
+ * Parse `~/.omp/agent/models.yml` — a `providers: <id>: { models: [ ... ] }`
+ * overlay OMP writes. A focused indentation scan is enough for this fixed
+ * shape and avoids pulling `js-yaml` into the provider's dependency surface.
+ * Any parse failure degrades to an empty overlay.
+ */
+function loadModelsYml() {
+    const out = [];
+    let text;
+    try {
+        text = readFileSync(join(OMP_AGENT_DIR, "models.yml"), "utf8");
+    }
+    catch {
+        return out;
+    }
+    let provider = "";
+    let inModels = false;
+    let model = null;
+    const push = () => {
+        if (model !== null) {
+            const parsed = normalizeModel({ ...model, provider });
+            if (parsed !== null)
+                out.push(parsed);
+            model = null;
+        }
+    };
+    for (const raw of text.split("\n")) {
+        const line = raw.replace(/\r$/, "");
+        if (line.trim() === "" || line.trimStart().startsWith("#"))
+            continue;
+        const indent = line.length - line.trimStart().length;
+        const trimmed = line.trim();
+        if (indent === 0) {
+            if (trimmed === "providers:") {
+                provider = "";
+                inModels = false;
+                model = null;
+            }
+            else {
+                provider = "";
+                inModels = false;
+                model = null;
+            }
+            continue;
+        }
+        if (indent === 2 && trimmed.endsWith(":")) {
+            push();
+            provider = trimmed.slice(0, -1).trim();
+            inModels = false;
+            continue;
+        }
+        if (indent === 4 && trimmed === "models:") {
+            inModels = true;
+            continue;
+        }
+        if (inModels && indent >= 6 && trimmed.startsWith("- ")) {
+            push();
+            model = {};
+            const entry = trimmed.slice(2).trim();
+            const colon = entry.indexOf(":");
+            if (colon > 0)
+                model[entry.slice(0, colon).trim()] = entry.slice(colon + 1).trim();
+            continue;
+        }
+        if (inModels && model !== null && indent >= 8) {
+            const colon = trimmed.indexOf(":");
+            if (colon > 0) {
+                const key = trimmed.slice(0, colon).trim();
+                model[key] = trimmed.slice(colon + 1).trim();
+            }
+            continue;
+        }
+        // Any other shape is outside the models list we care about.
+    }
+    push();
+    return out;
+}
+/** Coerce one raw model record into an {@link OmpModel}, or null when unusable. */
+function normalizeModel(raw) {
+    if (raw === null || typeof raw !== "object")
+        return null;
+    const record = raw;
+    const id = typeof record.id === "string" ? record.id : "";
+    const provider = typeof record.provider === "string" ? record.provider : "";
+    const name = typeof record.name === "string" && record.name !== "" ? record.name : id;
+    if (id === "" || provider === "" || name === "")
+        return null;
+    const thinking = normalizeThinking(record.thinking);
+    return {
+        id,
+        provider,
+        name,
+        ...(typeof record.api === "string" ? { api: record.api } : {}),
+        ...(typeof record.baseUrl === "string" ? { baseUrl: record.baseUrl } : {}),
+        ...(typeof record.reasoning === "boolean" ? { reasoning: record.reasoning } : {}),
+        ...(Array.isArray(record.input) ? { input: record.input.filter((m) => typeof m === "string") } : {}),
+        ...(typeof record.contextWindow === "number" ? { contextWindow: record.contextWindow } : {}),
+        ...(typeof record.maxTokens === "number" ? { maxTokens: record.maxTokens } : {}),
+        ...(thinking === undefined ? {} : { thinking }),
+    };
+}
+/** Map OMP's declared input modalities to the harness vocabulary. */
+function inputModalities(model) {
+    if (model.input === undefined)
+        return undefined;
+    const modalities = model.input.filter((m) => m === "text" || m === "image");
+    return modalities.length === 0 ? undefined : modalities;
+}
+/** Extract OMP's `thinking` sub-object, checking each field at the boundary. */
+function normalizeThinking(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const t = raw;
+    return {
+        ...(typeof t.mode === "string" ? { mode: t.mode } : {}),
+        ...(Array.isArray(t.efforts) ? { efforts: t.efforts.filter((e) => typeof e === "string") } : {}),
+        ...(typeof t.defaultLevel === "string" ? { defaultLevel: t.defaultLevel } : {}),
+    };
+}
+/** Map OMP `thinking.efforts` into the adapter reasoning-effort vocabulary. */
+function reasoningInfo(model) {
+    const efforts = model.thinking?.efforts ?? [];
+    if (efforts.length === 0)
+        return undefined;
+    const ids = new Set();
+    const mapped = efforts
+        .filter((effort) => effort !== "" && !ids.has(effort) && (ids.add(effort), true))
+        .map((effort) => ({ id: ReasoningEffortId(effort), name: effort }));
+    if (mapped.length === 0)
+        return undefined;
+    const defaultEffort = model.thinking?.defaultLevel;
+    return {
+        efforts: mapped,
+        ...(defaultEffort !== undefined && ids.has(defaultEffort) ? { defaultEffort: ReasoningEffortId(defaultEffort) } : {}),
+    };
+}
+/** One catalog row: {@link LlmModelInfo} for `listModels`. */
+export function toModelInfo(model) {
+    return {
+        provider: model.provider,
+        id: model.id,
+        name: model.name,
+        ...(inputModalities(model) === undefined ? {} : { inputModalities: inputModalities(model) }),
+    };
+}
+/** One exact-model resolution: {@link LlmResolvedModelInfo} for `resolveModel`. */
+export function toResolvedModelInfo(model) {
+    const info = toModelInfo(model);
+    const contextWindow = typeof model.contextWindow === "number" && model.contextWindow > 0 ? model.contextWindow : undefined;
+    const defaultMaxTokens = typeof model.maxTokens === "number" && model.maxTokens > 0 ? model.maxTokens : undefined;
+    const reasoning = reasoningInfo(model);
+    return {
+        ...info,
+        ...(contextWindow === undefined ? {} : { context: { contextWindow } }),
+        ...(defaultMaxTokens === undefined ? {} : { defaultMaxTokens }),
+        ...(reasoning === undefined ? {} : { reasoning }),
+    };
+}

package/agent-omp-sdk/dist/omp-cli.d.ts

@@ -0,0 +1,67 @@
+/**
+ * OMP CLI subprocess data plane — the model catalog and the `modelRoles` map
+ * are read from (and written through) the operator's own `omp` binary, the
+ * first-party entries the bridge uses instead of parsing OMP's files or
+ * hitting frame-limited RPC:
+ *
+ * - `omp models --json`     → the credential-resolved AVAILABLE model catalog
+ *   (documented selectability rule: provider not in `disabledProviders` and
+ *   keyless or with a resolvable credential — 7-level precedence, including
+ *   OAuth/login keys stored in agent.db that no config file reveals).
+ * - `omp config get modelRoles --json` → the role→"provider/model[:effort]"
+ *   map, including the persisted `default` selector (TUI semantics: the
+ *   default model IS config state, surviving sessions).
+ * - `omp config set modelRoles --json <obj>` → whole-object roundtrip write
+ *   (dotted keys are rejected; the entire modelRoles object is the unit).
+ *
+ * All calls run with cwd = `OMP_HOME` (omp writes its own state db next to
+ * the agent dir) and inherit the daemon environment. The binary is resolved
+ * per call ({@link resolveOmpExecutable}), so `$OMP_EXECUTABLE` and PATH
+ * changes take effect without a reload.
+ *
+ * Fail-soft: a missing, broken or unresponsive `omp` yields `undefined`
+ * (reads) or `false` (write) — the provider never fails to boot because the
+ * CLI is down.
+ *
+ * @module agent-omp/omp-cli
+ */
+/** One raw model record as OMP's catalog describes it. */
+export interface OmpCliModel {
+    provider: string;
+    id: string;
+    [key: string]: unknown;
+}
+/** role → "provider/model[:effort]" selectors, from the live config. */
+export interface OmpModelRoles {
+    [role: string]: string;
+}
+/**
+ * Synchronous `omp models --json` — the boot-time variant (the adapter's
+ * provider route list must be known before `registerAdapter` returns).
+ * Blocks up to the timeout; prefer the async variant everywhere else.
+ */
+export declare function ompAvailableModelsSync(): OmpCliModel[] | undefined;
+/**
+ * `omp models --json` — the AVAILABLE model catalog (credential-resolved,
+ * `disabledProviders`-aware). `undefined` when the CLI fails; callers fall
+ * back to the on-disk sources.
+ */
+export declare function ompAvailableModels(): Promise<OmpCliModel[] | undefined>;
+/**
+ * Synchronous `omp config get modelRoles --json` — boot-time variant of
+ * {@link ompModelRoles}.
+ */
+export declare function ompModelRolesSync(): OmpModelRoles | undefined;
+/**
+ * `omp config get modelRoles --json` — the current modelRoles object, read
+ * fresh on every call (the OMP TUI may have rewritten config.yml). `undefined`
+ * when unset or the CLI fails.
+ */
+export declare function ompModelRoles(): Promise<OmpModelRoles | undefined>;
+/**
+ * `omp config set modelRoles --json <obj>` — the TUI-grade default-model
+ * write: OMP persists `modelRoles.default` itself, so every new session
+ * (TUI or Web) inherits the selection. Whole-object roundtrip: dotted keys
+ * are rejected by the CLI. `false` on any failure (fail-soft).
+ */
+export declare function ompSetModelRoles(roles: OmpModelRoles): Promise<boolean>;

package/agent-omp-sdk/dist/omp-cli.js

@@ -0,0 +1,164 @@
+/**
+ * OMP CLI subprocess data plane — the model catalog and the `modelRoles` map
+ * are read from (and written through) the operator's own `omp` binary, the
+ * first-party entries the bridge uses instead of parsing OMP's files or
+ * hitting frame-limited RPC:
+ *
+ * - `omp models --json`     → the credential-resolved AVAILABLE model catalog
+ *   (documented selectability rule: provider not in `disabledProviders` and
+ *   keyless or with a resolvable credential — 7-level precedence, including
+ *   OAuth/login keys stored in agent.db that no config file reveals).
+ * - `omp config get modelRoles --json` → the role→"provider/model[:effort]"
+ *   map, including the persisted `default` selector (TUI semantics: the
+ *   default model IS config state, surviving sessions).
+ * - `omp config set modelRoles --json <obj>` → whole-object roundtrip write
+ *   (dotted keys are rejected; the entire modelRoles object is the unit).
+ *
+ * All calls run with cwd = `OMP_HOME` (omp writes its own state db next to
+ * the agent dir) and inherit the daemon environment. The binary is resolved
+ * per call ({@link resolveOmpExecutable}), so `$OMP_EXECUTABLE` and PATH
+ * changes take effect without a reload.
+ *
+ * Fail-soft: a missing, broken or unresponsive `omp` yields `undefined`
+ * (reads) or `false` (write) — the provider never fails to boot because the
+ * CLI is down.
+ *
+ * @module agent-omp/omp-cli
+ */
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+import { OMP_HOME } from "./knobs.js";
+import { resolveOmpExecutable } from "./omp-executable.js";
+const execFileAsync = promisify(execFile);
+const TIMEOUT_MS = 15_000;
+const MAX_BUFFER = 64 * 1024 * 1024;
+// ---------------------------------------------------------------------------
+// Subprocess plumbing (fail-soft: any failure → undefined/false)
+// ---------------------------------------------------------------------------
+/** One `omp <args>` invocation parsed as JSON; undefined on any failure. */
+async function ompCliJson(args) {
+    try {
+        const { stdout } = await execFileAsync(resolveOmpExecutable(), args, {
+            cwd: OMP_HOME,
+            timeout: TIMEOUT_MS,
+            maxBuffer: MAX_BUFFER,
+        });
+        return JSON.parse(stdout);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Synchronous variant of {@link ompCliJson} — the boot-time path. */
+function ompCliJsonSync(args) {
+    try {
+        const stdout = execFileSync(resolveOmpExecutable(), args, {
+            cwd: OMP_HOME,
+            timeout: TIMEOUT_MS,
+            encoding: "utf8",
+            maxBuffer: MAX_BUFFER,
+        });
+        return JSON.parse(stdout);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Validate an `omp models --json` payload; undefined when empty or invalid. */
+function parseModels(json) {
+    if (json === null || typeof json !== "object")
+        return undefined;
+    const models = json.models;
+    if (!Array.isArray(models))
+        return undefined;
+    const out = [];
+    for (const model of models) {
+        if (model !== null && typeof model === "object" && typeof model.provider === "string") {
+            out.push(model);
+        }
+    }
+    return out.length > 0 ? out : undefined;
+}
+/**
+ * Validate a `modelRoles` payload; undefined when unset, empty or invalid.
+ *
+ * `omp config get <key> --json` prints `{key, value, type, description}`, but
+ * the bare value map appears in older builds, so both shapes are accepted. A
+ * wrapped payload for a different key is rejected rather than misread as a
+ * role map.
+ */
+function parseModelRoles(json) {
+    if (json === null || typeof json !== "object" || Array.isArray(json))
+        return undefined;
+    const record = json;
+    let value = record;
+    if ("key" in record || "value" in record) {
+        if (typeof record.key === "string" && record.key !== "modelRoles")
+            return undefined;
+        value = record.value;
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const out = {};
+    for (const [role, selector] of Object.entries(value)) {
+        if (typeof selector === "string" && selector !== "")
+            out[role] = selector;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+// ---------------------------------------------------------------------------
+// Model catalog
+// ---------------------------------------------------------------------------
+/**
+ * Synchronous `omp models --json` — the boot-time variant (the adapter's
+ * provider route list must be known before `registerAdapter` returns).
+ * Blocks up to the timeout; prefer the async variant everywhere else.
+ */
+export function ompAvailableModelsSync() {
+    return parseModels(ompCliJsonSync(["models", "--json"]));
+}
+/**
+ * `omp models --json` — the AVAILABLE model catalog (credential-resolved,
+ * `disabledProviders`-aware). `undefined` when the CLI fails; callers fall
+ * back to the on-disk sources.
+ */
+export async function ompAvailableModels() {
+    return parseModels(await ompCliJson(["models", "--json"]));
+}
+// ---------------------------------------------------------------------------
+// modelRoles
+// ---------------------------------------------------------------------------
+/**
+ * Synchronous `omp config get modelRoles --json` — boot-time variant of
+ * {@link ompModelRoles}.
+ */
+export function ompModelRolesSync() {
+    return parseModelRoles(ompCliJsonSync(["config", "get", "modelRoles", "--json"]));
+}
+/**
+ * `omp config get modelRoles --json` — the current modelRoles object, read
+ * fresh on every call (the OMP TUI may have rewritten config.yml). `undefined`
+ * when unset or the CLI fails.
+ */
+export async function ompModelRoles() {
+    return parseModelRoles(await ompCliJson(["config", "get", "modelRoles", "--json"]));
+}
+/**
+ * `omp config set modelRoles --json <obj>` — the TUI-grade default-model
+ * write: OMP persists `modelRoles.default` itself, so every new session
+ * (TUI or Web) inherits the selection. Whole-object roundtrip: dotted keys
+ * are rejected by the CLI. `false` on any failure (fail-soft).
+ */
+export async function ompSetModelRoles(roles) {
+    try {
+        await execFileAsync(resolveOmpExecutable(), ["config", "set", "modelRoles", "--json", JSON.stringify(roles)], {
+            cwd: OMP_HOME,
+            timeout: TIMEOUT_MS,
+            maxBuffer: MAX_BUFFER,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/agent-omp-sdk/dist/omp-disk-discovery.d.ts

@@ -0,0 +1,27 @@
+/** One file-based slash command, shape-compatible with the old sidecar frame. */
+export interface OmpDiskSlashCommand {
+    name: string;
+    description: string;
+    content: string;
+    source: string;
+    filePath: string;
+}
+/** One discovered skill, shape-compatible with the old sidecar frame. */
+export interface OmpDiskSkill {
+    name: string;
+    description: string;
+    filePath: string;
+    baseDir: string;
+    source: string;
+}
+/**
+ * Read every file-based slash command from the discovery roots.
+ * Deterministic output: deduped by name (scan order, first wins), then sorted.
+ */
+export declare function readSlashCommands(cwd?: string): OmpDiskSlashCommand[];
+/**
+ * Read every discovered skill from the discovery roots: the Agent Skills
+ * standard `<root>/<name>/SKILL.md` layout, plus a lenient flat `<root>/*.md`.
+ * Deterministic output: deduped by name (scan order, first wins), then sorted.
+ */
+export declare function readSkills(cwd?: string): OmpDiskSkill[];