@jini-ai/agent-runtime 0.4.1 → 0.4.3

package/dist/model-discovery-types.d.ts

@@ -0,0 +1,139 @@
+import type { RuntimeEnv, RuntimeModelOption } from './types.js';
+import type { ProviderModelsInput } from './providers/model-catalog.js';
+export type ModelSource = 'cli' | 'rpc' | 'provider-api' | 'cli-cache' | 'config-file' | 'offline-fallback';
+export type ModelIdentityKind = 'concrete' | 'alias' | 'routing-mode';
+export interface DiscoveredModel extends RuntimeModelOption {
+    identityKind: ModelIdentityKind;
+    resolvedId?: string;
+    provider?: string;
+}
+export interface ModelCatalogSnapshot {
+    models: DiscoveredModel[];
+    source: ModelSource;
+    freshness: 'fresh' | 'stale' | 'offline-fallback';
+    fetchedAt: string;
+    expiresAt: string;
+    coverage: 'account' | 'provider' | 'configured' | 'observed';
+    launchFingerprint: string;
+    diagnostics: readonly {
+        code: 'auth-missing' | 'unsupported-version' | 'timeout' | 'offline' | 'malformed-response';
+        message: string;
+    }[];
+    /** Native current selection, preserved even when it is an opaque route. */
+    defaultSelectionId?: string;
+}
+export type DefaultModelResolution = {
+    status: 'resolved';
+    id: string;
+    selectionId?: string;
+    source: ModelSource;
+    resolvedAt: string;
+    launchFingerprint: string;
+} | {
+    status: 'unresolved';
+    selectionId?: string;
+    reason: string;
+};
+/** Represents the actual launch; fingerprints are opaque, never credential values. */
+export interface ModelDiscoveryContext {
+    executable: string;
+    version?: string | null;
+    cwd: string;
+    profile?: string;
+    configFingerprint?: string;
+    projectRoot?: string;
+    configPath?: string;
+    accountScope?: string;
+    env: RuntimeEnv;
+    model?: string;
+    resumeSessionId?: string;
+    /** Host-supplied authoritative metadata for the resumed session. */
+    resumedModelId?: string;
+    settingSources?: readonly string[];
+    settings?: string;
+}
+export interface AgentModelDiscoveryPort {
+    discoverModels(requiredArgs: {
+        context: ModelDiscoveryContext;
+    }, optionalArgs?: {
+        signal?: AbortSignal;
+        force?: boolean;
+        staleWhileRevalidate?: boolean;
+        deps?: ModelDiscoveryDeps;
+    }): Promise<ModelCatalogSnapshot>;
+    resolveDefaultModel(requiredArgs: {
+        context: ModelDiscoveryContext;
+        catalog: ModelCatalogSnapshot;
+    }, optionalArgs?: {
+        signal?: AbortSignal;
+        deps?: ModelDiscoveryDeps;
+    }): Promise<DefaultModelResolution>;
+}
+export interface ModelProbeResult {
+    models: readonly RuntimeModelOption[];
+    defaultSelectionId?: string;
+    source: ModelSource;
+    coverage: ModelCatalogSnapshot['coverage'];
+}
+export interface ModelCacheEntry {
+    good?: ModelCatalogSnapshot;
+    retryAt?: number;
+    failed?: ModelCatalogSnapshot;
+    pending?: Promise<ModelCatalogSnapshot>;
+}
+/** All effects belong to ports. Credentials never enter snapshots or diagnostic strings. */
+export interface ModelDiscoveryDeps {
+    process: {
+        run(input: {
+            context: ModelDiscoveryContext;
+            args: readonly string[];
+            stdin?: string;
+            signal: AbortSignal;
+            timeoutMs: number;
+            complete?: (stdout: string) => boolean;
+            terminateProcessTree?: boolean;
+        }): Promise<{
+            stdout: string;
+            stderr: string;
+        }>;
+    };
+    fs: {
+        read(path: string, options: {
+            signal: AbortSignal;
+        }): Promise<string | null>;
+        projectRoot?(input: {
+            cwd: string;
+            signal: AbortSignal;
+        }): Promise<string | null>;
+    };
+    http: {
+        list(input: ProviderModelsInput): Promise<import('./providers/types.js').ProviderModelsResponse>;
+    };
+    credential: {
+        connection(input: {
+            agentId: string;
+            context: ModelDiscoveryContext;
+            signal: AbortSignal;
+        }): Promise<ProviderModelsInput | null>;
+    };
+    acp: {
+        probe(input: {
+            context: ModelDiscoveryContext;
+            args: readonly string[];
+            signal: AbortSignal;
+        }): Promise<ModelProbeResult>;
+    };
+    /** Copilot/Droid SDK ports: no undocumented CLI flags or inference prompts. */
+    rpc: {
+        probe(input: {
+            agentId: string;
+            context: ModelDiscoveryContext;
+            signal: AbortSignal;
+        }): Promise<ModelProbeResult>;
+    };
+    clock: {
+        now(): number;
+    };
+    cache: Map<string, ModelCacheEntry>;
+}
+//# sourceMappingURL=model-discovery-types.d.ts.map

