@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/model/subagentModelWord.js

@@ -0,0 +1,261 @@
+import { CC_TIER_ALIASES, TIER_ORDER } from './tierVocabulary.js';
+import { liveModelRowsOf } from '../liveModelCatalog.js';
+import { quoteUntrustedForSentence } from '../displayUntrusted.js';
+import { msg, renderMessage } from '../i18n/translate.js';
+const STARTED_BY_THIS_PROCESS = 'started-by-this-process';
+function ownData(v, key) {
+    if (v === null || typeof v !== 'object')
+        return undefined;
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        return d !== undefined && 'value' in d ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const nonEmpty = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+function listOf(v) {
+    try {
+        if (!Array.isArray(v))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const n = ownData(v, 'length');
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+        return undefined;
+    const out = [];
+    for (let i = 0; i < n; i += 1)
+        out.push(ownData(v, String(i)));
+    return out;
+}
+function catalogFrom(rows) {
+    const names = [];
+    const idToName = new Map();
+    for (const r of rows) {
+        if (!names.includes(r.name))
+            names.push(r.name);
+        if (r.id !== undefined && !idToName.has(r.id))
+            idToName.set(r.id, r.name);
+    }
+    return { names, nameSet: new Set(names), idToName };
+}
+function localOf(input) {
+    const local = ownData(input, 'local');
+    if (local === null || typeof local !== 'object')
+        return undefined;
+    return ownData(local, 'engine') === STARTED_BY_THIS_PROCESS ? local : undefined;
+}
+function catalogOf(input, local) {
+    const live = ownData(input, 'liveCatalog');
+    if (live !== undefined && live !== null) {
+        const rows = typeof live === 'object' ? liveModelRowsOf(live) : null;
+        return rows === null ? undefined : catalogFrom(rows.map((r) => ({ name: r.name, id: r.id })));
+    }
+    if (local === undefined)
+        return undefined;
+    const pool = listOf(ownData(local, 'pool'));
+    if (pool === undefined)
+        return undefined;
+    const rows = [];
+    for (const e of pool) {
+        const name = nonEmpty(ownData(e, 'name'));
+        if (name === undefined)
+            continue;
+        const id = nonEmpty(ownData(e, 'id'));
+        rows.push(id === undefined ? { name } : { name, id });
+    }
+    return catalogFrom(rows);
+}
+function ownSlot(v, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        if (d === undefined)
+            return { kind: 'absent' };
+        return 'value' in d ? { kind: 'value', value: d.value } : { kind: 'unreadable' };
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+}
+function tiersOf(local) {
+    if (local === undefined)
+        return undefined;
+    const slot = ownSlot(local, 'tiers');
+    if (slot.kind !== 'value')
+        return undefined;
+    const raw = slot.value;
+    if (raw === undefined || raw === null)
+        return new Map();
+    if (typeof raw !== 'object')
+        return undefined;
+    try {
+        if (Array.isArray(raw))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const out = new Map();
+    let keys;
+    try {
+        keys = Object.keys(raw);
+    }
+    catch {
+        return undefined;
+    }
+    for (const k of keys) {
+        const b = ownSlot(raw, k);
+        if (b.kind !== 'value' || typeof b.value !== 'string')
+            return undefined;
+        if (b.value.length > 0)
+            out.set(k, b.value);
+    }
+    return out;
+}
+const BUILTIN_VOCAB = [...TIER_ORDER, ...Object.keys(CC_TIER_ALIASES), 'best'];
+function builtinKindOf(w) {
+    if (TIER_ORDER.includes(w))
+        return 'tier';
+    if (Object.hasOwn(CC_TIER_ALIASES, w))
+        return 'cc-alias';
+    return w === 'best' ? 'best' : undefined;
+}
+class BrokenBinding {
+}
+function landingOf(word, kind, tiers, cat) {
+    const ownKey = (k) => cat.nameSet.has(k);
+    const bound = (t) => {
+        const b = tiers.get(t);
+        if (b === undefined)
+            return undefined;
+        if (!cat.nameSet.has(b))
+            throw new BrokenBinding();
+        return b;
+    };
+    const landing = (t, self) => {
+        const b = bound(t);
+        if (b === undefined)
+            return undefined;
+        return { name: b, via: [...(t !== self && !ownKey(t) ? [t] : []), b] };
+    };
+    const resolveTier = (name, self = name) => {
+        const direct = landing(name, self);
+        if (direct !== undefined)
+            return direct;
+        const at = TIER_ORDER.indexOf(name);
+        if (at === -1)
+            return undefined;
+        for (let i = at + 1; i < TIER_ORDER.length; i++) {
+            const next = landing(TIER_ORDER[i], self);
+            if (next !== undefined)
+                return { name: next.name, via: [...(name !== self && !ownKey(name) ? [name] : []), ...next.via] };
+        }
+        return undefined;
+    };
+    if (tiers.has(word) || kind === 'tier')
+        return resolveTier(word);
+    if (kind === 'cc-alias')
+        return resolveTier(CC_TIER_ALIASES[word], word);
+    for (const name of TIER_ORDER) {
+        const r = landing(name, 'best');
+        if (r !== undefined)
+            return r;
+    }
+    return undefined;
+}
+const tierLabelOf = (word, kind) => (kind === 'cc-alias' ? CC_TIER_ALIASES[word] ?? word : word);
+function freezeReading(r) {
+    if (r.landing !== undefined) {
+        Object.freeze(r.landing.via);
+        Object.freeze(r.landing);
+    }
+    return Object.freeze(r);
+}
+function resolveIn(input) {
+    const rawWord = ownData(input, 'word');
+    const word = typeof rawWord === 'string' ? rawWord.trim() : '';
+    if (word === '' || word.toLowerCase() === 'inherit')
+        return freezeReading({ kind: 'inherit' });
+    const local = localOf(input);
+    const cat = catalogOf(input, local);
+    const tiers = tiersOf(local);
+    const customTierKeys = tiers === undefined ? [] : [...tiers.keys()];
+    const tierClass = (w, kind) => {
+        const label = tierLabelOf(w, kind);
+        if (tiers === undefined || cat === undefined)
+            return { kind, model: w, label };
+        if (tiers.size === 0)
+            return { kind: 'unbound', problem: 'tiers-inert', label };
+        let l;
+        try {
+            l = landingOf(w, kind, tiers, cat);
+        }
+        catch (e) {
+            if (e instanceof BrokenBinding)
+                return { kind: 'unbound', problem: 'binding-not-in-catalog', label };
+            throw e;
+        }
+        if (l === undefined)
+            return { kind: 'unbound', problem: 'chain-unbound', label };
+        return { kind, model: w, landing: { name: l.name, via: l.via, source: 'local-config' }, label: `${l.name} (${label})` };
+    };
+    const asCatalog = (name) => ({ kind: 'catalog', model: name, label: name });
+    const classify = (k) => {
+        if (cat?.nameSet.has(k))
+            return asCatalog(k);
+        const b = builtinKindOf(k);
+        return tierClass(k, b ?? 'tier');
+    };
+    if (cat?.nameSet.has(word))
+        return freezeReading(asCatalog(word));
+    const exact = builtinKindOf(word);
+    if (exact !== undefined)
+        return freezeReading(tierClass(word, exact));
+    if (tiers?.has(word))
+        return freezeReading(tierClass(word, 'tier'));
+    const lower = word.toLowerCase();
+    const space = new Set([...(cat?.names ?? []), ...BUILTIN_VOCAB, ...customTierKeys]);
+    const ciMatches = [...space].filter((k) => k.toLowerCase() === lower);
+    if (builtinKindOf(lower) !== undefined) {
+        return freezeReading(ciMatches.length === 1 ? classify(ciMatches[0]) : { kind: 'ambiguous' });
+    }
+    const byId = cat?.idToName.get(word);
+    if (byId !== undefined)
+        return freezeReading({ kind: 'model-id', model: byId, label: byId });
+    if (ciMatches.length === 1)
+        return freezeReading(classify(ciMatches[0]));
+    if (ciMatches.length > 1)
+        return freezeReading({ kind: 'ambiguous' });
+    return freezeReading({ kind: cat === undefined ? 'catalog-unknown' : 'passthrough', model: word, label: word });
+}
+export function resolveSubagentModelWord(input) {
+    try {
+        return resolveIn(input);
+    }
+    catch {
+        const w = ownData(input, 'word');
+        const word = typeof w === 'string' ? w.trim() : '';
+        return freezeReading(word === '' ? { kind: 'inherit' } : { kind: 'catalog-unknown', model: word, label: word });
+    }
+}
+export function subagentModelWordProblemLine(word, reading, lang) {
+    const ref = problemRefOf(word, reading);
+    return ref === undefined ? undefined : renderMessage(ref, lang);
+}
+function problemRefOf(word, reading) {
+    const kind = ownData(reading, 'kind');
+    if (kind !== 'unbound' && kind !== 'ambiguous')
+        return undefined;
+    const quoted = quoteUntrustedForSentence(typeof word === 'string' ? word.trim() : '', 80) ?? '""';
+    if (kind === 'ambiguous')
+        return msg('model.subagent.ambiguous', { word: quoted });
+    const problem = ownData(reading, 'problem');
+    if (problem === 'tiers-inert')
+        return msg('model.subagent.tiersInert', { word: quoted });
+    if (problem === 'binding-not-in-catalog')
+        return msg('model.subagent.bindingNotInCatalog', { word: quoted });
+    return msg('model.subagent.chainUnbound', { word: quoted });
+}

package/dist/model/tierVocabulary.d.ts

@@ -1,10 +1,12 @@
 import { CORE_DEFAULT_TIER_ORDER } from '../generated/engineFactTables.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
 export type Tier = (typeof CORE_DEFAULT_TIER_ORDER)[number];
 export declare const TIER_ORDER: readonly Tier[];
 export declare const SURFACED_TIERS: readonly Tier[];
 export declare const CC_TIER_ALIASES: Readonly<Record<string, Tier>>;
 export declare const DEFAULT_TIER: Tier;
 export declare const TIER_BLURBS: Readonly<Record<Tier, string>>;
+export declare function tierBlurb(tier: Tier, lang?: UiLanguage): string;
 export type TierGroupDef = {
     tiers: Partial<Record<Tier, string>>;
     defaultTier?: Tier;

package/dist/model/tierVocabulary.js

@@ -1,15 +1,27 @@
 import { CORE_CC_MODEL_TIER_ALIASES, CORE_DEFAULT_TIER_ORDER } from '../generated/engineFactTables.js';
+import { EN_MESSAGES } from '../i18n/messages.en.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 export const TIER_ORDER = CORE_DEFAULT_TIER_ORDER;
 export const SURFACED_TIERS = ['max', 'pro', 'flash', 'lite'];
 export const CC_TIER_ALIASES = CORE_CC_MODEL_TIER_ALIASES;
 export const DEFAULT_TIER = 'pro';
+const TIER_BLURB_KEYS = Object.freeze({
+    ultra: 'model.tier.blurb.ultra',
+    max: 'model.tier.blurb.max',
+    pro: 'model.tier.blurb.pro',
+    flash: 'model.tier.blurb.flash',
+    lite: 'model.tier.blurb.lite',
+});
 export const TIER_BLURBS = {
-    ultra: 'reserved above max — binds when a stronger model lands',
-    max: 'hardest problems — deep reasoning, big refactors',
-    pro: 'everyday driving — the default tier',
-    flash: 'fast + cheap — titles, recaps, volume work',
-    lite: 'cheapest — bulk classification, simple lookups',
+    ultra: EN_MESSAGES[TIER_BLURB_KEYS.ultra],
+    max: EN_MESSAGES[TIER_BLURB_KEYS.max],
+    pro: EN_MESSAGES[TIER_BLURB_KEYS.pro],
+    flash: EN_MESSAGES[TIER_BLURB_KEYS.flash],
+    lite: EN_MESSAGES[TIER_BLURB_KEYS.lite],
 };
+export function tierBlurb(tier, lang) {
+    return typeof tier === 'string' && Object.hasOwn(TIER_BLURB_KEYS, tier) ? renderMessage(msg(TIER_BLURB_KEYS[tier]), lang) : '';
+}
 export const isTier = (v) => typeof v === 'string' && TIER_ORDER.includes(v);
 export function resolveTierBinding(def, tier) {
     const direct = def.tiers[tier];

package/dist/modelCapabilityProbe.d.ts

@@ -1,3 +1,4 @@
+import type { ModelApiWord } from './model/providerPresets.js';
 export interface OpenAICompletionsProbeBody {
     model: string;
     messages: ReadonlyArray<{
@@ -66,4 +67,67 @@ type ProbeWritableEntry = {
     compat?: unknown;
 };
 export declare function applyProbeToEntry<T extends ProbeWritableEntry>(entry: T, result: ModelProbeResult): T;
+export declare const PROBE_VERDICTS: readonly ["ok", "auth", "unreachable", "model", "shape", "busy", "no_token", "other"];
+export type ProbeVerdictWord = (typeof PROBE_VERDICTS)[number];
+export type ProbeAnswerOutcome = 'error' | 'not_model' | 'ended';
+export interface ProbeVerdict {
+    readonly verdict: ProbeVerdictWord;
+    readonly httpStatus?: number;
+    readonly waitedMs?: number;
+    readonly path?: string;
+    readonly apiError?: string;
+    readonly outcome?: ProbeAnswerOutcome;
+    readonly nearModelId?: string;
+    readonly cause?: string;
+}
+export interface LivenessFetchInit {
+    readonly method: 'GET' | 'POST';
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body?: string;
+    readonly signal: AbortSignal;
+}
+export interface LivenessBodyReader {
+    read(): Promise<{
+        readonly done: boolean;
+        readonly value?: Uint8Array | undefined;
+    }>;
+    cancel(): Promise<void>;
+}
+export interface LivenessResponse {
+    readonly status: number;
+    readonly headers: {
+        get(name: string): string | null;
+    };
+    readonly body: {
+        getReader(): LivenessBodyReader;
+    } | null;
+    text(): Promise<string>;
+}
+export type LivenessFetch = (url: string, init: LivenessFetchInit) => Promise<LivenessResponse>;
+export interface LivenessProbeInput {
+    readonly api: ModelApiWord;
+    readonly baseUrl: string;
+    readonly modelId?: string;
+    readonly fetch: LivenessFetch;
+    readonly firstTokenBudgetMs: number;
+    readonly catalogBudgetMs: number;
+    readonly signal?: AbortSignal;
+    readonly now?: () => number;
+    readonly redact?: (text: string) => string;
+    readonly requestUrl?: (path: string) => string;
+}
+export declare function probeModelLiveness(input: LivenessProbeInput): Promise<ProbeVerdict>;
+export type ProbeVerdictRecourse = 'switch_model' | 'check_credentials';
+export interface ProbeVerdictNotice {
+    readonly line: string;
+    readonly recourse?: ProbeVerdictRecourse;
+}
+export interface ProbeVerdictFacts {
+    readonly verdict?: string;
+    readonly httpStatus?: number;
+    readonly waitedMs?: number;
+}
+export declare function probeVerdictNotice(facts: ProbeVerdictFacts | null | undefined, ctx?: {
+    readonly modelName?: string;
+}): ProbeVerdictNotice;
 export {};