dsh-loop-engine-allinone 0.4.1 → 0.7.0

package/lib/invariant.js

@@ -49,6 +49,20 @@ var ENGINE_REGISTRY = {
     loginHint: "run `codex login`, or set CODEX_API_KEY, or point `codexBin` at a signed-in install",
     authPaths: [".codex/auth.json"],
     localeKey: "engineCodex",
+    // Read out of the bundled CLI binary (0.149.1), which carries the ids its
+    // `thread/start` accepts; the driver passes the picked id straight through as
+    // `model`. Only the codex-family ids are listed: the binary also mentions
+    // `gpt-4.1`/`gpt-5.6` in contexts this build did not verify, and a wrong id
+    // fails loudly at the engine rather than silently falling back.
+    models: [
+      { id: "gpt-5.3-codex", label: "GPT-5.3 Codex" },
+      { id: "gpt-5.2-codex", label: "GPT-5.2 Codex" },
+      { id: "gpt-5.1-codex-max", label: "GPT-5.1 Codex Max" },
+      { id: "gpt-5.1-codex", label: "GPT-5.1 Codex" },
+      { id: "gpt-5.4", label: "GPT-5.4" },
+      { id: "gpt-5.2", label: "GPT-5.2" },
+      { id: "gpt-5.1", label: "GPT-5.1" }
+    ],
     capabilities: {
       streaming: true,
       protocol: "jsonrpc",
@@ -92,6 +106,20 @@ var ENGINE_REGISTRY = {
     loginHint: "run `kimi` once and sign in (or `kimi login`)",
     authPaths: [".kimi-code/credentials.json", ".kimi-code/auth.json"],
     localeKey: "engineKimi",
+    // Read out of `~/.kimi-code/config.toml`, which the Kimi Code app writes for
+    // the signed-in account: one `[models."kimi-code/<id>"]` block per model the
+    // account is provisioned for, with the vendor's own display name. The ids are
+    // what the app passes as `model`, so they are the right vocabulary for this
+    // driver's `session/set_model`. The catalog was NOT read off the ACP surface
+    // itself, because the `kimi` CLI is not installed on the machine this was
+    // measured on (only the desktop app is) — a stale id fails loudly at the
+    // engine rather than silently falling back.
+    models: [
+      { id: "k3", label: "K3" },
+      { id: "k3-256k", label: "K3-256k" },
+      { id: "kimi-for-coding", label: "K2.8 Preview" },
+      { id: "kimi-for-coding-highspeed", label: "K2.7 Code Highspeed" }
+    ],
     capabilities: {
       streaming: true,
       protocol: "acp",

package/lib/types/driver-acp/client.d.ts

@@ -112,6 +112,15 @@ export declare class AcpClient {
     private readonly handlers;
     /** Every terminal this client owns, so a disposed client cannot leak a process. */
     private readonly terminals;
+    /**
+     * The model catalog the agent published on its last `session/new`.
+     *
+     * Free discovery: the frame was already paid for by a session the user opened, so
+     * keeping it costs nothing and spares the maintainer from re-declaring the list
+     * every time the vendor ships a model. `undefined` means the agent published no
+     * model option (every engine except the ACP ones that do).
+     */
+    private lastCatalog;
     /** Monotonic id source for the terminals the agent creates. */
     private nextTerminalId;
     /** Whether this client was sealed or its process exited. */
@@ -171,6 +180,17 @@ export declare class AcpClient {
      * @returns the new session id.
      */
     newSession(cwd: string, extra?: Record<string, unknown>): Promise<string>;
+    /**
+     * The model catalog this agent published on its last `session/new`, if any.
+     *
+     * Empty until the first session is opened, which is the honest state: the plugin
+     * does not know the catalog before an engine has been asked.
+     * @returns the discovered models, or undefined when the agent published none.
+     */
+    discoveredModels(): readonly {
+        readonly id: string;
+        readonly label: string;
+    }[] | undefined;
     /**
      * Load (resume) an existing ACP session by id.
      *

package/lib/types/engine-registry.d.ts

@@ -290,6 +290,28 @@ export declare const ENGINE_REGISTRY: {
         readonly loginHint: "run `codex login`, or set CODEX_API_KEY, or point `codexBin` at a signed-in install";
         readonly authPaths: readonly [".codex/auth.json"];
         readonly localeKey: "engineCodex";
+        readonly models: readonly [{
+            readonly id: "gpt-5.3-codex";
+            readonly label: "GPT-5.3 Codex";
+        }, {
+            readonly id: "gpt-5.2-codex";
+            readonly label: "GPT-5.2 Codex";
+        }, {
+            readonly id: "gpt-5.1-codex-max";
+            readonly label: "GPT-5.1 Codex Max";
+        }, {
+            readonly id: "gpt-5.1-codex";
+            readonly label: "GPT-5.1 Codex";
+        }, {
+            readonly id: "gpt-5.4";
+            readonly label: "GPT-5.4";
+        }, {
+            readonly id: "gpt-5.2";
+            readonly label: "GPT-5.2";
+        }, {
+            readonly id: "gpt-5.1";
+            readonly label: "GPT-5.1";
+        }];
         readonly capabilities: {
             readonly streaming: true;
             readonly protocol: "jsonrpc";
@@ -329,6 +351,19 @@ export declare const ENGINE_REGISTRY: {
         readonly loginHint: "run `kimi` once and sign in (or `kimi login`)";
         readonly authPaths: readonly [".kimi-code/credentials.json", ".kimi-code/auth.json"];
         readonly localeKey: "engineKimi";
+        readonly models: readonly [{
+            readonly id: "k3";
+            readonly label: "K3";
+        }, {
+            readonly id: "k3-256k";
+            readonly label: "K3-256k";
+        }, {
+            readonly id: "kimi-for-coding";
+            readonly label: "K2.8 Preview";
+        }, {
+            readonly id: "kimi-for-coding-highspeed";
+            readonly label: "K2.7 Code Highspeed";
+        }];
         readonly capabilities: {
             readonly streaming: true;
             readonly protocol: "acp";

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

@@ -0,0 +1,98 @@
+/**
+ * Runtime model discovery: asking an engine what its subscription serves, without
+ * breaking the plugin's "booting the harness starts no external process" contract.
+ *
+ * ## Why this exists
+ *
+ * The registry DECLARES each engine's model catalog, because probing one means
+ * spawning the engine and a plugin that spawns ten CLIs at boot is a plugin nobody
+ * can start. The cost of that decision was real: when a vendor shipped a new model,
+ * the list in `engine-registry.ts` went stale, and a user saw the new model only
+ * after a plugin release. That is a maintenance burden on the maintainer and a
+ * stale menu for everyone else.
+ *
+ * This module removes the burden WITHOUT reintroducing the boot cost, by splitting
+ * discovery into two kinds:
+ *
+ *   - **FREE discovery** — the answer is already on disk or already in a frame the
+ *     driver received. Reading `~/.kimi-code/config.toml` spawns nothing; the
+ *     model list inside a `session/new` response was paid for by a session the user
+ *     opened anyway. These run whenever a catalog is asked for.
+ *   - **COSTLY discovery** — it needs a new child process (`grok models`,
+ *     `agy models`). Those are NOT run here: they belong behind an explicit refresh,
+ *     which is the caller's decision rather than something a menu render triggers.
+ *
+ * ## Precedence, and why declared stays
+ *
+ * A discovered catalog wins over the declared one when it is non-empty, because it
+ * describes the account RIGHT NOW. The declared catalog remains as the fallback for
+ * when discovery is impossible (CLI absent, not signed in, subscription lapsed) —
+ * so the menu is never empty and a deployment with no config file still works.
+ *
+ * A stale DECLARED id fails loudly at the engine; a stale DISCOVERED one cannot,
+ * because it came from the engine itself.
+ *
+ * @module dsh-loop-engine-allinone/model-discovery
+ */
+import type { EngineModel } from './engine-registry.ts';
+/**
+ * One discovered catalog, with where it came from.
+ *
+ * The provenance travels because the settings page shows it: "these came from the
+ * engine's own config" and "these are the plugin's declared fallback" are different
+ * claims, and a user debugging a missing model needs to know which one they are
+ * looking at.
+ */
+export interface DiscoveredCatalog {
+    /** The models the engine's own state says this account can use. */
+    readonly models: readonly EngineModel[];
+    /** Where they were read from, for the settings page and for diagnostics. */
+    readonly source: 'kimi-config' | 'acp-session' | 'codex-binary';
+}
+/**
+ * Read a TOML `[models."<provider>/<id>"]` block set into model entries.
+ *
+ * The Kimi Code app writes one block per provisioned model, each carrying the
+ * vendor's own `display_name` and its `model` id:
+ *
+ * ```toml
+ * [models."kimi-code/k3"]
+ * model = "k3"
+ * display_name = "K3"
+ * ```
+ *
+ * A minimal parser rather than a TOML dependency: this reads exactly two keys out of
+ * a file this project does not own, and a dependency for that would be a larger
+ * liability than the twenty lines below. Anything it does not recognize is skipped,
+ * so a config format change degrades to "no discovered models" (and the declared
+ * fallback applies) rather than throwing.
+ * @param text - the config file's contents.
+ * @returns the models, in file order, deduplicated by id.
+ */
+export declare function parseKimiConfigModels(text: string): readonly EngineModel[];
+/**
+ * Read a model catalog out of an ACP `session/new` result's `configOptions`.
+ *
+ * ACP agents publish their session options at `session/new`; a `model` option
+ * carries the engine's own composite ids plus the labels it wants rendered
+ * (measured on MiniMax Code: `m:minimax:MiniMax-M3:v:thinking` -> `M3 · thinking`).
+ * That list cost the user nothing extra - it arrived with a session they opened.
+ * @param configOptions - the `configOptions` array from a `session/new` result.
+ * @returns the models, or undefined when the frame carried no model option.
+ */
+export declare function modelsFromAcpConfigOptions(configOptions: unknown): readonly EngineModel[] | undefined;
+/**
+ * Pick the catalog a surface should render for one engine.
+ *
+ * Discovered wins when non-empty; the declared list is the fallback. Both being
+ * absent is the engine's own "I have no catalog" answer, which the model menu
+ * renders as the shared `external` group.
+ * @param discovered - what runtime discovery found, if anything.
+ * @param declared - the registry's declaration, if any.
+ * @returns the models to render, and which of the two produced them.
+ */
+export declare function effectiveCatalog(discovered: DiscoveredCatalog | undefined, declared: readonly EngineModel[] | undefined): {
+    models: readonly EngineModel[];
+    origin: 'discovered' | 'declared' | 'none';
+};
+//# sourceMappingURL=model-discovery.d.ts.map

package/lib/types/model-registry.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Runtime model discovery, wired to the provider routes.
+ *
+ * ## The timing problem this solves
+ *
+ * Routes are registered at APPLY (plugin boot), but discovery only produces an
+ * answer once an engine has run: an ACP catalog arrives in `session/new`, and a
+ * config file exists only after the app has been used. So boot cannot wait for it.
+ *
+ * The resolution is: boot registers each engine's route from what is knowable then
+ * (the declared catalog, or a FREE disk read), and a later discovery REPLACES that
+ * route's model list in place. `registerAdapter` is not re-called - the adapter
+ * object is asked for its models on every catalog build, so swapping the list it
+ * holds is what makes a newly discovered model appear without a restart.
+ *
+ * ## What is free, and what is not
+ *
+ * - `kimi`: read `~/.kimi-code/config.toml`. No process, safe at boot.
+ * - any ACP engine: the catalog in `session/new`'s `configOptions`, already paid
+ *   for by the session the user opened.
+ * - `codex`: the ids are static in the bundled binary; declared, not probed.
+ * - `grok` / `agy`: would need `grok models` / `agy models`, i.e. a NEW child
+ *   process. Not run here on purpose - the plugin still starts no external process
+ *   to build a menu. Those stay declared.
+ *
+ * @module dsh-loop-engine-allinone/model-registry
+ */
+import { type EngineModel, type HostedEngineId } from './engine-registry.ts';
+import { type DiscoveredCatalog } from './model-discovery.ts';
+/**
+ * Read Kimi's catalog from the app's own config, if the file is there.
+ *
+ * Free: one `readFileSync`, no child process. A missing or unreadable file is not
+ * an error - it means "this host has not used Kimi Code", and the declared catalog
+ * applies.
+ * @returns the catalog, or undefined when there is nothing to read.
+ */
+export declare function discoverKimiCatalog(): DiscoveredCatalog | undefined;
+/**
+ * Record a catalog an engine published at runtime (an ACP `session/new`).
+ * @param engine - the engine that published it.
+ * @param models - the models it published.
+ */
+export declare function recordDiscoveredCatalog(engine: HostedEngineId, models: readonly EngineModel[]): void;
+/**
+ * The catalog to register a route with at boot: discovered-if-free, else declared.
+ *
+ * Only the FREE sources are consulted here, so apply never spawns anything.
+ * @param engine - the engine whose route is being registered.
+ * @returns the models to advertise, and where they came from.
+ */
+export declare function bootCatalog(engine: HostedEngineId): {
+    models: readonly EngineModel[];
+    origin: 'discovered' | 'declared' | 'none';
+};
+/**
+ * The catalog to render RIGHT NOW for one engine.
+ *
+ * A route asks this on every catalog build, so a discovery made after boot shows up
+ * without a restart.
+ * @param engine - the engine whose catalog is wanted.
+ * @returns the live models, discovered taking precedence over declared.
+ */
+export declare function liveCatalog(engine: HostedEngineId): readonly EngineModel[];
+/** What one engine's catalog currently is, and where it came from. */
+export interface CatalogReport {
+    readonly engine: HostedEngineId;
+    readonly models: readonly EngineModel[];
+    readonly origin: 'discovered' | 'declared' | 'none';
+    /** Where a discovered catalog was read from; absent for a declared one. */
+    readonly source?: DiscoveredCatalog['source'];
+}
+/**
+ * Every engine's catalog with its provenance, for the settings page and diagnostics.
+ * @returns one report per engine that has any catalog.
+ */
+export declare function catalogReport(): readonly CatalogReport[];
+//# sourceMappingURL=model-registry.d.ts.map

package/lib/types/provider-route.d.ts

@@ -159,10 +159,14 @@ export declare class HostedEngineRouteAdapter extends LlmAdapter {
     /**
      * The engine-native models this route advertises, beyond `default`.
      *
-     * Empty for the shared `external` route: an engine with no declared catalog
-     * has nothing to add to "the engine decides".
+     * A THUNK rather than a fixed list, because the catalog can change after the
+     * route is registered: an ACP engine publishes its models in `session/new`, and a
+     * config file can gain a model when the vendor ships one. Reading it per catalog
+     * build is what makes a discovered model appear without a plugin restart (see
+     * `model-registry.ts`). A route with nothing to add returns an empty list, which
+     * is the shared `external` route's state.
      */
-    private readonly models;
+    private readonly modelsOf;
     /**
      * The name this route's group shows in the model menu.
      *
@@ -178,7 +182,7 @@ export declare class HostedEngineRouteAdapter extends LlmAdapter {
      * @param models - the engine-native models to advertise beside `default`.
      * @param displayName - the group name shown in the model menu.
      */
-    constructor(contextWindow?: number, label?: string, models?: readonly EngineModel[], displayName?: string);
+    constructor(contextWindow?: number, label?: string, models?: readonly EngineModel[] | (() => readonly EngineModel[]), displayName?: string);
     /**
      * Name the route's one entry.
      *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-loop-engine-allinone",
   "description": "Web-switchable agent loop engine selection for the DeepSeek Harness - out-of-tree plugin with a data-driven engine registry and a pluggable driver layer. Ten engines: Claude Code / Codex / Pi / Kimi Code / Antigravity / ZCode / Qoder CN / Hermes / Grok Build / MiniMax Code. All-in-one fork of kuun993/dsh-loop-engine.",
-  "version": "0.4.1",
+  "version": "0.7.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },