@aragon-agent/cli 0.6.46 → 0.6.48

package/dist/agent/model-probe.js

@@ -1,391 +0,0 @@
-/**
- * The connection probe behind `Test connection` and `Discover models`
- * (model-profile-connection-test §4.2-§4.8).
- *
- * WHY THIS IS NOT `ModelRegistry.discoverModels()`: that path folds every exception
- * into `[]` and stores the result in a five-minute process-wide cache. Using it here
- * would (a) collapse "wrong key", "wrong URL" and "this account owns no models" into
- * one sentence, and (b) let a probe of an UNSAVED draft endpoint poison `/model`,
- * `/context` and the main session's window resolution for five minutes. So the probe
- * talks to the adapter directly and classifies by `LLMError.errorType`.
- *
- * WHY `complete()` AND NOT ONLY `listModels()`: a model can be listed and still be
- * unable to generate (gateway aliases, permission layers). One real round trip is the
- * only honest answer to "does this work right now", and it is also the only evidence
- * that can produce `model_not_found`.
- *
- * ASCII ONLY: `agent/` is inside `glyphs.test.ts::inScope`.
- */
-import { createHash } from 'node:crypto';
-import { LLMError, MIN_MAX_OUTPUT_TOKENS, classifyOutputLimitFailure, } from '@aragon-agent/core';
-import { isValidEndpointUrl } from '../config/model-profiles.js';
-import { getLogger } from '../logging/logger.js';
-import { PROBE_LIMITS } from './model-probe-limits.js';
-/** `Reply with the single word OK.` - one isolated call, no tools, no system prompt. */
-const PROBE_PROMPT = 'Reply with the single word OK.';
-const UNKNOWN_DETAIL = 'The provider failed in an unrecognized way.';
-const NO_KEY_DETAIL_SUFFIX = ' Set one here or in the environment.';
-/**
- * Which key this draft would actually use (§4.2.1).
- *
- * The editor's `apiKey` field is ALWAYS the empty string: it is the replacement
- * input, not the live credential. `finishProfileEditor` resolves `keep` to the
- * saved entry key and `shared` to `null`, and the runtime then falls back to the
- * shared per-provider key. Without this table the most common path - editing an
- * existing profile, whose credential mode defaults to `keep` - would report
- * `(no key)` for a profile that has one.
- */
-export function resolveDraftKey(input) {
-    const nonEmpty = (value) => value && value.trim().length > 0 ? value.trim() : null;
-    if (input.credentialMode === 'replace')
-        return nonEmpty(input.draftKey);
-    if (input.credentialMode === 'keep') {
-        return nonEmpty(input.existingKey) ?? nonEmpty(input.sharedKey);
-    }
-    return nonEmpty(input.sharedKey);
-}
-/** Trailing slashes are not part of an endpoint's identity. */
-function normalizeBaseUrl(baseUrl) {
-    const trimmed = (baseUrl ?? '').trim();
-    if (trimmed.length === 0)
-        return null;
-    return trimmed.replace(/\/+$/, '');
-}
-function keyDigest(apiKey) {
-    const trimmed = (apiKey ?? '').trim();
-    if (trimmed.length === 0)
-        return 'none';
-    return createHash('sha256').update(trimmed).digest('hex').slice(0, 12);
-}
-/**
- * The host a failure sentence names - same four clauses as
- * `profileEndpointSummary()` in `ui/overlays/ModelProfilePicker.tsx`, which this
- * layer may not import (agent -> ui would invert the layering). `model-probe.test.ts`
- * asserts the two agree, so the duplication cannot drift silently.
- */
-export function endpointHost(baseUrl) {
-    if (!baseUrl || baseUrl.trim().length === 0)
-        return 'the provider';
-    try {
-        const url = new URL(baseUrl.trim());
-        return url.username || url.password || url.search || url.hash ? 'this endpoint'
-            : url.host || 'the provider';
-    }
-    catch {
-        return 'this endpoint';
-    }
-}
-function fingerprint(provider, baseUrl, apiKey, model) {
-    const connection = `${provider}|${normalizeBaseUrl(baseUrl) ?? ''}|${keyDigest(apiKey)}`;
-    return model === undefined ? connection : `${connection}|${model.trim()}`;
-}
-/** Absolute sentence so a redacted, truncated message can never show a key. */
-function redactDetail(text, secrets) {
-    let safe = text;
-    for (const secret of secrets) {
-        if (secret.length > 0)
-            safe = safe.split(secret).join('[redacted]');
-    }
-    return safe.replace(/[\u0000-\u001f\u007f]/g, ' ').slice(0, PROBE_LIMITS.detailChars);
-}
-/**
- * One timer, two recorded facts. `cancelled` and `timeout` must be distinguishable
- * AFTER the fact, because an aborted adapter may resolve quietly or throw something
- * that looks like a network error (§4.3 step 6).
- */
-function createDeadline(timeoutMs, parent) {
-    const controller = new AbortController();
-    let fired = false;
-    const onParentAbort = () => controller.abort();
-    if (parent) {
-        if (parent.aborted)
-            controller.abort();
-        else
-            parent.addEventListener('abort', onParentAbort, { once: true });
-    }
-    const handle = setTimeout(() => { fired = true; controller.abort(); }, timeoutMs);
-    unrefTimer(handle);
-    return {
-        signal: controller.signal,
-        isFired: () => fired,
-        isCancelled: () => parent?.aborted === true,
-        dispose: () => {
-            clearTimeout(handle);
-            parent?.removeEventListener('abort', onParentAbort);
-        },
-    };
-}
-/**
- * Run the best-effort model list under a cap. It never rejects and never vetoes.
- *
- * The cap timer is `unref`'d exactly like the deadline (§4.8): after a fast verdict the
- * list is still in flight, and a referenced five-second timer would keep the process
- * alive on exit for a number nobody is going to read.
- *
- * Taking a THUNK rather than a promise is what stops a synchronous throw (§4.3 step 3):
- * an adapter that fails before its first `await` - a test double, or a guard clause -
- * would otherwise escape past this layer and cancel a completion not yet attempted.
- */
-function withCap(call, ms) {
-    let pending;
-    try {
-        pending = call();
-    }
-    catch {
-        return Promise.resolve(undefined);
-    }
-    return new Promise((resolve) => {
-        const handle = setTimeout(() => resolve(undefined), ms);
-        unrefTimer(handle);
-        const settle = (value) => { clearTimeout(handle); resolve(value); };
-        pending.then((value) => settle(value), () => settle(undefined));
-    });
-}
-/** Timers and immediates both expose `unref<Timer>`; neither may outlive the probe. */
-function unrefTimer(handle) {
-    const unrefable = handle;
-    unrefable.unref?.();
-}
-/**
- * The list AS IT STANDS when the verdict is reached.
- *
- * One macrotask of grace, so a list that resolved while the completion was in flight
- * publishes itself before we judge - and a list still in flight is NOT waited for,
- * because it has no veto over the verdict (§4.3 step 3 / RV-P1-1).
- */
-function listAtVerdict(listing) {
-    const grant = new Promise((resolve) => {
-        unrefTimer(setImmediate(() => resolve(undefined)));
-    });
-    return Promise.race([listing, grant]);
-}
-function guardFailure(provider, request, targetId) {
-    const base = { ok: false, targetId, latencyMs: 0 };
-    if (!provider) {
-        return { ...base, kind: 'unsupported_provider',
-            detail: `This build has no adapter for ${request.provider}.` };
-    }
-    if (!request.apiKey || request.apiKey.trim().length === 0) {
-        return { ...base, kind: 'missing_key',
-            detail: `No API key for ${request.provider}.${NO_KEY_DETAIL_SUFFIX}` };
-    }
-    if (request.baseUrl && !isValidEndpointUrl(request.baseUrl)) {
-        return { ...base, kind: 'invalid_base_url',
-            detail: 'Base URL must be an http(s) URL without credentials, query or fragment.' };
-    }
-    return undefined;
-}
-function mentionsModel(err) {
-    return /model/i.test(err.message);
-}
-/** The ONE classification matrix (§4.4). Signal facts are checked by the caller. */
-function classifyError(err, facts) {
-    if (!(err instanceof LLMError))
-        return { kind: 'unknown', detail: UNKNOWN_DETAIL };
-    const status = typeof err.statusCode === 'number' ? err.statusCode : undefined;
-    const suffix = status === undefined ? '' : ` (HTTP ${status})`;
-    switch (err.errorType) {
-        case 'auth_error':
-            return { kind: 'auth', detail: `Key rejected by ${facts.provider}${suffix}.` };
-        case 'invalid_request':
-        case 'context_overflow':
-            return mentionsModel(err)
-                ? { kind: 'model_not_found',
-                    detail: `The provider did not accept model "${facts.model}"${suffix}.` }
-                : { kind: 'invalid_request', detail: `The provider rejected the request${suffix}.` };
-        case 'rate_limit':
-            return { kind: 'rate_limit',
-                detail: `Rate limited by ${facts.provider}${suffix || ' (HTTP 429)'}. Try again shortly.` };
-        case 'overloaded':
-        case 'server_error':
-            return { kind: 'provider_unavailable',
-                detail: `${facts.provider} is unavailable right now${suffix}.` };
-        case 'network_error':
-            return { kind: 'network',
-                detail: `Could not reach ${facts.host}. Check the base URL, DNS, proxy or VPN.` };
-        case 'timeout':
-            return { kind: 'timeout',
-                detail: `No answer from ${facts.host} within ${facts.timeoutSeconds} s.` };
-        default:
-            return { kind: 'unknown', detail: UNKNOWN_DETAIL };
-    }
-}
-function firstText(message) {
-    const block = message.content.find((part) => part.type === 'text');
-    return block && block.type === 'text' ? block.text : undefined;
-}
-/** Only text literally present in the error body may count as "the field is wrong". */
-function errorBody(err) {
-    return typeof err.raw === 'string' ? err.raw : err.message;
-}
-function isTokenFieldRejection(err, provider) {
-    if (!(err instanceof LLMError))
-        return false;
-    return classifyOutputLimitFailure(provider, err.statusCode ?? 0, errorBody(err)) !== undefined;
-}
-function requestFor(request, deadline, maxTokens) {
-    return {
-        model: request.model.trim(),
-        messages: [{ role: 'user', content: PROBE_PROMPT }],
-        apiKey: request.apiKey ?? '',
-        ...(request.baseUrl ? { baseUrl: request.baseUrl } : {}),
-        signal: deadline.signal,
-        ...(maxTokens === undefined ? {} : { maxTokens }),
-    };
-}
-function logProbe(facts, outcome, now) {
-    try {
-        getLogger().child('llm').info('probe_result', {
-            provider: facts.provider, model: facts.model, host: facts.host,
-            latencyMs: outcome.latencyMs, ok: outcome.ok, kind: outcome.kind ?? 'ok',
-            at: now,
-        });
-    }
-    catch { /* logging must never fail a probe */ }
-}
-function candidateOf(model) {
-    return {
-        id: model.id,
-        name: model.name && model.name !== model.id ? model.name : model.id,
-        ...(model.contextWindowSource === 'api' && model.contextWindow
-            ? { contextWindow: model.contextWindow } : {}),
-        supportsTools: model.supportsTools === true,
-    };
-}
-async function runDiscovery(provider, request, connectionId) {
-    const guard = guardFailure(provider, request, connectionId);
-    if (guard) {
-        return { ok: false, connectionId, kind: guard.kind, detail: guard.detail, models: [],
-            truncated: false, total: 0 };
-    }
-    const deadline = createDeadline(PROBE_LIMITS.discoveryTimeoutMs, request.signal);
-    const facts = { provider: request.provider, model: request.model,
-        host: endpointHost(request.baseUrl), timeoutSeconds: PROBE_LIMITS.discoveryTimeoutMs / 1000 };
-    try {
-        const listed = await provider.listModels(request.apiKey, request.baseUrl ?? undefined, deadline.signal);
-        const candidates = (listed ?? []).map(candidateOf).filter((entry) => entry.id.length > 0);
-        return { ok: true, connectionId, total: candidates.length,
-            models: candidates.slice(0, PROBE_LIMITS.maxListedModels),
-            truncated: candidates.length > PROBE_LIMITS.maxListedModels };
-    }
-    catch (failure) {
-        const verdict = request.signal?.aborted ? { kind: 'cancelled', detail: 'Cancelled.' }
-            : deadline.isFired()
-                ? { kind: 'timeout',
-                    detail: `No answer from ${facts.host} within ${facts.timeoutSeconds} s.` }
-                : classifyError(failure, facts);
-        return { ok: false, connectionId, kind: verdict.kind, detail: verdict.detail, models: [],
-            truncated: false, total: 0 };
-    }
-    finally {
-        deadline.dispose();
-    }
-}
-/** Create the probe port. One instance per App; `SettingsScreen` only passes it down. */
-export function createModelProbe(deps) {
-    const now = deps.now ?? Date.now;
-    return {
-        targetFingerprint: (target) => fingerprint(target.provider, target.baseUrl, target.apiKey, target.model),
-        connectionFingerprint: (target) => fingerprint(target.provider, target.baseUrl, target.apiKey),
-        discover: (request) => runDiscovery(deps.registry.get(request.provider), request, fingerprint(request.provider, request.baseUrl, request.apiKey)),
-        test: (request) => runTest(deps, request),
-    };
-}
-async function runTest(deps, request) {
-    const clock = deps.now ?? Date.now;
-    const started = clock();
-    const targetId = fingerprint(request.provider, request.baseUrl, request.apiKey, request.model);
-    const provider = deps.registry.get(request.provider);
-    const guard = guardFailure(provider, request, targetId);
-    if (guard)
-        return guard;
-    const adapter = provider;
-    const deadline = createDeadline(PROBE_LIMITS.testTimeoutMs, request.signal);
-    const facts = { provider: request.provider, model: request.model.trim(),
-        host: endpointHost(request.baseUrl), timeoutSeconds: PROBE_LIMITS.testTimeoutMs / 1000 };
-    // The list runs CONCURRENTLY and has no veto (§4.3 step 3): it may only decorate a
-    // verdict the completion already produced. Nothing waits for it except the
-    // model-less path, which has no completion to wait for.
-    const listing = withCap(() => adapter.listModels(request.apiKey, request.baseUrl ?? undefined, deadline.signal), PROBE_LIMITS.listModelsBudgetMs);
-    try {
-        return await completeAndJudge(adapter, request, deadline, facts, { targetId, started, now: clock, listing });
-    }
-    finally {
-        deadline.dispose();
-    }
-}
-async function completeAndJudge(provider, request, deadline, facts, context) {
-    const base = { targetId: context.targetId };
-    if (request.model.trim().length === 0) {
-        // Nothing to complete: list only, and report what the key can reach.
-        const reachable = await context.listing;
-        const latencyMs = context.now() - context.started;
-        if (request.signal?.aborted) {
-            return { ...base, ok: false, latencyMs, kind: 'cancelled', detail: 'Cancelled.' };
-        }
-        if (deadline.isFired()) {
-            return { ...base, ok: false, latencyMs, kind: 'timeout',
-                detail: `No answer from ${facts.host} within ${facts.timeoutSeconds} s.` };
-        }
-        return { ...base, ok: true, latencyMs,
-            ...(reachable ? { availableModels: reachable.length } : {}) };
-    }
-    let message;
-    let failure;
-    try {
-        message = await provider.complete(requestFor(request, deadline, MIN_MAX_OUTPUT_TOKENS));
-    }
-    catch (error) {
-        failure = error;
-    }
-    if (failure !== undefined && isTokenFieldRejection(failure, request.provider)) {
-        // Exactly ONE repair retry with the cap left to the adapter's own learned field.
-        try {
-            message = await provider.complete(requestFor(request, deadline));
-            failure = undefined;
-        }
-        catch (error) {
-            failure = error;
-        }
-    }
-    const latencyMs = context.now() - context.started;
-    if (request.signal?.aborted) {
-        return { ...base, ok: false, latencyMs, kind: 'cancelled', detail: 'Cancelled.' };
-    }
-    if (deadline.isFired()) {
-        return { ...base, ok: false, latencyMs, kind: 'timeout',
-            detail: `No answer from ${facts.host} within ${facts.timeoutSeconds} s.` };
-    }
-    if (failure !== undefined || !message) {
-        const verdict = classifyError(failure, facts);
-        const secrets = [request.apiKey ?? ''];
-        const outcome = { ...base, ok: false, latencyMs, kind: verdict.kind,
-            detail: redactDetail(verdict.detail, secrets) };
-        const reachable = await listAtVerdict(context.listing);
-        if (reachable)
-            outcome.availableModels = reachable.length;
-        if (verdict.kind === 'model_not_found' && reachable) {
-            outcome.modelListed = reachable.some((model) => model.id === facts.model);
-        }
-        logProbe(facts, outcome, context.now());
-        return outcome;
-    }
-    const text = firstText(message);
-    if (text === undefined) {
-        const outcome = { ...base, ok: false, latencyMs, kind: 'unknown',
-            detail: UNKNOWN_DETAIL };
-        logProbe(facts, outcome, context.now());
-        return outcome;
-    }
-    const reachable = await listAtVerdict(context.listing);
-    const outcome = {
-        ...base, ok: true, latencyMs,
-        reply: text.trim().slice(0, PROBE_LIMITS.replyChars),
-        ...(message.usage ? { usage: { inputTokens: message.usage.inputTokens,
-                outputTokens: message.usage.outputTokens } } : {}),
-        ...(reachable ? { availableModels: reachable.length,
-            modelListed: reachable.some((model) => model.id === facts.model) } : {}),
-    };
-    logProbe(facts, outcome, context.now());
-    return outcome;
-}

