dsh-loop-engine-allinone 0.0.0-stage → 0.4.0

package/lib/types/preset.d.ts

@@ -0,0 +1,254 @@
+/**
+ * Hosted-engine agent presets: one managed copy of the deployment's `standard`
+ * preset per hosted engine, with the dsh-native command and skill rows
+ * stripped.
+ *
+ * A hosted engine (Claude Code, Codex, Pi, Kimi) owns its session's command
+ * and skill surface: the plugin bridges the engine's own slash commands and
+ * skill providers into the session (see `engine-surface.ts`), and the
+ * dsh-native equivalents would only duplicate or mislead — dsh `/plan` is
+ * advisory prompt text an external engine never assembles, and dsh skills
+ * would sit next to the engine's own catalog. Those rows live inside the
+ * agent-preset composition, which a profile patch cannot otherwise reach, so
+ * the plugin authors a stripped copy of that composition per engine. The
+ * compaction group is deliberately NOT stripped: it is what keeps the SESSION
+ * LOG bounded, and a hosted engine's own per-turn compaction cannot stand in
+ * for it (see {@link STRIPPED_ROWS}).
+ *
+ * The copy is also where the deployment's summarization model is written
+ * ({@link applySummarizerTarget}): compaction summarizes through an ordinary
+ * llm call, and a hosted session's routed model is this plugin's placeholder
+ * route, so without a real dsh model named at
+ * `compaction-basic.config.summarizationProvider` / `summarizationModel` the
+ * group can never shrink anything. A profile patch cannot reach that nested
+ * row (a row's `config` is replaced whole), which leaves the composition the
+ * plugin authors as the one carrier.
+ *
+ * WHICH mechanism carries that copy is the running harness generation's
+ * business, and the two share everything but the carrier:
+ *
+ *  - the 0.1.5 line reads presets from a DIRECTORY per preset under the user
+ *    preset root (`$DSH_HOME/.agent-presets/<id>`), so there it is two files
+ *    per engine ({@link ensureEnginePresets});
+ *  - the 0.1.7 line replaced that with composed plugin rows: a preset is one
+ *    `@deepseek-ai/dsh-agent-preset` row whose `config.plugins` list IS the
+ *    composition, declared wherever a composition is declared. Nothing reads
+ *    `.agent-presets` any more, so there it is four `insert` rows in the
+ *    profile patch the plugin already manages
+ *    ({@link ensureEnginePresetRows}). The rows mirror the shipped shape
+ *    (`packages/bundle/web-app/presets/standard.patch.yml` in the harness),
+ *    with this plugin's own id, order, and stripped composition.
+ *
+ * Both mechanisms regenerate from the current `standard` composition on every
+ * boot: text on disk is never authoritative, so a harness upgrade that changes
+ * `standard` flows through. Neither re-parses YAML — the strip is a line
+ * transform that preserves everything it does not drop byte for byte, comments
+ * included, and the row form only re-indents that text.
+ *
+ * The preset id is ALSO the per-session engine selector: the harness resolves
+ * one preset per session and hands its id to the agent factory at create time
+ * (`CreateAgentOptions.meta.agentPreset`), which is the only per-session
+ * channel that reaches agent creation. One preset per engine is therefore what
+ * makes "session A on Codex, session B on Kimi, concurrently" expressible in a
+ * harness that admits exactly one AgentFactory.
+ *
+ * @module dsh-loop-engine-allinone/preset
+ */
+export { HOSTED_PRESET_PREFIX, SOURCE_PRESET_ID, engineOfPreset, enginePresetId, hostedEngineOf, sessionEngineOf, } from './agent-preset-ids.ts';
+export type { SessionEngine } from './agent-preset-ids.ts';
+/** Harness-home-relative directory of locally authored presets (mirrors `USER_PRESET_DIR` in `dsh-agent-presets`). */
+export declare const USER_PRESET_DIR = ".agent-presets";
+/** The composition file that makes a directory a preset. */
+export declare const COMPOSITION_FILE = "agent.cordis.yml";
+/** The display-metadata file beside a preset's composition. */
+export declare const METADATA_FILE = "preset.yml";
+/** Every preset id this plugin owns, whether or not it is currently authored. */
+export declare const HOSTED_PRESET_IDS: readonly string[];
+/**
+ * Top-level rows stripped from the source preset for hosted engines:
+ * - `skill-filesystem` / `tool-skill`: the dsh skill surface — each engine
+ *   registers its own skill provider in the session's agent scope;
+ * - `tool-goal` / `command-goal`: dsh's goal mode. The model-facing tool only
+ *   works while an in-process loop drives the session, and the human command
+ *   would sit in the menu with nothing behind it — no hosted engine here
+ *   implements `/goal`, so there is nothing for it to hand over to. The
+ *   `command-goal` row lives HERE, in the preset layer, because that is where
+ *   the human command is registered; disabling the host-plane row from the
+ *   profile patch does not reach it (`standard` carries its own row);
+ * - `planning`: dsh plan mode — its only model-visible effect is a system
+ *   prompt section an external engine never assembles.
+ *
+ * The `compaction` group is KEPT, and must stay kept: it is what bounds the
+ * SESSION LOG, which every hosted step replays in full as its engine prompt
+ * (`src/driver-core/prompt.ts`). A hosted engine's own compaction cannot stand
+ * in for it — the engine's context is thrown away, because the driver opens a
+ * fresh engine session per step (`session/new` for Kimi, a new thread / query
+ * for the others), so its shrink lasts one step while the log keeps growing and
+ * each later step replays everything again. Measured on a real 33-turn Kimi
+ * session: ~3.3 MB replayed per step (tool results 2.0 MB + tool-call lines
+ * 1.19 MB), which the Kimi CLI auto-compacted from ~918k tokens down to ~47k at
+ * the start of every turn — and discarded. Keeping this group is what lets dsh
+ * write its own durable checkpoints instead. The route needs a declared
+ * capacity for that to fire: see `DEFAULT_ENGINE_CONTEXT_WINDOW`
+ * (`src/provider-route.ts`) and the `engineContextWindow` Config field
+ * (`src/index.ts`).
+ */
+export declare const STRIPPED_ROWS: readonly ["skill-filesystem", "tool-skill", "tool-goal", "command-goal", "planning"];
+/**
+ * Begin marker of the plugin-managed preset-rows region inside a profile patch
+ * file. The region is what registers the hosted engines' presets on the 0.1.7
+ * line, where a preset is a composed row rather than a directory.
+ *
+ * Deliberately NOT the managed block's marker: the two regions are located and
+ * rewritten independently, so editing one never rewrites the other's bytes.
+ */
+export declare const PRESET_ROWS_BEGIN = "# -- dsh-loop-engine presets --";
+/** End marker of the plugin-managed preset-rows region inside a profile patch file. */
+export declare const PRESET_ROWS_END = "# -- /dsh-loop-engine presets --";
+/**
+ * Roster order of every preset this plugin authors. The shipped presets occupy
+ * 1..4 (`standard` 1, `ptc` 2, `minimal` 3, `cordis` 4), and the roster sorts
+ * by order and then by id, so one constant past that range puts every managed
+ * preset after every shipped one — the deployment's own presets stay at the top
+ * of the picker and the engines' copies trail it, which is also where the
+ * order they are listed in (selection order) is readable.
+ */
+export declare const ENGINE_PRESET_ORDER = 100;
+/**
+ * Entry id of the harness plugin whose `config` names the dsh model a hosted
+ * session's compaction summarizes through
+ * (`@deepseek-ai/dsh-compaction-basic`, a child of the `compaction` group).
+ * See {@link applySummarizerTarget} for why the plugin writes it.
+ */
+export declare const SUMMARIZER_ENTRY_ID = "compaction-basic";
+/**
+ * The dsh model a hosted session's compaction summarizes through: a real dsh
+ * provider route and an exact model id on it, never this plugin's placeholder
+ * route.
+ *
+ * The pair exists because compaction summarizes by making an ordinary llm call
+ * (`packages/compaction/compaction-basic/src/summarizer.ts` `resolveTarget`),
+ * and a hosted session's routed model is this plugin's own placeholder
+ * (`external/default`), whose `stream()` fails loud
+ * (`src/provider-route.ts`). See {@link applySummarizerTarget}.
+ */
+export interface SummarizerTarget {
+    /** Dsh provider route the summarization request is sent to. */
+    readonly provider: string;
+    /** Exact model id on that route. */
+    readonly model: string;
+}
+/**
+ * The managed preset-rows region: one preset row per hosted engine, bracketed
+ * by the markers that make it locatable and rewritable.
+ * @param composition - the source `standard` composition.
+ * @param target - the summarization model to write into every copy, or
+ *   undefined to leave the copies exactly as the strip left them.
+ * @returns the region's text, ending in a newline.
+ */
+export declare function renderPresetRows(composition: string, target?: SummarizerTarget): string;
+/**
+ * Produce the next patch-file text carrying the preset-rows region, preserving
+ * every byte outside that span — including the managed block, which is located
+ * by its own markers. Appends the region when absent and replaces it when
+ * present, so an unchanged composition leaves the text byte for byte identical.
+ *
+ * The region is a root-level collection like the managed block, so a leftover
+ * seed `[]` is dropped with it: two root collections in one document is YAML
+ * the harness rejects, and the profile would stop booting.
+ * @param text - current patch-file text.
+ * @param composition - the source `standard` composition.
+ * @param target - the summarization model to write into every copy, or
+ *   undefined to leave the copies exactly as the strip left them.
+ * @returns the rewritten patch-file text.
+ */
+export declare function applyEnginePresetRows(text: string, composition: string, target?: SummarizerTarget): string;
+/**
+ * Remove top-level entries by id from a preset composition, preserving every
+ * other byte. Each entry owns the comment/blank run directly above its opener
+ * — that run is the entry's section heading and drops with it — except the
+ * run above the FIRST entry, which is the file header and stays. Entries
+ * without an `id` opener are always kept: the transform touches only what it
+ * can name.
+ * @param text - the source composition.
+ * @param ids - top-level row ids to strip.
+ * @returns the stripped composition.
+ */
+export declare function stripPresetRows(text: string, ids?: readonly string[]): string;
+/**
+ * Name the dsh model a hosted session's compaction summarizes through, inside
+ * the composition this plugin authors.
+ *
+ * Compaction summarizes by making an ordinary llm call, and it resolves that
+ * call's target from `config.summarizationProvider` / `config.summarizationModel`
+ * when both are set — otherwise from the agent's routed model
+ * (`packages/compaction/compaction-basic/src/summarizer.ts` `resolveTarget`).
+ * For a hosted session the routed model IS this plugin's placeholder route
+ * (`external/default`), whose `stream()` fails loud by design, so without this
+ * pair every compaction attempt there dies with `HOSTED_ENGINE_ROUTE` — caught
+ * by the `agent/pre-step` listener as a warning, so the turn continues but the
+ * session log never shrinks.
+ *
+ * The plugin writes the pair HERE because there is nowhere else to write it: a
+ * profile-patch row replaces the whole `config` of the row it names, and the
+ * patch index only descends into a `group: true` row's `config` array — a
+ * preset's entries live in `config.plugins`, a plain field, so naming the pair
+ * from the profile means re-declaring the entire `standard` composition. The
+ * composition the plugin authors itself is therefore the one place a
+ * deployment-side value can reach a nested row.
+ *
+ * The two keys land in `entryId`'s own `config:` mapping: an existing `config:`
+ * block is merged into (never duplicated, and without emitting a key the entry
+ * already carries), and a missing one is appended after the entry's last key at
+ * the entry's own indentation. Text without the entry, and any call with an
+ * undefined target, comes back byte for byte unchanged.
+ * @param text - the composition text (typically the stripped `standard`).
+ * @param target - the summarization model to write, or undefined to do nothing.
+ * @param entryId - id of the entry whose `config` receives the pair.
+ * @returns the composition text carrying the pair under `entryId`.
+ */
+export declare function applySummarizerTarget(text: string, target: SummarizerTarget | undefined, entryId?: string): string;
+/** Minimal read seam over the host's preset roster, per harness generation. */
+export interface PresetCompositionSource {
+    /** 0.1.5 line: read one preset's composition text; throws when the id is unknown. */
+    read?(id: string): Promise<string>;
+    /** 0.1.7 line: read one preset's document; `content` is the composition text. */
+    readDocument?(id: string): Promise<{
+        readonly content: string;
+    }>;
+}
+/**
+ * Regenerate every hosted engine's preset under the dsh home's user preset root
+ * from the roster's `standard` preset. Idempotent: an up-to-date directory is
+ * untouched, so no standing mount sees a spurious file-stamp change.
+ * @param dshHome - the resolved harness home.
+ * @param source - the roster's composition reader.
+ * @param target - the summarization model to write into every copy, or
+ *   undefined to leave the copies exactly as the strip left them.
+ * @returns whether any file was written.
+ * @throws when the source preset cannot be read or the writes fail.
+ */
+export declare function ensureEnginePresets(dshHome: string, source: PresetCompositionSource, target?: SummarizerTarget): Promise<boolean>;
+/**
+ * Regenerate every hosted engine's preset as an `insert` row in the profile
+ * patch the plugin already manages, from the roster's `standard` preset.
+ *
+ * This is the 0.1.7 mechanism: a preset there is a composed plugin row, and the
+ * user preset root is not read at all — so a preset written as a directory
+ * would simply never register, leaving the roster without the id every hosted
+ * session records. The rows go in the profile's own `cordis.patch.yml` because
+ * that is the one composition layer the plugin owns: it is already the file the
+ * managed block lives in, it is applied after the bundle's own preset rows, and
+ * a rewrite of it is what the harness's live patch reload picks up.
+ *
+ * Idempotent: an up-to-date region is left byte for byte alone, so a rewrite
+ * that changes nothing does not touch the file's stamp.
+ * @param patchPath - absolute path of the profile's patch file.
+ * @param source - the roster's composition reader.
+ * @param target - the summarization model to write into every copy, or
+ *   undefined to leave the copies exactly as the strip left them.
+ * @returns whether the patch file was written.
+ * @throws when the source preset cannot be read or the write fails.
+ */
+export declare function ensureEnginePresetRows(patchPath: string, source: PresetCompositionSource, target?: SummarizerTarget): Promise<boolean>;
+//# sourceMappingURL=preset.d.ts.map

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

@@ -0,0 +1,245 @@
+/**
+ * Hosted-engine provider route placeholder.
+ *
+ * Every hosted engine logs its sessions' request/header with ONE shared provider
+ * label ({@link HOSTED_ROUTE_LABEL}, `external`) rather than a model endpoint the
+ * harness llm registry serves — the engine owns its model natively. The web
+ * host derives a session's model selection from that header and refuses a turn
+ * whose provider no registered adapter serves, so without a placeholder route
+ * the SECOND prompt of every hosted session fails with `model-unavailable`.
+ *
+ * One label for every hosted engine, because the browser model catalog is built
+ * per Host GENERATION and does not require (or vary by) a Session
+ * (`packages/api/session-controller/src/catalog.ts`). A per-engine label would
+ * therefore show one provider group per engine in every session's menu at once —
+ * four identical `default` entries — so they are collapsed into this one route.
+ *
+ * Serving the label is only half of it. The model menu renders the session's
+ * selection through the catalog, and a provider group that advertises no models
+ * is dropped (`packages/api/session-controller/src/catalog.ts`, non-empty
+ * groups only) — leaving the seat to show the raw `provider/model` string, i.e.
+ * a model that does not exist to any adapter. So the placeholder advertises
+ * exactly ONE entry, {@link HOSTED_DEFAULT_MODEL}:
+ * `{ provider: HOSTED_ROUTE_LABEL, id: 'default', name: 'default' }`. The id is
+ * the same string every engine logs as its model label, which is what makes the
+ * seat resolve the session's `(provider, model)` to this entry and render the
+ * engine's own word for "whatever it decides" instead of a composite string
+ * (see {@link HOSTED_DEFAULT_MODEL} for the host-side mechanism).
+ *
+ * The entry is not a model this plugin can serve: {@link HostedEngineRouteAdapter.stream}
+ * fails loud, because a real model call reaching one of these routes means a
+ * session the harness loop drives was handed an engine label — a wiring bug,
+ * not a request. Two things keep that from happening: a session switched back
+ * to `in-process` has the deployment default written into its log
+ * (`model-selection-reset.ts`), and a session BUILT on `in-process` whose
+ * selection is one of these labels has it replaced by the same authority before
+ * the host installs it (same module, `guardFor`).
+ *
+ * @module dsh-loop-engine-allinone/provider-route
+ */
+import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, ModelModality, StreamChunk } from '@deepseek-ai/dsh-llm';
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+import { type EngineModel } from './engine-registry.ts';
+import type { HostedEngineId } from './settings.ts';
+/**
+ * Context window this plugin declares for the hosted route when a deployment
+ * pins none: 262144 tokens (256 Ki).
+ *
+ * The number exists because dsh's own auto-compaction sizes its pressure
+ * threshold from the routed model's declared capacity
+ * (`packages/compaction/compaction-basic/src/config.ts` `resolveCompactSpec` —
+ * `contextWindow * thresholdRatio`, ratio defaulting to `0.8`). A hosted engine
+ * reports no capacity at all: its model lives inside its own child process, so
+ * the placeholder route is the only place dsh can read one. 256 Ki is the round
+ * window the hosted CLIs in use expose; a deployment whose engine window is
+ * smaller, or whose engines differ, should set `engineContextWindow` to the
+ * smallest window in use (see `src/index.ts`).
+ */
+export declare const DEFAULT_ENGINE_CONTEXT_WINDOW = 262144;
+/**
+ * The input modalities this route's single entry declares: text AND image.
+ *
+ * Every hosted engine is handed the images of the step's own messages —
+ * `pi`/`kimi` as bytes over their RPC/ACP channels, `codex` as a `localImage`
+ * path the app-server opens itself, `claude-code` as base64 blocks appended to
+ * the prompt's streaming input message (the prompt's image placeholder still
+ * names the readable path; see `docs/driver-core.md` §2 and
+ * `docs/engine-claude.md` §9.1). The capability
+ * therefore belongs to the route, which is what the host asks about; which
+ * shape of handover an engine gets is that engine's business, not the session's.
+ */
+export declare const HOSTED_MODEL_MODALITIES: readonly ModelModality[];
+/**
+ * The provider route label one hosted engine logs into its sessions'
+ * request/header.
+ *
+ * **Two kinds of label, on purpose.**
+ *
+ * An engine that declares its own model catalog (`descriptor.models`,
+ * `engine-registry.ts`) gets a route of ITS OWN, named by its engine id. The
+ * model menu then shows a group per such engine — `agy` holding
+ * `default` plus Gemini/Claude ids — and picking one passes that id to the
+ * engine.
+ *
+ * Every other engine keeps the shared {@link HOSTED_ROUTE_LABEL} (`external`)
+ * with its single `default`. That is not a leftover: the browser model catalog
+ * is built per Host GENERATION rather than per session
+ * (`packages/api/session-controller/src/catalog.ts`), so a group per engine
+ * would put eight identical `default` rows in every session's menu — the exact
+ * noise the shared label exists to avoid. A group only earns its place in that
+ * menu by carrying models the others do not.
+ *
+ * Both kinds stay registered, so a session logged either way keeps resolving.
+ * @param engine - the hosted engine whose route label is asked for.
+ * @returns that engine's route label.
+ */
+export declare function hostedRouteLabelOf(engine: HostedEngineId): string;
+/**
+ * The hosted engine whose own route a provider label names, if any.
+ *
+ * The inverse of the per-engine half of {@link hostedRouteLabelOf}, for the
+ * places that must attribute a selection to an engine — chiefly the refusal a
+ * driver owes when a session picks a model belonging to a DIFFERENT engine.
+ * @param provider - a provider label from a selection.
+ * @returns the engine that label belongs to, or undefined for the shared route
+ *   and for anything that is not one of this plugin's routes.
+ */
+export declare function hostedEngineOfRouteLabel(provider: string): HostedEngineId | undefined;
+/**
+ * Whether a provider is one of this plugin's hosted engine route labels — a
+ * label some hosted engine logs (now, or in an earlier build), which no adapter
+ * serves a real model on.
+ *
+ * The OLD four per-engine labels are members on purpose, even though only
+ * {@link HOSTED_ROUTE_LABEL} is registered. A pre-existing session's header
+ * still names one of them; treating only the current label as hosted would let
+ * such a session keep the stale selection, and the host — which finds no
+ * adapter serving `kimi` any more — would refuse its next turn
+ * (`model-unavailable`). Membership here is what lets `model-selection-reset`
+ * rewrite the seat to `external/default` (or the deployment default) first.
+ * @param provider - the provider of any selection, header, or default.
+ * @returns whether that provider is a hosted engine's route label.
+ */
+export declare function isHostedProviderRoute(provider: string): boolean;
+/**
+ * Placeholder adapter serving the one hosted engine provider route label.
+ *
+ * It advertises the single menu entry ({@link HOSTED_DEFAULT_MODEL}) so the
+ * model seat can name the session's selection, carries the route's display name
+ * ({@link HOSTED_ROUTE_NAME}) so the catalog's provider group is labelled
+ * `external`, and {@link stream} fails loud: a call reaching it means a real model
+ * query was routed to an engine that owns its model natively — a wiring bug, not
+ * a request to serve.
+ *
+ * It also DECLARES a context window for the route ({@link resolveModel}): the
+ * window is what dsh's auto-compaction measures its pressure threshold against,
+ * and a hosted engine reports no capacity of its own, so without one the hosted
+ * session never compacts.
+ */
+export declare class HostedEngineRouteAdapter extends LlmAdapter {
+    /**
+     * Capacity this route declares, normalized at construction.
+     *
+     * A deployment knob rather than a constant because the engines' real windows
+     * differ; the adapter only guarantees the value the registry's validation
+     * accepts (a positive integer), so a non-positive or non-integer wire value
+     * cannot reach the compaction path as a nonsense window.
+     */
+    private readonly contextWindow;
+    /**
+     * @param contextWindow - declared context capacity in tokens. A value that is
+     *   not a positive integer (absent included) falls back to
+     *   {@link DEFAULT_ENGINE_CONTEXT_WINDOW}.
+     */
+    /**
+     * The provider label this adapter was registered for, echoed by every method
+     * (the registry rejects an identity mismatch).
+     */
+    private readonly label;
+    /**
+     * 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".
+     */
+    private readonly models;
+    /**
+     * The name this route's group shows in the model menu.
+     *
+     * A separate field from {@link label}: the label is the WIRE value (the engine
+     * id, which the registry compares against the registration), while this is what
+     * a human reads. Conflating them would put `agy` in the menu instead of
+     * `Antigravity`.
+     */
+    private readonly displayName;
+    /**
+     * @param contextWindow - declared context capacity in tokens.
+     * @param label - the provider label this adapter serves (a wire value).
+     * @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);
+    /**
+     * Name the route's one entry.
+     *
+     * `id` must equal the provider the adapter was registered for (the registry
+     * rejects a mismatch — `packages/llm/llm/src/index.ts` `prepareRoutes`), so it
+     * is echoed back; `name` is the one localized string the catalog carries.
+     * @param provider - the route this adapter is registered for.
+     * @returns the route's display metadata.
+     */
+    providerInfo(provider: string): LlmProviderInfo;
+    /**
+     * Advertise the route's single entry.
+     *
+     * The id is the model label the engine logs, so the picker resolves a hosted
+     * session's selection to this entry (and highlights its row) rather than
+     * falling through to the raw composite string; the name is the same word,
+     * rendered as-is.
+     *
+     * {@link HOSTED_MODEL_MODALITIES} is declared, not left absent, because the
+     * host reads it as a capability: `packages/api/session-controller/src/commands.ts`
+     * refuses a prompt carrying an image when the session's model declares
+     * modalities that exclude `image`, and `LlmModelInfo` documents an absent
+     * field as UNKNOWN. A hosted session's fate for an attached image therefore
+     * has to be something this plugin SAYS, not something a missing field happens
+     * to allow — while a field this plugin omits, or the harness stops treating
+     * as unknown, silently turns every hosted session image-blind.
+     *
+     * No capacity is declared here, because `LlmModelInfo` (the catalog shape this
+     * method returns) has no context field at all; the window rides
+     * {@link resolveModel}, the shape the harness asks about capacity through.
+     * @returns the one entry this route advertises.
+     */
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    /**
+     * Resolve the route's one entry for the exact model label asked about, with
+     * the context window dsh needs to size auto-compaction.
+     *
+     * The capacity rides HERE rather than on {@link listModels}' entry because the
+     * two are different harness concepts: `LlmModelInfo` — what the catalog and
+     * the model menu read — has no capacity field, while `LlmResolvedModelInfo` —
+     * what `ctx.llm.resolveModelInfo` returns — carries the optional
+     * `context: { contextWindow }`. dsh's compaction pressure path calls the
+     * latter for the session's latest routed model
+     * (`packages/compaction/compaction-basic/src/index.ts` `compactIfNeeded`) and
+     * throws `TargetPressureConfigError` — swallowed into a one-time warning, so
+     * compaction simply never fires — when it comes back without a window. A
+     * hosted session's log therefore only stays bounded because this method
+     * answers with one.
+     *
+     * `provider` and `id` are echoed exactly as asked: `normalizeModelInfo`
+     * (`packages/llm/llm/src/index.ts`) rejects a result whose identity does not
+     * match the query, and the model label a hosted session logged is the engine's
+     * own word (`default`, or whatever a deployment pinned in `config.model`), not
+     * always {@link HOSTED_DEFAULT_MODEL}. `name` is the same string, matching the
+     * advertised entry, since `LlmModelInfo.name` is rendered verbatim.
+     * @param provider - the route this adapter is registered for.
+     * @param model - the exact model label the session's `request/header` logged.
+     * @param _signal - unused; resolution is synchronous.
+     * @returns the route's entry with its declared context window.
+     */
+    resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    stream(_options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
+//# sourceMappingURL=provider-route.d.ts.map