package/dist/model-discovery-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=model-discovery-types.js.map

package/dist/model-discovery.d.ts

@@ -0,0 +1,46 @@
+import type { RuntimeModelOption } from './types.js';
+import type { AgentModelDiscoveryPort, DefaultModelResolution, DiscoveredModel, ModelCatalogSnapshot, ModelDiscoveryContext, ModelDiscoveryDeps } from './model-discovery-types.js';
+export * from './model-discovery-types.js';
+export declare const MODEL_CATALOG_TTL_MS: number;
+export declare const MODEL_NEGATIVE_TTL_MS = 30000;
+export declare function modelIdentityKind(id: string): DiscoveredModel['identityKind'];
+export declare function normalizeDiscoveredModels(models: readonly RuntimeModelOption[]): DiscoveredModel[];
+/** Hash all launch-affecting state, including env credentials; none of the raw material escapes. */
+export declare function modelLaunchFingerprint(context: ModelDiscoveryContext, configMaterial?: string): string;
+/** Cancellation always reaches the effect port. A broken port cannot hold callers indefinitely. */
+export declare function withModelProbeTimeout<T>(work: (signal: AbortSignal) => Promise<T>, timeoutMs: number, parent?: AbortSignal): Promise<T>;
+export declare class ModelProbeError extends Error {
+    readonly code: ModelCatalogSnapshot['diagnostics'][number]['code'];
+    constructor(code: ModelCatalogSnapshot['diagnostics'][number]['code']);
+}
+export interface AgentDiscoveryConfiguration {
+    fallbackModels: () => readonly RuntimeModelOption[];
+    parse?: (input: {
+        stdout: string;
+    }) => RuntimeModelOption[] | null;
+    args?: readonly string[];
+}
+export declare function createAgentModelDiscovery(agentId: string, configuration: AgentDiscoveryConfiguration): AgentModelDiscoveryPort;
+export declare function offlineSnapshot(fingerprint: string, now: number, fallback: readonly RuntimeModelOption[], issue?: ModelCatalogSnapshot['diagnostics'][number]): ModelCatalogSnapshot;
+/** Hosts may supply either discovery port independently; static definitions need no probes. */
+type ModelDiscoveryDefinition = Partial<AgentModelDiscoveryPort> & {
+    id?: string;
+    fallbackModels?: readonly RuntimeModelOption[];
+    defaultModelEnvVar?: string;
+    supportsCustomModel?: boolean;
+    supportsConcreteModelSelection?: boolean;
+};
+export declare function modelDiscoveryForDef(def: ModelDiscoveryDefinition): AgentModelDiscoveryPort;
+/** Resolve against the actual launch scope, pinning the same ID shown by the picker. */
+export declare function resolveModelForLaunch({ def, context }: {
+    def: ModelDiscoveryDefinition;
+    context: ModelDiscoveryContext;
+}, optional?: {
+    deps?: ModelDiscoveryDeps;
+    signal?: AbortSignal;
+}): Promise<{
+    model: string;
+    catalog: ModelCatalogSnapshot;
+    resolution: DefaultModelResolution;
+}>;
+//# sourceMappingURL=model-discovery.d.ts.map

package/dist/model-discovery.js

