@fro.bot/systematic 3.9.1 → 3.10.1

package/dist/lib/model-availability.d.ts

@@ -1,83 +0,0 @@
-interface ConnectedProvider {
-    id: string;
-    models: Record<string, unknown>;
-}
-interface ProvidersResponse {
-    providers: ConnectedProvider[];
-    default: Record<string, string>;
-}
-interface ClientConfigApi {
-    providers: () => Promise<{
-        data: ProvidersResponse;
-        error: undefined;
-    } | {
-        data: undefined;
-        error: unknown;
-    }>;
-}
-export interface OpencodeClientLike {
-    config: ClientConfigApi;
-}
-/**
- * Outcome of model availability discovery.
- *
- * - `api`: The OpenCode server's `/config/providers` endpoint responded with
- *   a connected-providers payload AND `models` is non-empty. An authoritatively
- *   empty response (`data.providers = []`, or providers present with zero
- *   models) collapses to `'unknown'` instead — see below — because the
- *   operational consequence is identical and downstream consumers should treat
- *   both cases the same way.
- * - `cache`: The API call failed (error envelope, thrown, or timed out) and
- *   the local `models.json` cache was readable AND non-empty. `models`
- *   reflects whatever OpenCode last wrote to disk. A cache that loads
- *   successfully but produces a zero-size set collapses to `'unknown'` for
- *   the same operational reason an empty API response does.
- * - `unknown`: Either both the API call and the cache fallback failed (cache
- *   missing, unreadable, corrupt, or schema-mismatched), OR the API call
- *   succeeded with zero usable models. Resolution should degrade gracefully —
- *   callers should treat `unknown` as a signal to skip source-default model
- *   pinning so users do not get agents pinned to inaccessible models.
- *   `models` is the empty set.
- */
-export type DiscoveryStatus = 'api' | 'cache' | 'unknown';
-export interface ModelAvailability {
-    status: DiscoveryStatus;
-    /**
-     * Set of `${providerId}/${modelId}` strings. Typed `ReadonlySet` because
-     * callers must not mutate the returned collection — mutation would corrupt
-     * future calls in the same process. Each `ModelAvailability` is a fresh
-     * instance (see `emptyAvailability()`), so mutation via cast cannot
-     * propagate, but the type makes intent explicit.
-     */
-    models: ReadonlySet<string>;
-}
-interface AvailabilityOptions {
-    /**
-     * Maximum time to wait for `client.config.providers()` before falling
-     * back to the local cache. Defaults to 1500ms — a startup-budget value
-     * that prevents a slow/half-open OpenCode server from holding the plugin
-     * indefinitely.
-     *
-     * Set to `null` to disable the timeout entirely (not recommended).
-     */
-    apiTimeoutMs?: number | null;
-}
-/**
- * Discover the set of `provider/model` keys the OpenCode server considers
- * connected (or, on API failure, the set last written to the on-disk
- * `models.json` cache).
- *
- * The returned `status` lets callers distinguish three discovery outcomes:
- * - `api`: live answer; safe to pin source-default models against it
- * - `cache`: degraded but informed; the cached `provider/model` keys are
- *   plausibly still authoritative
- * - `unknown`: both the API and the cache failed; callers should fall back
- *   to OpenCode's parent-model inheritance rather than pinning a source
- *   default the user may not have access to
- *
- * The API call is bounded by `apiTimeoutMs` (default 1500ms). On timeout,
- * thrown error, error-envelope response, or undefined data, the cache
- * fallback runs. The function never rejects.
- */
-export declare function getAvailableModels(client: OpencodeClientLike, options?: AvailabilityOptions): Promise<ModelAvailability>;
-export {};

package/dist/lib/source-model-defaults.d.ts

