omp-llm-role 1.0.0 → 1.2.0

package/src/agent-file.ts

@@ -16,8 +16,8 @@
  *     the effort and prices it; a second pin would silently disagree with it.
  */
 
-import { existsSync, mkdirSync, statSync, unlinkSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
 import { writeConfigAtomic } from "./config-edit.ts";
 import { agentDir } from "./state.ts";
 
@@ -99,9 +99,6 @@ export function writeAgentFile(path: string, text: string, force: boolean): Agen
   if (existsSync(path) && !force) {
     return { ok: false, error: `${path} already exists — pass --force to overwrite` };
   }
-  // A first agent may be the first thing in the dir (~/.omp/agent/agents is not
-  // created by omp until something writes there).
-  mkdirSync(dirname(path), { recursive: true });
   const mtimeBefore = existsSync(path) ? statSync(path).mtimeMs : 0;
   const result = writeConfigAtomic(path, text, mtimeBefore);
   if (result === "conflict") return { ok: false, error: `${path} changed while writing — refusing to overwrite` };

package/src/architect-provenance.ts

@@ -0,0 +1,16 @@
+/**
+ * Provenance for the vendored agent-creation architect prompt.
+ *
+ * `src/prompts/agent-creation-architect.md` is copied verbatim from omp's
+ * `/agents` hub prompt. omp's extension loader does not resolve the SDK subpath
+ * that prompt lives under, so the plugin ships its own copy; this constant is the
+ * omp version it was copied from. Bump it and the prompt's header comment
+ * together when re-syncing after an omp upgrade (see
+ * `docs/dev/agent-authoring.md`), so a drift is a visible test failure rather
+ * than a silent one.
+ *
+ * Kept in its own module (not `agent-architect.ts`) because that module imports
+ * `@oh-my-pi/pi-coding-agent`, which only resolves inside omp — a test cannot
+ * import it.
+ */
+export const ARCHITECT_PROMPT_VERSION = "18.4.8";

package/src/availability.ts

@@ -1,5 +1,5 @@
 /**
- * Availability model (SPEC §5): what the user's OpenRouter key can actually run.
+ * Availability model: what the user's OpenRouter key can actually run.
  *
  * OpenRouter exposes no per-key model allowlist — availability is derived from
  * key tier + budget (tier gate), then every candidate must resolve to a concrete
@@ -76,7 +76,7 @@ export async function fetchKeyMeta(token: string, fetchImpl: typeof fetch = fetc
   };
 }
 
-/** Tier gate (SPEC §5.2): billed budget wins, else free daily quota, else run aborts. */
+/** Tier gate: billed budget wins, else free daily quota, else run aborts. */
 export function tierGate(meta: KeyMeta): Tier {
   const billedUsable = !meta.isFreeTier && meta.limitRemaining > 0 && meta.creditsRemaining > 0;
   if (billedUsable) return "billed";
@@ -88,12 +88,30 @@ export type ProbeVerdict = "ok" | "blocked" | "unknown";
 
 const OPENROUTER_COMPLETIONS_URL = "https://openrouter.ai/api/v1/chat/completions";
 
+/** POST a one-token completion to OpenRouter with the shared request skeleton
+ * (Bearer auth, JSON body, 20s timeout). Shared by `probeModel` and
+ * `fetchAllowedProviders`. */
+function completionRequest(token: string, body: unknown, fetchImpl: typeof fetch): Promise<Response> {
+  return fetchImpl(OPENROUTER_COMPLETIONS_URL, {
+    method: "POST",
+    headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(20_000),
+  });
+}
+
+/** Extract `error.message` from a parsed OpenRouter error body, or "" when the
+ * body does not carry one. */
+function errorMessage(body: unknown): string {
+  return isRecord(body) && isRecord(body.error) && typeof body.error.message === "string" ? body.error.message : "";
+}
+
 /** 404 body OpenRouter returns when the account's allowed-providers privacy
  * whitelist (or a data-policy toggle) leaves a model without a runnable endpoint. */
 const BLOCKED_RE = /no allowed providers/i;
 
 /**
- * One-token completion probe (SPEC §5 addendum): the only reliable signal for
+ * One-token completion probe: the only reliable signal for
  * account-level provider restrictions — neither `/api/v1/key` nor the catalog
  * endpoints expose the allowed-providers whitelist, but a real request's 404
  * body names it. Only the narrow no-allowed-providers verdict blocks a
@@ -102,22 +120,165 @@ const BLOCKED_RE = /no allowed providers/i;
  */
 export async function probeModel(token: string, catalogId: string, fetchImpl: typeof fetch = fetch): Promise<ProbeVerdict> {
   try {
-    const res = await fetchImpl(OPENROUTER_COMPLETIONS_URL, {
-      method: "POST",
-      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
-      body: JSON.stringify({ model: catalogId, messages: [{ role: "user", content: "ok" }], max_tokens: 1 }),
-      signal: AbortSignal.timeout(20_000),
-    });
+    const res = await completionRequest(token, { model: catalogId, messages: [{ role: "user", content: "ok" }], max_tokens: 1 }, fetchImpl);
     if (res.ok) return "ok";
     if (res.status !== 404) return "unknown";
     const body: unknown = await res.json().catch(() => null);
-    const message = isRecord(body) && isRecord(body.error) && typeof body.error.message === "string" ? body.error.message : "";
+    const message = errorMessage(body);
     return BLOCKED_RE.test(message) ? "blocked" : "unknown";
   } catch {
     return "unknown";
   }
 }
 
+/** 404 body OpenRouter returns when the account's allowed-providers privacy
+ * whitelist leaves the canary provider without a runnable endpoint; the message
+ * names the whitelist after "permits only:". */
+const ALLOWED_PROVIDERS_RE = /permits only:\s*([^.]*)\./i;
+
+/**
+ * Harvest the account's allowed-providers privacy whitelist. The whitelist is
+ * invisible to `/api/v1/key` and the catalog endpoints; the only place it
+ * appears is the 404 body of a request that fails because of it. A canary
+ * completion on a valid model with a nonexistent provider slug (`provider.only`)
+ * 404s and names the whitelist. Returns null when the body does not name a
+ * whitelist (no whitelist set), the response is not a 404, or the request
+ * throws — never throws.
+ */
+export async function fetchAllowedProviders(token: string, modelId: string, fetchImpl: typeof fetch = fetch): Promise<Set<string> | null> {
+  try {
+    const res = await completionRequest(
+      token,
+      {
+        model: modelId,
+        messages: [{ role: "user", content: "ok" }],
+        max_tokens: 1,
+        provider: { only: ["__omp-llm-role-canary__"] },
+      },
+      fetchImpl,
+    );
+    if (res.status !== 404) return null;
+    const body: unknown = await res.json().catch(() => null);
+    const message = errorMessage(body);
+    const match = ALLOWED_PROVIDERS_RE.exec(message);
+    if (!match) return null;
+    const providers = match[1]
+      .split(",")
+      .map((s) => s.trim())
+      .filter((s) => s.length > 0);
+    return providers.length > 0 ? new Set(providers) : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Whether a route's `providerSlug` is permitted by the account's
+ * allowed-providers whitelist. Whitelist entries are bare lab names
+ * (`coreweave`) while route slugs are tiered (`coreweave/fp8`), so a match is
+ * the entry itself or an `entry/` prefix.
+ */
+export function providerAllowed(allowed: ReadonlySet<string>, slug: string): boolean {
+  for (const entry of allowed) {
+    if (slug === entry || slug.startsWith(`${entry}/`)) return true;
+  }
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// Keyed-catalog availability
+// ---------------------------------------------------------------------------
+
+/**
+ * What the user's OpenRouter key can actually run, derived from the account
+ * setting "Filter the model catalog for API keys": with it on, a
+ * Bearer-authenticated `GET /api/v1/models` returns only the models the key may
+ * use (provider restrictions and guardrails applied), while the unauthenticated
+ * request still sees the public catalog. Set membership is the only signal —
+ * the response carries no per-model access flag.
+ *
+ * `allowed`/`blocked` are populated only when `reason === "active"`; every other
+ * reason leaves them empty so a consumer that forgets to check `active` degrades
+ * to "unknown" rather than over-claiming "usable".
+ */
+export type KeyAvailability = {
+  /** keyed catalog ⊊ public catalog → the OpenRouter filter is on. */
+  active: boolean;
+  reason: "active" | "no-filter" | "unavailable";
+  /** ranking ids present in the keyed catalog (empty unless `active`). */
+  allowed: ReadonlySet<string>;
+  /** ranking ids present in the public catalog but not the keyed one (empty unless `active`). */
+  blocked: ReadonlySet<string>;
+  publicCount: number;
+  keyedCount: number;
+  /** ISO 8601. */
+  fetchedAt: string;
+};
+
+const OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+
+/** Tolerant `data[].id` reader; null when the payload is not the expected shape. */
+function modelIdsFromPayload(v: unknown): string[] | null {
+  if (!isRecord(v) || !Array.isArray(v.data)) return null;
+  const ids: string[] = [];
+  for (const row of v.data) {
+    if (isRecord(row) && typeof row.id === "string") ids.push(row.id);
+  }
+  return ids;
+}
+
+/**
+ * Pure derivation of the availability mark from the two catalog id lists. Both
+ * are normalized with `rankingIdOf` — the same identity space `resolveVariant`
+ * and the engine's `Model.id` use — so `~org/x-latest`, `org/x:free` and
+ * `org/x` collapse to one ranking id and aliases never produce a false "blocked".
+ *
+ * `active` requires a non-empty keyed list that is a **proper subset** of the
+ * public one; equality (the setting is off) or a keyed id absent from public is
+ * `no-filter`; an empty list is `unavailable`.
+ */
+export function computeKeyAvailability(publicIds: string[], keyedIds: string[], fetchedAt = new Date().toISOString()): KeyAvailability {
+  const publicSet = new Set(publicIds.map(rankingIdOf));
+  const keyedSet = new Set(keyedIds.map(rankingIdOf));
+  const base = { publicCount: publicSet.size, keyedCount: keyedSet.size, fetchedAt };
+  if (publicSet.size === 0 || keyedSet.size === 0) {
+    return { active: false, reason: "unavailable", allowed: new Set(), blocked: new Set(), ...base };
+  }
+  const subset = keyedSet.size < publicSet.size && [...keyedSet].every((id) => publicSet.has(id));
+  if (!subset) return { active: false, reason: "no-filter", allowed: new Set(), blocked: new Set(), ...base };
+  return {
+    active: true,
+    reason: "active",
+    allowed: keyedSet,
+    blocked: new Set([...publicSet].filter((id) => !keyedSet.has(id))),
+    ...base,
+  };
+}
+
+/**
+ * Fetch the public and key-authenticated catalogs in parallel and derive the
+ * availability mark. **Never throws**: any transport, status, or shape failure
+ * yields `reason: "unavailable"` with empty sets, so both callers (the explorer
+ * and the updater) keep their current behavior on a transient OpenRouter outage.
+ */
+export async function fetchKeyAvailability(token: string, fetchImpl: typeof fetch = fetch): Promise<KeyAvailability> {
+  const fetchedAt = new Date().toISOString();
+  const unavailable: KeyAvailability = { active: false, reason: "unavailable", allowed: new Set(), blocked: new Set(), publicCount: 0, keyedCount: 0, fetchedAt };
+  try {
+    const [publicRes, keyedRes] = await Promise.all([
+      fetchImpl(OPENROUTER_MODELS_URL),
+      fetchImpl(OPENROUTER_MODELS_URL, { headers: { authorization: `Bearer ${token}` } }),
+    ]);
+    if (!publicRes.ok || !keyedRes.ok) return unavailable;
+    const publicIds = modelIdsFromPayload(await publicRes.json());
+    const keyedIds = modelIdsFromPayload(await keyedRes.json());
+    if (publicIds === null || keyedIds === null) return unavailable;
+    return computeKeyAvailability(publicIds, keyedIds, fetchedAt);
+  } catch {
+    return unavailable;
+  }
+}
+
 /** Keep openrouter catalog rows the tier may run: never `:batch`; `:free` only on free tier. */
 export function filterCatalog(catalog: CatalogEntry[], tier: Tier): CatalogEntry[] {
   if (tier === "none") return [];
@@ -134,12 +295,27 @@ export function rankingIdOf(catalogId: string): string {
   return noFree.endsWith("-latest") ? noFree.slice(0, -"-latest".length) : noFree;
 }
 
-/** Identity of a configured selector for hysteresis/chain keys: drop `:level`, `openrouter/`, then rankingIdOf. */
-export function currentRankingId(selector: string): string {
+/** Split a selector's trailing thinking suffix (`provider/model[:level]`):
+ * `base` without the suffix, `level` the suffix or null. The single home for
+ * the `:level` strip shared by `currentRankingId`, `providerPinOfSelector`, and
+ * the extension's selector handling. */
+export function splitThinkingSuffix(selector: string): { base: string; level: string | null } {
   const colon = selector.lastIndexOf(":");
-  const base = colon !== -1 && selector.slice(colon + 1) in THINKING_LEVELS ? selector.slice(0, colon) : selector;
+  if (colon !== -1 && selector.slice(colon + 1) in THINKING_LEVELS) {
+    return { base: selector.slice(0, colon), level: selector.slice(colon + 1) };
+  }
+  return { base: selector, level: null };
+}
+
+/** Identity of a configured selector for hysteresis/chain keys: drop `:level`,
+ * `openrouter/`, and a trailing `@<slug>` provider pin, then rankingIdOf. A
+ * tiered pin (`@deepinfra/fp8`) is dropped whole — everything from the last `@`. */
+export function currentRankingId(selector: string): string {
+  const { base } = splitThinkingSuffix(selector);
   const unprefixed = base.startsWith("openrouter/") ? base.slice("openrouter/".length) : base;
-  return rankingIdOf(unprefixed);
+  const at = unprefixed.lastIndexOf("@");
+  const unpinned = at !== -1 ? unprefixed.slice(0, at) : unprefixed;
+  return rankingIdOf(unpinned);
 }
 
 // "Newest dated" = trailing -MMDD or -YYYYMMDD (max numeric wins; ties lexicographic).
@@ -147,7 +323,7 @@ const DATED_RE = /-(\d{4}|\d{8})$/;
 
 /**
  * Map a ranking row id (llm-stats bare id) to a concrete catalog id among
- * tier-eligible candidates (SPEC §5.4). Candidates match when their suffix after
+ * tier-eligible candidates. Candidates match when their suffix after
  * the last `/` equals the ranking id, possibly after stripping `:free` and one
  * `-latest` (org prefixes, including `~`-prefixed, are ignored for matching).
  * Order: exact id -> newest dated -> bare -> `~org/…-latest` alias (last resort —

package/src/benchmark-author.ts

@@ -4,12 +4,13 @@
  * from the fetched content. The extension then dry-runs the declaration (fetch,
  * parse, join, coverage/leader) and asks the user to confirm before it is saved.
  *
- * This module is extension-only: it imports `@oh-my-pi/pi-coding-agent`, which
- * only resolves inside omp. The tests import the pure validation/execution path
- * in `src/benchmark-sources.ts` instead.
+ * This module is extension-only: it imports `@oh-my-pi/pi-coding-agent`
+ * dynamically, inside the function (the SDK only resolves inside omp; a static
+ * import failure would be fatal to the whole `extension.ts` load). The tests
+ * import the pure validation/execution path in `src/benchmark-sources.ts`
+ * instead.
  */
 
-import { createAgentSession } from "@oh-my-pi/pi-coding-agent";
 import { readFileSync } from "node:fs";
 import { fetchText, parseSourceDeclaration, type SourceDeclaration } from "./benchmark-sources.ts";
 import { extractAssistantText, extractJsonObject } from "./agent-architect.ts";
@@ -47,6 +48,10 @@ export type BenchmarkAuthorOptions = {
  */
 export async function authorBenchmarkSource(opts: BenchmarkAuthorOptions): Promise<SourceDeclaration> {
   const content = (await fetchText(opts.link)).slice(0, MAX_CONTENT);
+  // Dynamic, inside the function: `@oh-my-pi/pi-coding-agent` only resolves
+  // inside omp, and a static import failure would be fatal to the whole
+  // `extension.ts` load (see `agent-architect.ts`).
+  const { createAgentSession } = await import("@oh-my-pi/pi-coding-agent");
   const { session } = await createAgentSession({
     cwd: opts.cwd,
     model: opts.model as never,