package/dist/agent/queued-messages.d.ts

@@ -1,23 +0,0 @@
-import type { Entry } from './reducer.js';
-import type { InvocationCard } from './invocation-card.js';
-/** Full user text retained until Core acknowledges its opaque ID. */
-export interface PendingSteering {
-    readonly queueId: string;
-    readonly text: string;
-    /** Carried so the `queued -> user` rewrite keeps the card (tui-invocation-cards). */
-    readonly invocation?: InvocationCard;
-}
-/** Hide only active pending entries, using the same projection for measurement and paint. */
-export declare function selectTranscriptEntries(entries: Entry[], pending: readonly PendingSteering[]): Entry[];
-/** Restore trimmed messages in FIFO order before atomically accepting known receipts. */
-export declare function reconcileSteeringReceipt(options: {
-    entries: Entry[];
-    pending: readonly PendingSteering[];
-    ids: readonly string[];
-}): {
-    entries: Entry[];
-    pending: PendingSteering[];
-    changed: boolean;
-};
-/** Supplement trimmed/cleared history for save and exit without deduplicating text. */
-export declare function mergePendingEntries(entries: Entry[], pending: readonly PendingSteering[]): Entry[];

package/dist/agent/queued-messages.js

@@ -1,49 +0,0 @@
-/** Hide only active pending entries, using the same projection for measurement and paint. */
-export function selectTranscriptEntries(entries, pending) {
-    if (pending.length === 0)
-        return entries;
-    const ids = new Set(pending.map((item) => item.queueId));
-    return entries.filter((entry) => entry.kind !== 'queued' || !ids.has(entry.queueId ?? ''));
-}
-/** Restore trimmed messages in FIFO order before atomically accepting known receipts. */
-export function reconcileSteeringReceipt(options) {
-    const receipts = new Set(options.ids);
-    const ids = new Set(options.pending.filter((item) => receipts.has(item.queueId))
-        .map((item) => item.queueId));
-    if (!ids.size)
-        return { entries: options.entries, pending: [...options.pending], changed: false };
-    const entries = mergePendingEntries(options.entries, options.pending).map((entry) => entry.kind === 'queued' && ids.has(entry.queueId ?? '')
-        ? {
-            id: entry.id, kind: 'user', text: entry.text,
-            ...(entry.invocation ? { invocation: entry.invocation } : {}),
-        } : entry);
-    return { entries, pending: options.pending.filter((item) => !ids.has(item.queueId)), changed: true };
-}
-/** Supplement trimmed/cleared history for save and exit without deduplicating text. */
-export function mergePendingEntries(entries, pending) {
-    if (pending.length === 0)
-        return entries;
-    const positions = new Map(pending.map((item, index) => [item.queueId, index]));
-    const visible = new Map(entries.flatMap((entry) => entry.kind === 'queued' && entry.queueId !== undefined
-        ? [[entry.queueId, entry]] : []));
-    const merged = [];
-    let cursor = 0;
-    const appendThrough = (last) => {
-        while (cursor <= last) {
-            const item = pending[cursor++];
-            const existing = visible.get(item.queueId);
-            merged.push(existing ? { ...existing, text: item.text } :
-                { id: `pending:${item.queueId}`, kind: 'queued', ...item });
-        }
-    };
-    for (const entry of entries) {
-        const position = entry.kind === 'queued' && entry.queueId !== undefined
-            ? positions.get(entry.queueId) : undefined;
-        if (position === undefined)
-            merged.push(entry);
-        else
-            appendThrough(position);
-    }
-    appendThrough(pending.length - 1);
-    return merged;
-}