@@ -1,117 +0,0 @@
-/**
- * Provider-grouped source category model defaults for Systematic bundled agents.
- *
- * This module owns the canonical shape, Zod schema, and constant for the
- * per-category model resolution chain. The resolution algorithm walks
- * the provider list in order and picks the first available provider/model pair.
- *
- * Provider catalog is constrained to the 7 IDs with empirical OMO usage-frequency
- * justification: vercel=80, opencode=55, github-copilot=39, opencode-go=26,
- * openai=20, anthropic=18, google=10.
- */
-import { z } from 'zod';
-/**
- * Zod literal union of the 7 supported provider IDs.
- * Ordered by OMO empirical usage frequency (highest first).
- */
-export declare const ProviderID: z.ZodUnion<readonly [z.ZodLiteral<"vercel">, z.ZodLiteral<"opencode">, z.ZodLiteral<"github-copilot">, z.ZodLiteral<"opencode-go">, z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"google">]>;
-export type ProviderID = z.infer<typeof ProviderID>;
-/**
- * Zod schema for the full source category model defaults map.
- *
- * Schema is **pure** — it validates only structural correctness:
- * - Shape correctness (CategoryDefaultSchema per value)
- * - Provider lists non-empty (enforced by CategoryDefaultSchema)
- * - Model lists non-empty (enforced by ProviderEntrySchema)
- * - (model, variant) pairs unique within a provider entry
- * - Provider IDs unique within a category
- * - variant is non-empty, whitespace-free, max 128 chars
- * - `rationale` and `whenToOverride` reject pipe (`|`) and newline characters
- *   so the generator produces well-formed Markdown tables
- *
- * Filesystem coverage (every key resolves to a real `agents/<category>/`
- * directory) is NOT checked here. Use `assertCategoryCoverageOnDisk` to
- * enforce that invariant from tests where it matters; the production
- * runtime path uses `assertSourceCategoryModelCoverage` from
- * `agent-overlays.ts` against an in-memory inventory rather than reading
- * disk again.
- */
-export declare const SourceCategoryDefaultsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
-    rationale: z.ZodString;
-    whenToOverride: z.ZodOptional<z.ZodString>;
-    providers: z.ZodArray<z.ZodObject<{
-        provider: z.ZodUnion<readonly [z.ZodLiteral<"vercel">, z.ZodLiteral<"opencode">, z.ZodLiteral<"github-copilot">, z.ZodLiteral<"opencode-go">, z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"google">]>;
-        models: z.ZodArray<z.ZodObject<{
-            model: z.ZodString;
-            variant: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>>;
-/**
- * Verify that every category key in `categories` maps to a real
- * `agents/<category>/` directory on disk under `agentsDir` (defaulting to
- * the package's bundled-agents directory). Throws with a useful message if
- * any keys are unrecognized.
- *
- * Use from tests to lock the SOURCE_CATEGORY_MODEL_DEFAULTS ↔ agents/
- * directory layout contract. The production runtime path validates the
- * inverse direction (every bundled-agent category has a source default)
- * via `assertSourceCategoryModelCoverage` in `agent-overlays.ts`.
- */
-export declare function assertCategoryCoverageOnDisk(categories: readonly string[], agentsDir?: string): void;
-export interface ModelEntry {
-    model: string;
-    variant?: string;
-}
-export interface ProviderEntry {
-    provider: ProviderID;
-    models: ModelEntry[];
-}
-export interface CategoryDefault {
-    rationale: string;
-    whenToOverride?: string;
-    providers: ProviderEntry[];
-}
-export type SourceCategoryDefaults = Record<string, CategoryDefault>;
-/**
- * Provider-grouped source model defaults for the 5 Systematic agent categories.
- *
- * Provider chains are ordered by OMO category-fit reasoning. The resolver
- * walks providers in order and picks the first available provider/model pair.
- * If no provider is available, the first entry of the first provider is used as
- * the last-resort fallback.
- *
- * Model choices translate the existing flat-string-array constant in agent-overlays.ts
- * to the new provider-grouped shape, with variant annotations where applicable.
- */
-export declare const SOURCE_CATEGORY_MODEL_DEFAULTS: SourceCategoryDefaults;
-/**
- * Format the SOURCE_CATEGORY_MODEL_DEFAULTS as a GitHub-flavored markdown table
- * for injection into documentation.
- *
- * Columns: Category | Chain | Rationale | When to Override
- *
- * Chain format: comma-separated `provider/model[+variant]` for the first 2–3
- * provider entries (first model per provider). Appends `, …` when there are
- * more than 3 provider entries.
- *
- * Returns a string ending with `\n` for clean concatenation.
- */
-export declare function formatForDocs(): string;
-/**
- * Walk the provider-grouped shape for a category and return the first available
- * provider/model pair from the availability set.
- *
- * Algorithm:
- * 1. Look up the category. Unknown category is a programmer error — throw.
- * 2. Walk providers in declared order. For each provider, walk its models in
- *    declared order and test `${provider}/${model}` membership in availabilitySet.
- * 3. On first hit, return { provider, model, variant? }.
- * 4. Last-resort fallback (no available model anywhere): return the first model
- *    entry of the first provider entry, including its variant if present.
- */
-export declare function resolveSourceModel(category: string, availabilitySet: ReadonlySet<string>): {
-    provider: ProviderID;
-    model: string;
-    variant?: string;
-};