@@ -0,0 +1,258 @@
+import { createHash } from 'node:crypto';
+import { readModelConfiguration } from './model-discovery-config.js';
+import { defaultModelDiscoveryDeps, probeAgentCatalog, probeCliCache, modelProbeTimeoutMs } from './model-discovery-adapters.js';
+export * from './model-discovery-types.js';
+export const MODEL_CATALOG_TTL_MS = 15 * 60_000;
+export const MODEL_NEGATIVE_TTL_MS = 30_000;
+const MAX_CATALOG_SCOPES = 128;
+export function modelIdentityKind(id) {
+    const token = id.slice(id.lastIndexOf('/') + 1);
+    if (/^(default|auto|adaptive|smart|deep|rush|ultimate|premium|balanced|fast|vercel-ai-gateway|grok-build)$/i.test(token) || /(?:^|[-/])gateway$/i.test(id))
+        return 'routing-mode';
+    if (/^(opus|sonnet|haiku|fable|best|latest|claude|gemini|gpt|codex|swe)(?:\[.*\])?$/i.test(token) || /(?:^|[-/])latest$/i.test(id))
+        return 'alias';
+    return 'concrete';
+}
+export function normalizeDiscoveredModels(models) {
+    const seen = new Set();
+    return models.flatMap((row) => {
+        if (!row.id || row.id === 'default' || seen.has(row.id))
+            return [];
+        seen.add(row.id);
+        const model = row;
+        return [{ ...row, identityKind: model.identityKind ?? modelIdentityKind(row.id), ...(model.resolvedId ? { resolvedId: model.resolvedId } : {}) }];
+    });
+}
+/** Hash all launch-affecting state, including env credentials; none of the raw material escapes. */
+export function modelLaunchFingerprint(context, configMaterial = '') {
+    return createHash('sha256').update(JSON.stringify({ ...context, env: Object.entries(context.env).sort(([a], [b]) => a.localeCompare(b)), configMaterial })).digest('hex');
+}
+class ProbeTimeout extends Error {
+}
+const probePools = new WeakMap();
+/** Four simultaneous cold probes per host; queued callers keep cancellation responsive. */
+async function boundedProbe(deps, work, signal) {
+    const pool = probePools.get(deps) || { active: 0, queue: [] };
+    probePools.set(deps, pool);
+    if (pool.active >= 4) {
+        await new Promise((resolve, reject) => {
+            const ready = () => { signal?.removeEventListener('abort', abort); resolve(); };
+            const abort = () => { const index = pool.queue.indexOf(ready); if (index >= 0)
+                pool.queue.splice(index, 1); reject(new ProbeTimeout('Probe cancelled')); };
+            pool.queue.push(ready);
+            if (signal?.aborted)
+                abort();
+            else
+                signal?.addEventListener('abort', abort, { once: true });
+        });
+    }
+    else
+        pool.active += 1;
+    try {
+        if (signal?.aborted)
+            throw new ProbeTimeout('Probe cancelled');
+        return await work();
+    }
+    finally {
+        const next = pool.queue.shift();
+        if (next)
+            next();
+        else
+            pool.active -= 1;
+    }
+}
+/** Cancellation always reaches the effect port. A broken port cannot hold callers indefinitely. */
+export async function withModelProbeTimeout(work, timeoutMs, parent) {
+    if (parent?.aborted)
+        throw new ProbeTimeout('Probe cancelled');
+    const controller = new AbortController();
+    let timer;
+    let abortListener;
+    const stopped = new Promise((_resolve, reject) => {
+        abortListener = () => { controller.abort(); reject(new ProbeTimeout('Probe cancelled')); };
+        if (parent?.aborted)
+            abortListener();
+        else
+            parent?.addEventListener('abort', abortListener, { once: true });
+        timer = setTimeout(() => { controller.abort(); reject(new ProbeTimeout('Probe timed out')); }, timeoutMs);
+    });
+    try {
+        return await Promise.race([work(controller.signal), stopped]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (abortListener)
+            parent?.removeEventListener('abort', abortListener);
+    }
+}
+function diagnostic(error) {
+    // Never stringify vendor errors: stderr/HTTP bodies may include credentials or OAuth URLs.
+    const code = error instanceof ProbeTimeout ? 'timeout' : error instanceof ModelProbeError ? error.code : 'offline';
+    return { code, message: ({ timeout: 'Model discovery timed out or was cancelled.', 'auth-missing': 'CLI credentials are unavailable.', 'unsupported-version': 'Native metadata discovery is unavailable for this version.', 'malformed-response': 'Native metadata contained no usable catalog.', offline: 'Model discovery could not reach its source.' })[code] };
+}
+export class ModelProbeError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+export function createAgentModelDiscovery(agentId, configuration) {
+    async function scoped(context, deps, signal) {
+        const config = await withModelProbeTimeout((active) => readModelConfiguration(agentId, context, deps, active), 1000, signal);
+        return { config, key: `${agentId}:${modelLaunchFingerprint(context, config.fingerprintMaterial)}` };
+    }
+    const port = {
+        async discoverModels({ context }, { signal, force = false, staleWhileRevalidate = false, deps = defaultModelDiscoveryDeps } = {}) {
+            let state;
+            try {
+                state = await scoped(context, deps, signal);
+            }
+            catch (error) {
+                return offlineSnapshot(modelLaunchFingerprint(context), deps.clock.now(), configuration.fallbackModels(), diagnostic(error));
+            }
+            const { key, config } = state;
+            const fingerprint = key.slice(agentId.length + 1);
+            const now = deps.clock.now();
+            const cached = deps.cache.get(key) || {};
+            const lastGood = () => cached.failed || (cached.good && {
+                ...cached.good, freshness: Date.parse(cached.good.expiresAt) > now ? cached.good.freshness : 'stale',
+            });
+            if (cached.pending)
+                return staleWhileRevalidate && lastGood() || cached.pending;
+            if (!force && cached.retryAt && cached.retryAt > now && cached.failed)
+                return cached.failed;
+            if (!force && !staleWhileRevalidate && !cached.failed && cached.good && Date.parse(cached.good.expiresAt) > now)
+                return cached.good;
+            // A fresh host process may still have a CLI-owned disk catalog. Use its observed rows
+            // immediately; keep stale provenance and refresh without holding the first user prompt.
+            if (staleWhileRevalidate && !cached.good && ['codex', 'opencode', 'claude', 'codebuddy'].includes(agentId)) {
+                try {
+                    const disk = await withModelProbeTimeout(active => probeCliCache(agentId, context, deps, active), 1000, signal);
+                    const models = normalizeDiscoveredModels(disk.models);
+                    if (models.length)
+                        cached.good = { models, source: 'cli-cache', coverage: disk.coverage,
+                            freshness: 'stale', fetchedAt: new Date(now).toISOString(), expiresAt: new Date(now).toISOString(),
+                            launchFingerprint: fingerprint, diagnostics: [],
+                            ...(config.selection ? { defaultSelectionId: config.selection } : {}) };
+                }
+                catch { /* No usable disk cache: keep the bounded cold-probe path below. */ }
+                // Another caller may have started the refresh while disk metadata was read.
+                const concurrent = deps.cache.get(key);
+                if (concurrent?.pending)
+                    return concurrent.failed || concurrent.good || concurrent.pending;
+            }
+            const pending = (async () => {
+                try {
+                    const result = await boundedProbe(deps, () => withModelProbeTimeout((active) => probeAgentCatalog(agentId, context, configuration, deps, active), modelProbeTimeoutMs(agentId), signal), signal);
+                    const models = normalizeDiscoveredModels(result.models);
+                    if (models.length === 0)
+                        throw new ModelProbeError('malformed-response');
+                    const fetched = deps.clock.now();
+                    // Native default metadata outranks a config guess (Grok can route despite its TOML).
+                    const nativeWins = result.source === 'rpc' && !['claude', 'codebuddy'].includes(agentId) || agentId === 'grok-build';
+                    const selection = context.model || (nativeWins ? result.defaultSelectionId || config.selection : config.selection || result.defaultSelectionId);
+                    const snapshot = { models, source: result.source, coverage: result.coverage,
+                        fetchedAt: new Date(fetched).toISOString(), expiresAt: new Date(fetched + MODEL_CATALOG_TTL_MS).toISOString(),
+                        freshness: result.source === 'cli-cache' ? 'stale' : 'fresh', launchFingerprint: fingerprint, diagnostics: [],
+                        ...(selection ? { defaultSelectionId: selection } : {}) };
+                    cached.good = snapshot;
+                    delete cached.retryAt;
+                    delete cached.failed;
+                    return snapshot;
+                }
+                catch (error) {
+                    cached.retryAt = deps.clock.now() + MODEL_NEGATIVE_TTL_MS;
+                    cached.failed = cached.good ? { ...cached.good, freshness: 'stale', diagnostics: [diagnostic(error)] } : offlineSnapshot(fingerprint, deps.clock.now(), configuration.fallbackModels(), diagnostic(error));
+                    return cached.failed;
+                }
+                finally {
+                    delete cached.pending;
+                }
+            })();
+            cached.pending = pending;
+            deps.cache.set(key, cached);
+            // Evict settled scopes first; coalesced callers must retain their in-flight entry.
+            for (const [oldKey, entry] of deps.cache) {
+                if (deps.cache.size <= MAX_CATALOG_SCOPES)
+                    break;
+                if (!entry.pending)
+                    deps.cache.delete(oldKey);
+            }
+            // Explicit rescan still waits for live evidence. Launches retain the scoped last-good
+            // catalog while this coalesced, timeout-bounded refresh updates the cache in the background.
+            return staleWhileRevalidate && lastGood() || pending;
+        },
+        async resolveDefaultModel({ context, catalog }, { signal, deps = defaultModelDiscoveryDeps } = {}) {
+            let state;
+            try {
+                state = await scoped(context, deps, signal);
+            }
+            catch {
+                return { status: 'unresolved', reason: 'Launch configuration could not be read.' };
+            }
+            const fingerprint = state.key.slice(agentId.length + 1);
+            if (fingerprint !== catalog.launchFingerprint)
+                return { status: 'unresolved', reason: 'Launch configuration changed; refresh the catalog.' };
+            if (context.resumeSessionId && !context.resumedModelId && !context.model)
+                return { status: 'unresolved', reason: 'Resumed session model metadata is required.' };
+            const selection = context.model || context.resumedModelId || catalog.defaultSelectionId || state.config.selection;
+            if (!selection)
+                return { status: 'unresolved', reason: 'Native metadata did not resolve a default; pick a concrete model.' };
+            const row = catalog.models.find((model) => model.id === selection || model.label === selection);
+            if (catalog.freshness === 'offline-fallback' && row && row.id !== selection)
+                return { status: 'unresolved', selectionId: selection, reason: 'Offline hints cannot resolve a display name or alias.' };
+            const id = row?.resolvedId || (row?.identityKind === 'concrete' ? row.id : undefined);
+            if (!id || modelIdentityKind(id) !== 'concrete')
+                return { status: 'unresolved', selectionId: selection, reason: 'The configured selection has no concrete model evidence.' };
+            return { status: 'resolved', id, selectionId: selection, source: state.config.selection === selection ? 'config-file' : catalog.source, resolvedAt: new Date(deps.clock.now()).toISOString(), launchFingerprint: fingerprint };
+        },
+    };
+    return port;
+}
+export function offlineSnapshot(fingerprint, now, fallback, issue) {
+    return { models: normalizeDiscoveredModels(fallback), source: 'offline-fallback', freshness: 'offline-fallback', fetchedAt: new Date(now).toISOString(), expiresAt: new Date(now + MODEL_NEGATIVE_TTL_MS).toISOString(), coverage: 'configured', launchFingerprint: fingerprint, diagnostics: issue ? [issue] : [] };
+}
+export function modelDiscoveryForDef(def) {
+    return {
+        discoverModels: def.discoverModels?.bind(def) || (async ({ context }, { deps = defaultModelDiscoveryDeps } = {}) => {
+            const catalog = offlineSnapshot(modelLaunchFingerprint(context), deps.clock.now(), def.fallbackModels || []);
+            const configured = def.defaultModelEnvVar && context.env[def.defaultModelEnvVar]?.trim();
+            // Static hosts used their first concrete fallback before discovery existed. Preserve
+            // that contract while letting a declared env default or explicit selection take precedence.
+            const selection = context.model || context.resumedModelId || configured || catalog.models.find(row => row.identityKind === 'concrete')?.id;
+            return { ...catalog, ...(selection ? { defaultSelectionId: selection } : {}) };
+        }),
+        resolveDefaultModel: def.resolveDefaultModel?.bind(def) || (async ({ context, catalog }, { deps = defaultModelDiscoveryDeps } = {}) => {
+            if (context.resumeSessionId && !context.resumedModelId && !context.model)
+                return { status: 'unresolved', reason: 'Resumed session model metadata is required.' };
+            const configured = def.defaultModelEnvVar && context.env[def.defaultModelEnvVar]?.trim();
+            const selection = context.model || context.resumedModelId || configured || catalog.defaultSelectionId;
+            const row = catalog.models.find(model => model.id === selection || model.label === selection);
+            // A host's declared env default is authoritative even when its static hints lag behind.
+            const id = row?.resolvedId || (row?.identityKind === 'concrete' ? row.id : undefined)
+                || (configured === selection && configured ? configured : undefined);
+            if (!id || modelIdentityKind(id) !== 'concrete')
+                return { status: 'unresolved', ...(selection ? { selectionId: selection } : {}), reason: 'The configured selection has no concrete model evidence.' };
+            return { status: 'resolved', id, ...(selection ? { selectionId: selection } : {}), source: configured === selection ? 'config-file' : catalog.source,
+                resolvedAt: new Date(deps.clock.now()).toISOString(), launchFingerprint: catalog.launchFingerprint };
+        }),
+    };
+}
+/** Resolve against the actual launch scope, pinning the same ID shown by the picker. */
+export async function resolveModelForLaunch({ def, context }, optional = {}) {
+    if (def.supportsConcreteModelSelection === false)
+        throw new Error('This CLI cannot pin a concrete starting model.');
+    const discovery = modelDiscoveryForDef(def);
+    const catalog = await discovery.discoverModels({ context }, { ...optional, staleWhileRevalidate: true });
+    // Custom input is allowed unless the definition explicitly disables it: an unlisted user ID is already
+    // the intended launch value. Never substitute a catalog default or reinterpret its spelling.
+    const resolution = context.model && def.supportsCustomModel !== false && !catalog.models.some(row => row.id === context.model)
+        ? { status: 'resolved', id: context.model, selectionId: context.model, source: 'config-file', resolvedAt: new Date((optional.deps || defaultModelDiscoveryDeps).clock.now()).toISOString(), launchFingerprint: catalog.launchFingerprint }
+        : await discovery.resolveDefaultModel({ context, catalog }, optional);
+    if (resolution.status !== 'resolved')
+        throw new Error(resolution.reason);
+    return { model: resolution.id, catalog, resolution };
+}
+//# sourceMappingURL=model-discovery.js.map

package/dist/model-registry.d.ts

@@ -1,41 +1,10 @@
 /**
  * @module model-registry
- *
- * The provider/model/agent vocabulary that any Jini consumer picking "which
- * model" or "which coding agent" to run needs, plus the handful of pure
- * helpers (credential-status resolution, model-list merging, a stable cache
- * key, model-choice normalization against a live catalogue) those pickers
- * all independently re-derive today.
- *
- * Ported and generified from OD's `apps/web/src/state/config.ts`
- * (`KnownProvider`/`KNOWN_PROVIDERS`), `packages/contracts/src/api/registry.ts`
- * (`AgentInfo`/`AgentDiagnostic`/`AgentFixIntent`/`AgentModelOption`),
- * `packages/contracts/src/api/providerModels.ts` (`ProviderModelOption`),
- * `packages/contracts/src/api/app-config.ts` (`AgentModelPrefs`),
- * `apps/web/src/components/providerModelsCache.ts`, and
- * `apps/web/src/components/agentModelSelection.ts` — see
- * `packages/agent-runtime/archived provenance ledger` for the full per-symbol mapping.
- * No OD product-identity strings or OD-specific gating (e.g. the original's
- * hardcoded `agent.id === 'amr'` carve-out) survived the port.
- *
- * Named `model-registry.ts`, not `registry.ts`: this package already has a
- * `registry.ts` (the `BASE_AGENT_DEFS` static CLI-adapter catalog +
- * `getAgentDef(id)`) — a different concept that happens to share the word
- * "registry". `AgentDiagnostic`/`AgentDiagnosticSeverity`/`AgentFixIntent`
- * are NOT redefined here either, for the same reason `ModelOption` isn't:
- * this package already has real, more complete versions of all three
- * (`./types.js`, vendored from the same OD `packages/contracts/src/api/
- * registry.ts` source this module cites above — main's `AgentFixIntent`
- * adds a `launchOAuth` case this port's copy lacked, and its
- * `AgentDiagnostic.reason` is the specific `AgentDiagnosticReason` literal
- * union rather than a bare `string`). Reusing them keeps one canonical
- * diagnostic shape in the package instead of two divergent ones under the
- * same names. `ModelOption` alone is renamed (to `ModelCatalogOption`)
- * rather than reused, because the package's existing `ModelOption`
- * (`agent-protocol/acp/models.ts`, `{ id, label }`) is a narrower,
- * genuinely different shape for ACP model-probe results, not a compatible
- * version of this module's `{ id, label, hint, providerId, default, caps }`
- * model-catalogue entry.
+ * Provider/model/agent picker vocabulary and credential-status, merge, cache and choice helpers.
+ * registry.ts owns the CLI-adapter catalog, a distinct concept. Reuse the canonical protocol
+ * catalog types and runtime diagnostic types rather than redefining looser copies.
+ * ModelCatalogOption carries provider/hint/default/capability data; the protocol ACP ModelOption
+ * is a narrower id/label probe shape, so their names and contracts stay separate.
  */
 import type { AgentDefinition, CredentialStatus, ModelCatalogOption, ModelProvider } from '@jini-ai/protocol';
 export interface AgentModelChoice {

package/dist/models.d.ts

@@ -1,9 +1,6 @@
 /**
  * @module models
- *
- * Model-option defaults, a per-agent "last surfaced to the UI" live-model
- * cache, and model-id sanitization. Ported verbatim from OD's
- * `apps/daemon/src/runtimes/models.ts` — no product coupling.
+ * Model-option defaults, a per-agent last-surfaced live-model cache and model-id sanitization.
  */
 import type { RuntimeAgentDef, RuntimeModelOption } from './types.js';
 export declare const DEFAULT_MODEL_OPTION: RuntimeModelOption;

package/dist/models.js

@@ -86,7 +86,9 @@ export function sanitizeCustomModel({ id }) {
     const trimmed = id.trim();
     if (trimmed.length === 0 || trimmed.length > 200)
         return null;
-    if (!/^[A-Za-z0-9][A-Za-z0-9._/:@-]*$/.test(trimmed))
+    // Catalog capability variants (e.g. Claude's [1m] context window) are native model IDs.
+    // argv is never a shell string; keep the existing leading-flag/whitespace/control guards.
+    if (!/^[A-Za-z0-9][A-Za-z0-9._/:@\[\]-]*$/.test(trimmed))
         return null;
     return trimmed;
 }

package/dist/opencode-log.js

@@ -8,9 +8,7 @@
  * only in OpenCode's own session log (`service=llm … error={…}`). This
  * module recovers that signal so a chat UI can show "usage limit reached"
  * instead of a bare timeout. OpenCode-specific by design.
- *
- * Ported verbatim from OD's `apps/daemon/src/runtimes/opencode-log.ts`
- * — no product coupling (it only reads OpenCode's own on-disk log format).
+
  */
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';

package/dist/paths.js

@@ -1,9 +1,6 @@
 /**
  * @module paths
- *
- * Home-relative path expansion for configured env values and file paths.
- * Ported verbatim from OD's `apps/daemon/src/runtimes/paths.ts` — no
- * product coupling.
+ * Home-relative expansion for configured environment values and file paths.
  */
 import path from 'node:path';
 import { homedir } from 'node:os';

package/dist/pi-models.d.ts

@@ -1,12 +1,6 @@
 /**
  * @module pi-models
- *
- * Parses `pi --list-models`'s TSV table (read from stderr) into model
- * options. Ported verbatim (pure string parsing, no transport) from OD's
- * `apps/daemon/src/pi-rpc.ts#parsePiModels` — the surrounding file is the
- * ~700-line pi-rpc stdio transport (out of this task's scope, same
- * reasoning as `acp-model-probe.ts`), but this one function has no
- * dependency on it.
+ * Parse the pi --list-models whitespace table into model options, independently of the stdio transport.
  */
 import type { RuntimeModelOption } from './types.js';
 export declare function parsePiModels({ stdout }: {

package/dist/pi-models.js

@@ -13,9 +13,7 @@ export function parsePiModels({ stdout }) {
         // The loop bound (`i < lines.length`) guarantees `lines[i]` is always
         // defined; the non-null assertion documents that runtime invariant
         // instead of a `noUncheckedIndexedAccess`-driven guard that could never
-        // actually trigger (same treatment as this function's other port,
-        // `agent-protocol/pi-rpc/models.ts` — see archived provenance ledger's "Barrel
-        // merge" section for why two copies of this function exist).
+        // actually trigger.
         const line = lines[i];
         const parts = line.split(/\s+/);
         if (parts.length < 2)

package/dist/prompt-augmenter.d.ts

@@ -1,22 +1,8 @@
 /**
  * @module prompt-augmenter
- *
- * Port replacing OD's `apps/daemon/src/runtimes/chat-prompt-inputs.ts` (design-system
- * selection resolution — `resolveEffectiveDesignSystemSelection`,
- * `designSystemIdFromPluginSnapshot`, `formatDesignFilesWorkspaceHint`,
- * Codex image-generation prompt overrides, comment-attachment rendering,
- * research-command-contract composition — all genuinely OD-product prompt
- * content) and the workspace-context-kind half of OD's
- * `runtimes/chat-run-context.ts` (not present on this branch as a separate
- * file, but the same `'design-system'`-as-a-context-kind concept lives
- * inline in `chat-prompt-inputs.ts`).
- *
- * None of that OD logic is ported — per the task charter, this file defines
- * only the injection seam. The shape below is r1b §1's proposed
- * `PromptAugmenter` signature, used as-is (it matched the real source: the
- * engine composes a base prompt and a generic `RunContextSelection`, then
- * calls out to the host for product-specific augmentation and an optional
- * system-prompt overlay).
+ * Product context, artifact conventions, research contracts and system overlays are host-owned.
+ * The engine composes a base prompt and generic RunContextSelection, then calls this port rather
+ * than depending on a product's design/annotation/workspace model.
  */
 /** A single item in the run's attached/selected workspace context. `kind` is host-defined — the engine treats it as an opaque string. */
 export interface WorkspaceContextItem {

package/dist/prompt-augmenter.js

@@ -1,22 +1,8 @@
 /**
  * @module prompt-augmenter
- *
- * Port replacing OD's `apps/daemon/src/runtimes/chat-prompt-inputs.ts` (design-system
- * selection resolution — `resolveEffectiveDesignSystemSelection`,
- * `designSystemIdFromPluginSnapshot`, `formatDesignFilesWorkspaceHint`,
- * Codex image-generation prompt overrides, comment-attachment rendering,
- * research-command-contract composition — all genuinely OD-product prompt
- * content) and the workspace-context-kind half of OD's
- * `runtimes/chat-run-context.ts` (not present on this branch as a separate
- * file, but the same `'design-system'`-as-a-context-kind concept lives
- * inline in `chat-prompt-inputs.ts`).
- *
- * None of that OD logic is ported — per the task charter, this file defines
- * only the injection seam. The shape below is r1b §1's proposed
- * `PromptAugmenter` signature, used as-is (it matched the real source: the
- * engine composes a base prompt and a generic `RunContextSelection`, then
- * calls out to the host for product-specific augmentation and an optional
- * system-prompt overlay).
+ * Product context, artifact conventions, research contracts and system overlays are host-owned.
+ * The engine composes a base prompt and generic RunContextSelection, then calls this port rather
+ * than depending on a product's design/annotation/workspace model.
  */
 /** Passes the base prompt through unchanged and adds no system overlay. */
 export const noopPromptAugmenter = {

package/dist/providers/model-catalog.d.ts

@@ -20,6 +20,8 @@ export type ProviderModelsInput = ProviderModelsRequest & {
     requestInit?: Pick<RequestInit, 'dispatcher'>;
     /** Injectable DNS resolver for the base-URL SSRF guard; defaults to `node:dns`. */
     dnsLookup?: DnsLookupFn;
+    /** Injectable HTTP transport for adapter conformance; defaults to fetch. */
+    fetchFn?: typeof fetch;
 };
 /**
  * Fetches the live model catalog for a BYOK provider connection. Validates